NETWORKING tworzenie połączeń sieciowych gniazda UDP, TCP klasy transportowe klasy protokółów programowanie asynchroniczne
Jan 11, 2016
NETWORKING
tworzenie połączeń sieciowych
gniazda UDP, TCP
klasy transportowe
klasy protokółów
programowanie asynchroniczne
gniazda UDP
- odbiorca
Socket listener =
new Socket(AddressFamily.InterNetwork,
SocketType.Dgram, ProtocolType.Udp);
IPEndPoint localEP = // adres odbiorcy
new IPEndPoint(IPAddress.Any, 5001);
listener.Bind(localEP);
IPEndPoint tempRemoteEP = // adres nadawcy
new IPEndPoint(IPAddress.Any, 5002);
EndPoint trEP = (EndPoint)tempRemoteEP;
listener.Poll(-1, SelectMode.SelectRead);
listener.ReceiveFrom(buffer, ref trEP);
- nadawca
string listener = "localhost";
Socket client =
new Socket(AddressFamily.InterNetwork,
SocketType.Dgram, ProtocolType.Udp);
IPEndPoint localEP = // adres nadawcy
new IPEndPoint(IPAddress.Any, 5002);
client.Bind(localEP);
buffer = Encoding.ASCII.GetBytes(message);
ipaddress = Dns.GetHostEntry(listener).AddressList[0];
IPEndPoint remoteEP = // adres odbiorcy
new IPEndPoint(ipaddress, 5001);
client.SendTo(buffer, 0, buffer.Length,
SocketFlags.None, remoteEP);
UDPSocket
gniazda TCP
- odbiorca
Socket GetListenerSocket(string host, int port)
{
Socket s = null, ts;
IPEndPoint lep;
IPHostEntry iphe = Dns.GetHostEntry(host);
foreach(IPAddress ipa in iphe.AddressList)
{
lep = new IPEndPoint(ipa, port);
ts = new Socket(lep.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
try
{
ts.Bind(lep);
ts.Listen(2); // max 2 waiting connections
s = ts;
break;
}
catch ( . . . )
{ . . . }
return s;
}
Socket server = GetListenerSocket("localhost", 5010);
Socket s = server.Accept();
byte[] responseData = new byte[128];
int bytesRead;
try
{
bytesRead = s.Receive(responseData);
. . .
}
catch . . .
{
...
}
- nadawca
Socket GetSocket(string host, int port)
{
Socket s = null, ts;
IPEndPoint ipe;
IPHostEntry iphe = ns.GetHostEntry(host);
foreach(IPAddress ipa in iphe.AddressList)
{
ipe = new IPEndPoint(ipa, port);
ts = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{ ts.Connect(ipe);
s = ts;
break; }
catch ( . . .) { . . .}
}
return s;
}
Socket s = GetSocket("localhost", 5010);
if(s == null)
return;
s.Send(buffer); TCPSocket
klasa transportowa UDP UdpClient
- odbiorca
UdpClient listener = new UdpClient(port);
IPEndPoint remoteEp = new IPEndPoint(IPAddress.Any, port);
byte[] buffer =
listener.Receive(ref remoteEp);
- nadawca
UdpClient client = new UdpClient(port);
byte[] buffer = Encoding.ASCII.GetBytes(message);
client.Send(buffer, buffer.Length, listener, port);
client.Close();
UDPClass
klasy transportowe TCP TcpListener TcpClient
- odbiorca
TcpListener listener = new TcpListener(port);
listener.Start();
if (listener.Pending())
{ TcpClient s = listener.AcceptTcpClient();
NetworkStream stream = s.GetStream(); }
//
int bytesRead = stream.Read(responseData, 0, responseData.Length); // byte[]
- nadawca
TcpClient client = new TcpClient();
client.Connect(listener, port);
NetworkStream stream = client.GetStream();
stream.Write(buffer, 0, buffer.Length);
//
if (stream.DataAvailable)
bytesRead =
stream.Read(buffer, 0, buffer.Length);
TCPClasses
przesyłanie z wykorzystaniem protokółu SOAP
- odbiorca
NetworkStream ns = tcpclient.GetStream();
SoapFormatter channel = new SoapFormatter();
message = (string)channel.Deserialize(ns);
- nadawca
SoapFormatter channel = new SoapFormatter();
channel.Serialize(tcpclient.GetStream(), message); TCPSOAP
klasy protokółów - FTP
- klasa WebClient
Uri libra = new Uri (@"ftp://man.put.poznan.pl/Nowy.txt");
if (libra.Scheme != Uri.UriSchemeFtp) return;
WebClient request = new WebClient();
request.Credentials = new NetworkCredential(name, pass);//
request.DownloadFile(libra.ToString(), @"Nowy.txt"); //
request.UploadFile(libra.ToString(), @"Nowy.txt"); Get1
- klasy FtpWebRequest FtpWebResponse
Uri libra = new Uri(@"ftp://man.put.poznan.pl");
FtpWebRequest request = (FtpWebRequest)FtpWebRequest.Create(libra);
request.Credentials = new NetworkCredential(name, pass);
request.UseBinary = false;
request.Method = WebRequestMethods.Ftp.ListDirectory;
FtpWebResponse response = (FtpWebResponse)request.GetResponse();
Stream responseStream = response.GetResponseStream(); Get2
klasy protokółów - HTTP, HTTPS, FILE
- WebClient
string address = @"http://www.cs.put.poznan.pl/jkniat/HT.html";
// @"https://poczta.put.poznan.pl"
// @"file://D:/HT.html
WebClient wc = new WebClient();
//
Console.WriteLine(Encoding.ASCII.GetString (wc.DownloadData(address)));
//
wc.DownloadFile(address, "HTcopy.html");Get1
- WebRequest WebResponse
string address = @"http://www.cs.put.poznan.pl/jkniat/HT.html";
WebRequest request = WebRequest.Create(address);
WebResponse response = request.GetResponse();
StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.ASCII);
Console.WriteLine(reader.ReadToEnd());
Get2, HTTPpage
programowanie asynchroniczne
- TCP Socket Server
ManualResetEvent AcceptEvent = new ManualResetEvent(false);
//
ManualResetEvent ReceiveEvent = new ManualResetEvent(false);
// synchronizacja wątków za pomocą zgłaszania // zdarzeń i oczekiwania na zdarzenia:// .WaitOne() .Set() .Reset()
void Start()
{
Socket srv = GetLisSocket ("localhost", port);
AcceptEvent.Reset();
ReceiveEvent.Reset();
srv.BeginAccept( new AsyncCallback(AcceptCallback), srv);
AcceptEvent.WaitOne(); // oczekiwanie na sygnał
}
void AcceptCallback(IAsyncResult result)
{Socket temp = (Socket) result.AsyncState;
Socket a = temp.EndAccept(result);
asyncData.socket = a;
IAsyncResult recres = a.BeginReceive(ad.RecBytes,
0, 256, 0,
new AsyncCallback(ReceiveCallback),
ad);
ReceiveEvent.WaitOne(); // oczekiwanie
AcceptEvent.Set(); // sygnał dla Start
}
void ReceiveCallback(IAsyncResult result)
{
int bytes = ad.socket.EndReceive(result); if (bytes > 0) {
string data = Encoding.ASCII.GetString(ad.RecBytes, 0, bytes); Console.WriteLine("Odebrano: [" + data + "]\n");
}
ReceiveEvent.Set(); // sygnał dla AcceptCallback
}
AsyTCP
- HTTP
string address = @"http://www.cs.put.poznan.pl";
WebRequest request = WebRequest.Create(address);
AsyncResponseData ad = new AsyncResponseData(request);
IAsyncResult responseResult =
request.BeginGetResponse
(new AsyncCallback(ResponseCallback),
ad);
void ResponseCallback(IAsyncResult result)
{AsyncResponseData ar = (AsyncResponseData)result.AsyncState;
WebRequest request = ar.Request;
WebResponse response = request.EndGetResponse(result);
Stream stream = response.GetResponseStream();
AsyncReadData ad = new AsyncReadData(stream);
IAsyncResult readResult = stream.BeginRead(ad.Buffer, 0, ad.Buffer.Length, new AsyncCallback(ReadCallback), ad);
. . . } AsyPage