static void Main(string[] args)
{
UdpClient udpServer = new UdpClient(9000);
IPAddress ip = IPAddress.Loopback;
IPEndPoint RemoteIpEndPoint = new IPEndPoint(ip, 9000);
try
{
Console.WriteLine("Server is ready");
while (true)
{
Byte[] receiveBytes = udpServer.Receive(ref RemoteIpEndPoint);
string recivedData = Encoding.ASCII.GetString(receiveBytes);
Console.WriteLine(recivedData);
string metode = recivedData.Split(" ")[0];
double vaerdi = Convert.ToDouble(recivedData.Split(" ")[1]);
string message = "";
switch (metode.ToLower())
{
case "tildanske":
double tilDKK = ValutaConverter.TilDanske(vaerdi);
message = tilDKK.ToString() + " DKK";
break;
case "tilsvenske":
double tilSWE = ValutaConverter.TilSvenske(vaerdi);
message = tilSWE.ToString() + " SWE";
break;
}
Byte[] sendBytes = Encoding.ASCII.GetBytes(message);
udpServer.Send(sendBytes, sendBytes.Length, RemoteIpEndPoint);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void TilSvenskeKronerTest()
{
// arrange
double danskeKroner = 10;
//act - vores resultat
double result = ValutaConverter.TilSvenskeKroner(danskeKroner);
//assert
Assert.AreEqual(14.202, result, 0.001); // vi bruger delta til at vide hvor mange betydende cifte (efter komma) vi vil have
}
public void TilDanskeKronerTest()
{
//arrange - Data vi vil teste på:
double svenskeKroner = 10; // Vi tager 10 svenske kroner vi vil konvertere til danske kroner
//act - Vi refererer til class'en vi vil teste på - her: ValutaConverter.
double result = ValutaConverter.TilDanskeKroner(svenskeKroner); // Vi gemmer den i en variabel "result", så vi kan måle om den er korrekt.
//assert - hvordan skal tingene agere i din kode, hvad er resultatet:
Assert.AreEqual(7.041, result, 0.001);// Vi tester om de to er ens - vores forventede resultat (de 10 svenske til danske) og det faktiske resultat.
}
public void KonverterTilSvenske()
{
//arrange
double danskeKroner = 10;
//act
double result = ValutaConverter.TilSvenske(danskeKroner);
//assert
Assert.AreEqual(14.202, result, Delta);
}
public void KonverterTilDanske()
{
//arrange
double svenskeKroner = 10;
//act
double result = ValutaConverter.TilDanske(svenskeKroner);
//assert
Assert.AreEqual(7.041, result, Delta);
}
public static void DoClient(TcpClient socket)
{
Stream ns = socket.GetStream();
StreamReader sr = new StreamReader(ns);
StreamWriter sw = new StreamWriter(ns);
sw.AutoFlush = true;
sw.WriteLine("You are connected!!");
while (true)
{
string message = sr.ReadLine();
string metode = message.Split(" ")[0];
double vaerdi = Convert.ToDouble(message.Split(" ")[1]);
switch (metode.ToLower())
{
case "tildanske":
double tilDKK = ValutaConverter.TilDanske(vaerdi);
sw.WriteLine($"{tilDKK} DKK");
break;
case "tilsvenske":
double tilSWE = ValutaConverter.TilSvenske(vaerdi);
sw.WriteLine($"{tilSWE} SWE");
break;
}
}
}
// Når Client er færdig med ovenstående, ryger den herned:
public static void DoClient(TcpClient socket) // modtager TcpClient vi kalder socket
{
// serverens måde at håndtere kommunikation frem og tilbage fra TcpClient og TcpServer
Stream ns = socket.GetStream(); // vi tager fat i vores TcpClient og siger "vi skal have fat i din stream" og gemmer det i en variabel, så vi kan tilgå den
StreamReader sr = new StreamReader(ns); // vi sender vores stream med den (ns)
StreamWriter sw = new StreamWriter(ns); //
sw.AutoFlush = true;
sw.WriteLine("You are connected"); // vi skriver til StreamWriteren, så vi kan teste, at vi er connected
while (true) // vi vil gerne holde forbindelsen åben så længe vi har noget at spørge om
{
string message = sr.ReadLine(); // vi skal have vores server til at vente på en besked fra TcpClient'en. En ny variabel (message) skal være lig med den besked vi venter at få fra klienten.
string metode = message.Split(" ")[0]; // vi tager fat i den besked vi har fået fra klienten og splitter den på mellemrum, så får vi en liste af strenge ud, der er sepereret på mellemrum.
double vaerdi = Convert.ToDouble(message.Split(" ")[1]);
switch (metode.ToLower()) // vi laver en switch på metoden
{
case "tildanske":
double tilDKK = ValutaConverter.TilDanskeKroner(vaerdi); // resultatet vi skal give til klienten gemmer vi i en variabel
sw.WriteLine($"{tilDKK} DKK"); // det vi skriver tilbage til klienten
break;
case "tilsvenske":
double tilSEK = ValutaConverter.TilSvenskeKroner(vaerdi); // resultatet vi skal give til klienten gemmer vi i en variabel
sw.WriteLine($"{tilSEK} SEK"); // det vi skriver tilbage til klienten
break;
// i sockettest.exe programmet skriver man metoden efterfulgt af værdien, fx. tildanske 10
}
}
}
[Route("TilSvenskeKroner/{danskeKroner}")] // grunde til at vi skriver {} i Route er, at Frameworket bagved så forstår at det er dynamisk - altså er den kan skifte værdi, så vi kan kalde forskellige værdier fra vores view
public double Get(double danskeKroner)
{
return(ValutaConverter.TilSvenskeKroner(danskeKroner));
}
[Route("TilDanskeKroner/{svenskeKroner}")] // vigtigt vi har styr på vores routing. Dvs den måde vores service er bygget op på. Det er vigtigt vi differentierer mellem de to forskellige services vi har. Den ligger som en "under-route" til vores Converter - det er en del af URL'en.
public double TilDanskeKroner(double svenskeKroner) // vi ved at returtypen kommer til at være en double. Vi kalder den TilDanske (tidl. Get())
{
return(ValutaConverter.TilDanskeKroner(svenskeKroner)); // vi sender de svenske kroner
}
static void Main(string[] args)
{
// Det vi gør her, det er, at vi sætter noget server op - siger vi skal have en UdpClient på den her server, vi skal have fat i ting fra det her EndPoint. Altså: Vi sætter UDP-serveren op.
// Creates an udp Client for reading incoming data
UdpClient udpServer = new UdpClient(9000);
//Creates an IPEndPoint to record the IP Address and port number of the sender
IPAddress ip = IPAddress.Loopback; //Loopback - lyt på "localhost". Hvilken IP-adresse den skal køre på (Localhost)
IPEndPoint RemoteIpEndPoint = new IPEndPoint(ip, 9000); // Hvilken IP-adresse den skal modtage data fra.
//IPEndPoint object will allow us to read datagrams sent from another source.
//Vi bruger en Upp-Client til at sende, emulere en udp-server kan man kalde det, fordi der ikke er noget der hedder en udp-server som sådan, altså der er ikke nogen class i C#, der hedder det.
try
{
Console.WriteLine("Server is ready"); //Så ved vi at serveren er nået dertil hvor den er klar til at tage imod data
while (true) //Fordi vi gerne vil have, at man kan blive ved med at kommunikere til den / modtage data
{
//Og så siger vi til den - tag imod de her bytes, på den her port, som vi har sat ovenover.
Byte[] receivedBytes = udpServer.Receive(ref RemoteIpEndPoint); // ReceivedBytes vil vi gerne modtage fra den her modtager (RemoteIpEndPoint - fra ovenover)
//Så siger vi: "De her bytes vi har modtaget, dem vil vi gerne have oversat til en string.
string receivedData = Encoding.ASCII.GetString(receivedBytes); //Det har noget at gøre med den måde Udp sender på, der bliver man nødt til at konvertere tingene, fordi det ikke underforstået nødvendigvis er i bestemt format.
Console.WriteLine(receivedData);
//I TcpConverter'en har jeg lavet noget, der minder lidt om. Kig i Server.cs.- metode, værdi, switch. Det bruges nærmest ens her:
string metode = receivedData.Split(" ")[0]; // split på mellemrum på 0 (1. plads)
double vaerdi = Convert.ToDouble(receivedData.Split(" ")[1]); // split på mellemrum på 1 (2. plads)
//Vi skal have encoded det tilbage til bytes, så vi kan sende det igen - så vi gøre sådan her:
string message = "";
switch (metode.ToLower()) // vi laver en switch på metoden
{
case "tildanske":
double tilDKK = ValutaConverter.TilDanskeKroner(vaerdi);
message = tilDKK.ToString() + " DKK";
break;
case "tilsvenske":
double tilSEK = ValutaConverter.TilSvenskeKroner(vaerdi);
message = tilSEK.ToString() + " SEK";
break;
}
//Så skal vi have encoded det til bytes, så vi siger:
Byte[] sendBytes = Encoding.ASCII.GetBytes(message);
udpServer.Send(sendBytes, sendBytes.Length, RemoteIpEndPoint);
//Ovenstående konvetrer vi "message" tilbage til at være nogle bytes, så fordi når man sender med udp, skal man have det man sender; Bytes, hvad er længden på det man sender, så modtageren ved hvornår alt er modtaget, samt hvem modtageren er. Det er egentlig det der skal til, for at lave Upp-serveren.
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public double TilDanske(double svenskeKroner)
{
return(ValutaConverter.TilDanske(svenskeKroner));
}
