networking tworzenie połączeń sieciowych · gniazda udp, tcp · klasy transportowe
Post on 11-Jan-2016
33 Views
Preview:
DESCRIPTION
TRANSCRIPT
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
top related