networking tworzenie połączeń sieciowych · gniazda udp, tcp · klasy transportowe

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


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


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

networking tworzenie połączeń sieciowych · gniazda udp, tcp · klasy transportowe

Documents