Makofske D.B. TCP-IP sockets in C-sharp.Practical guide for programmers
Подождите немного. Документ загружается.
118 Chapter 4: Beyond the Basics
■
method for the callback:
AsyncCallback ac = new AsyncCallback(myMethodToCall);
:
:
:
public static void myMethodToCall(IAsyncResult result) {
// callback code goes here
}
If no callback method is required, this argument can be null (although remember that
the end method must be invoked somewhere). The callback method itself must have the
signature public static void <callbackMethodName>(IAsyncResult). The IAsyncResult
class will be discussed in a moment.
The object argument is simply a way to convey user-defined information from the
caller to the callback. This information could be the NetworkStream or socket class instance
itself, or a user-defined class that includes both the NetworkStream, the byte buffer being
used, and anything else to which the application callback method needs access.
The BeginRead() and BeginWrite() methods also have a different return type: an
IAsyncResult instance. The IAsyncResult represents the status of the asynchronous
operation and can be used to poll or block on the return of that operation. If you decide
to block waiting for the operation to complete, the IAsyncResult’s AsyncWaitHandle
property contains a method called WaitOne(). Invoking this method will block until the
corresponding end method is called.
Once the asynchronous operation completes, the callback method is invoked. The
callback method receives an IAsyncResult instance as an argument, which has a property
called AsyncState that will contain an object. This object is the same object that was
passed to the begin method, and needs to be cast to its original type before being used.
The IAsyncResult instance is also used as the argument to the end call. The end call
completes the symmetry of the call and returns the result of the call. That result is the
exact same value that the synchronous version of the call would have returned.
public override int EndRead(IAsyncResult asyncResult);
public override void EndWrite(IAsyncResult asyncResult);
As an example let’s assume that BeginRead() is called on a NetworkStream instance,
and in addition to the usual arguments passed a callback method (new AsyncCall-
back(myCallback)) and the read byte buffer as the state. The EndRead() call will return
the number of bytes read from the NetworkStream, the same as a synchronous call to
Read() would have.
public static void myCallback(IAsyncResult result) {
byte[] buffer = (byte[])result.AsyncState;
int bytesRead = EndRead(result);
Console.WriteLine("Got {0} bytes of: {1}", bytesread, buffer);
}
■
4.4 Asynchronous I/O 119
Once you understand the differences between the synchronous and asynchronous
versions of one method, the basic concepts can be extrapolated to cover the entire .NET
asynchronous API. In summary, it involves:
1. Begin Method: The begin call takes (in addition to the arguments in the syn-
chronous version of the method) an AsyncCallback instance specifying the callback
method and an object containing any user-defined state. The begin call returns an
IAsyncResult that can be used to poll or block on the call’s return.
2. Callback State: The callback method is passed the state (the begin call’s object
argument) stored in the AsyncState property of the IAsyncResult instance.
3. End Method: The end method call takes as an argument the IAsyncResult instance
returned by the callback invocation, and returns the value that the synchronous
version of the call would have returned.
Figure 4.1 shows a pictorial depiction of how a BeginSend() call executes.
Table 4.2 lists some of the .NET classes used in this book that have asynchronous
methods (this is not a complete list of all asynchronous methods .NET provides).
Main Thread
New Thread
Create Socket
Connect
Call BeginSend
Send occurs
concurrently
Other Processing
Continues
Send Completes
SendCallBack
Call EndSend
Send
Callback
is invoked
EndSend returns the number of bytes
sent if Send was successful, or throws
a
SocketExce
p
tion if it was unsuccessful
Figure 4.1: Asynchronous Send() example.
120 Chapter 4: Beyond the Basics
■
Class Asynchronous Method API
Dns BeginGetHostByName()/EndGetHostByName()
BeginResolve()/EndResolve()
FileStream BeginRead()/EndRead()
BeginWrite()/EndWrite()
NetworkStream BeginRead()/EndRead()
BeginWrite()/EndWrite()
Socket BeginAccept()/EndAccept()
BeginConnect()/EndConnect()
BeginReceive()/EndReceive()
BeginReceiveFrom()/EndReceiveFrom()
BeginSend()/EndSend()
BeginSendTo()/EndSendTo()
Stream BeginRead()/EndRead()
BeginWrite()/EndWrite()
Table 4.2: Selected .NET Asynchronous Methods
Its time to look at some examples. Below we implement versions of TcpEchoClient
and TcpEchoServer from Chapter 2 using the asynchronous API. The assumption in both
cases is that the program has other operations it needs to be performing while blocking
on the various network calls. To simulate that we added a simple doOtherStuff() method,
which just loops five times, printing output and sleeping.
You will also note that the number of asynchronous methods defined for the Socket
class is significantly more than what is defined for NetworkStream. In order to demon-
strate the contrast between the two, the echo client uses the TcpClient class with a
NetworkStream, and the echo server uses the Socket class.
TcpEchoClientAsync.cs
0 using System; // For String, IAsyncResult, ArgumentException
1 using System.Text; // For Encoding
2 using System.Net.Sockets; // For TcpClient, NetworkStream
3 using System.Threading; // For ManualResetEvent
4
5 class ClientState {
6 // Object to contain client state, including the network stream
7 // and the send/recv buffer
■
4.4 Asynchronous I/O 121
8
9 private byte[] byteBuffer;
10 private NetworkStream netStream;
11 private StringBuilder echoResponse;
12 private int totalBytesRcvd = 0; // Total bytes received so far
13
14 public ClientState(NetworkStream netStream, byte[] byteBuffer) {
15 this.netStream = netStream;
16 this.byteBuffer = byteBuffer;
17 echoResponse = new StringBuilder();
18 }
19
20 public NetworkStream NetStream {
21 get {
22 return netStream;
23 }
24 }
25
26 public byte[] ByteBuffer {
27 set {
28 byteBuffer = value;
29 }
30 get {
31 return byteBuffer;
32 }
33 }
34
35 public void AppendResponse(String response) {
36 echoResponse.Append(response);
37 }
38 public String EchoResponse {
39 get {
40 return echoResponse.ToString();
41 }
42 }
43
44 public void AddToTotalBytes(int count) {
45 totalBytesRcvd += count;
46 }
47 public int TotalBytes {
48 get {
49 return totalBytesRcvd;
50 }
122 Chapter 4: Beyond the Basics
■
51 }
52 }
53
54 class TcpEchoClientAsync {
55
56 // A manual event signal we will trigger when all reads are complete:
57 public static ManualResetEvent ReadDone = new ManualResetEvent(false);
58
59 static void Main(string[] args) {
60
61 if ((args.Length < 2) || (args.Length > 3)) { // Test for correct # of args
62 throw new ArgumentException("Parameters: <Server> <Word> [<Port>]");
63 }
64
65 String server = args[0]; // Server name or IP address
66
67 // Use port argument if supplied, otherwise default to 7
68 int servPort = (args.Length == 3) ? Int32.Parse(args[2]) : 7;
69
70 Console.WriteLine("Thread {0} ({1}) - Main()",
71 Thread.CurrentThread.GetHashCode(),
72 Thread.CurrentThread.ThreadState);
73 // Create TcpClient that is connected to server on specified port
74 TcpClient client = new TcpClient();
75
76 client.Connect(server, servPort);
77 Console.WriteLine("Thread {0} ({1}) - Main(): connected to server",
78 Thread.CurrentThread.GetHashCode(),
79 Thread.CurrentThread.ThreadState);
80
81 NetworkStream netStream = client.GetStream();
82 ClientState cs = new ClientState(netStream,
83 Encoding.ASCII.GetBytes(args[1]));
84 // Send the encoded string to the server
85 IAsyncResult result = netStream.BeginWrite(cs.ByteBuffer, 0,
86 cs.ByteBuffer.Length,
87 new AsyncCallback(WriteCallback),
88 cs);
89
90 doOtherStuff();
91
92 result.AsyncWaitHandle.WaitOne(); // block until EndWrite is called
93
■
4.4 Asynchronous I/O 123
94 // Receive the same string back from the server
95 result = netStream.BeginRead(cs.ByteBuffer, cs.TotalBytes,
96 cs.ByteBuffer.Length - cs.TotalBytes,
97 new AsyncCallback(ReadCallback), cs);
98
99 doOtherStuff();
100
101 ReadDone.WaitOne(); // Block until ReadDone is manually set
102
103 netStream.Close(); // Close the stream
104 client.Close(); // Close the socket
105 }
106
107 public static void doOtherStuff() {
108 for (int x=1; x<=5; x++) {
109 Console.WriteLine("Thread {0} ({1}) - doOtherStuff(): {2}...",
110 Thread.CurrentThread.GetHashCode(),
111 Thread.CurrentThread.ThreadState, x);
112 Thread.Sleep(1000);
113 }
114 }
115
116 public static void WriteCallback(IAsyncResult asyncResult) {
117
118 ClientState cs = (ClientState) asyncResult.AsyncState;
119
120 cs.NetStream.EndWrite(asyncResult);
121 Console.WriteLine("Thread {0} ({1}) - WriteCallback(): Sent {2} bytes...",
122 Thread.CurrentThread.GetHashCode(),
123 Thread.CurrentThread.ThreadState, cs.ByteBuffer.Length);
124 }
125
126 public static void ReadCallback(IAsyncResult asyncResult) {
127
128 ClientState cs = (ClientState) asyncResult.AsyncState;
129
130 int bytesRcvd = cs.NetStream.EndRead(asyncResult);
131
132 cs.AddToTotalBytes(bytesRcvd);
133 cs.AppendResponse(Encoding.ASCII.GetString(cs.ByteBuffer, 0, bytesRcvd));
134
135 if (cs.TotalBytes < cs.ByteBuffer.Length) {
136
Console.WriteLine("Thread {0} ({1}) - ReadCallback(): Received {2} bytes...",
124 Chapter 4: Beyond the Basics
■
137 Thread.CurrentThread.GetHashCode(),
138 Thread.CurrentThread.ThreadState, bytesRcvd);
139 cs.NetStream.BeginRead(cs.ByteBuffer, cs.TotalBytes,
140 cs.ByteBuffer.Length - cs.TotalBytes,
141 new AsyncCallback(ReadCallback), cs.NetStream);
142 } else {
143 Console.WriteLine("Thread {0} ({1}) - ReadCallback():
144 Received {2} total " + "bytes: {3}",
145 Thread.CurrentThread.GetHashCode(),
146 Thread.CurrentThread.ThreadState, cs.TotalBytes,
147 cs.EchoResponse);
148 ReadDone.Set(); // Signal read complete event
149 }
150 }
151 }
TcpEchoClientAsync.cs
1. ClientState class: lines 5–52
The ClientState class is used to store the send/receive buffer, NetworkStream,
the echo response, and a total byte count. It is used to pass state to the callback
methods.
2. Argument parsing: lines 61–68
3. Print state, TcpClient creation and setup: lines 70–79
Create a TcpClient instance and connect to the remote server.
4. Store state in ClientState instance: lines 81–82
Create a ClientState instance and store the network stream and command-line
input bytes to be sent.
5. Call BeginWrite: lines 84–88
Call BeginWrite() with the standard Write() arguments plus a user-defined call-
back method of WriteCallback() (wrapped in an AsyncCallback delegate instance)
and a state object reference to the user-defined ClientState.
6. Perform asynchronous processing, then block: lines 90–92
Call doOtherStuff() to simulate asynchronous processing, then use the Async-
WaitHandle property of the IAsyncResult to call WaitOne(), which blocks until
EndWrite() is called.
■
4.4 Asynchronous I/O 125
7. Call BeginRead: lines 94–97
Call BeginRead() with the standard Read() arguments plus a user-defined callback
method of ReadCallback() (wrapped in an AsyncCallback delegate instance) and a
state object reference to the user-defined ClientState.
8. Perform asynchronous processing, then block: lines 99–101
Call doOtherStuff() to simulate asynchronous processing, then use the Manual-
ResetEvent class instance ReadDone to call WaitOne(), which blocks until Read-
Done() has been set. Note that we cannot use the IAsyncResult from the BeginRead()
in this case, because that would unblock us after the first read, and we may have
multiple reads.
9. Close the stream and socket: lines 103–104
10. doOtherStuff(): lines 107–114
Simulate other processing by writing some output in a loop with Thread.Sleep()
prolonging the intervals slightly.
11. WriteCallback(): lines 116–124
■
Retrieve the state object: lines 118
The write callback state object was a ClientState instance, so store it as
a local variable by casting the IAsyncResult instance property AsyncState as a
ClientState.
■
EndWrite(): line 120
Call the EndWrite() method to complete the operation.
■
Output the number of bytes sent: lines 121–123
12. ReadCallback(): lines 126–150
■
Retrieve the state object: lines 128–130
The read callback state object was a ClientState instance, so store it as a
local variable by casting the IAsyncResult instance property AsyncState as
a ClientState. Create local variables where convenient.
■
Issue another BeginRead(): lines 135–142
If the length of the response is less than the expected response, issue another
BeginRead() to get the remaining bytes.
■
Output the echo response: lines 143–148
If all bytes have been received, output the echo response.
■
Trigger ManualResetEvent: line 149
Manually trigger the ReadDone ManualResetEvent so we can unblock if we are
blocking on read completion.
TcpEchoServerAsync.cs
0 using System; // For Console, IAsyncResult, ArgumentException
1 using System.Net; // For IPEndPoint
126 Chapter 4: Beyond the Basics
■
2 using System.Net.Sockets; // For Socket
3 using System.Threading; // For ManualResetEvent
4
5 class ClientState {
6 // Object to contain client state, including the client socket
7 // and the receive buffer
8
9 private const int BUFSIZE = 32; // Size of receive buffer
10 private byte[] rcvBuffer;
11 private Socket clntSock;
12
13 public ClientState(Socket clntSock) {
14 this.clntSock = clntSock;
15 rcvBuffer = new byte[BUFSIZE]; // Receive buffer
16 }
17
18 public byte[] RcvBuffer {
19 get {
20 return rcvBuffer;
21 }
22 }
23
24 public Socket ClntSock {
25 get {
26 return clntSock;
27 }
28 }
29 }
30
31 class TcpEchoServerAsync {
32
33 private const int BACKLOG = 5; // Outstanding connection queue max size
34
35 static void Main(string[] args) {
36
37 if (args.Length != 1) // Test for correct # of args
38 throw new ArgumentException("Parameters: <Port>");
39
40 int servPort = Int32.Parse(args[0]);
41
42 // Create a Socket to accept client connections
43 Socket servSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
44 ProtocolType.Tcp);
■
4.4 Asynchronous I/O 127
45
46 servSock.Bind(new IPEndPoint(IPAddress.Any, servPort));
47 servSock.Listen(BACKLOG);
48
49 for (;;) { // Run forever, accepting and servicing connections
50 Console.WriteLine("Thread {0} ({1}) - Main(): calling BeginAccept()",
51 Thread.CurrentThread.GetHashCode(),
52 Thread.CurrentThread.ThreadState);
53
54
IAsyncResult result = servSock.BeginAccept(new AsyncCallback(AcceptCallback),
55 servSock);
56 doOtherStuff();
57
58 // Wait for the EndAccept before issuing a new BeginAccept
59 result.AsyncWaitHandle.WaitOne();
60 }
61 }
62
63 public static void doOtherStuff() {
64 for (int x=1; x<=5; x++) {
65 Console.WriteLine("Thread {0} ({1}) - doOtherStuff(): {2}...",
66 Thread.CurrentThread.GetHashCode(),
67 Thread.CurrentThread.ThreadState, x);
68 Thread.Sleep(1000);
69 }
70 }
71
72 public static void AcceptCallback(IAsyncResult asyncResult) {
73
74 Socket servSock = (Socket) asyncResult.AsyncState;
75 Socket clntSock = null;
76
77 try {
78
79 clntSock = servSock.EndAccept(asyncResult);
80
81
Console.WriteLine("Thread {0} ({1}) - AcceptCallback(): handling client at {2}",
82 Thread.CurrentThread.GetHashCode(),
83 Thread.CurrentThread.ThreadState,
84 clntSock.RemoteEndPoint);
85
86 ClientState cs = new ClientState(clntSock);
87