作为c#程序员，没有精力和激情去学习java了，又遇到一些项目需要开发手机端，于是我们的networkcomms2.3.1网络通讯框架又要出场了，是的，这是一款来自英国的网络通讯框架，由c#语言编写，其在编写时根据不用的应用环境，写了不同的代码，支持安卓，平果，winphone等平台开发。
找了一个类大家看看他的书写方法 ，使用预编译语句，编写针对不同系统的代码
1 public static class NetworkComms
2 {
3 /// <summary>
4 /// Static constructor which sets comm default values
5 /// </summary>
6 static NetworkComms()
7 {
8 //Generally comms defaults are defined here
9 NetworkIdentifier = ShortGuid.NewGuid();
10 NetworkLoadUpdateWindowMS = 2000;
11
12 InterfaceLinkSpeed = 95000000;
13
14 DefaultListenPort = 10000;
15 ListenOnAllAllowedInterfaces = true;
16
17 CheckSumMismatchSentPacketCacheMaxByteLimit = 75000;
18 MinimumSentPacketCacheTimeMinutes = 1;
19
20 ConnectionEstablishTimeoutMS = 10000;
21 PacketConfirmationTimeoutMS = 5000;
22 ConnectionAliveTestTimeoutMS = 1000;
23
24 #if SILVERLIGHT || WINDOWS_PHONE
25 CurrentRuntimeEnvironment = RuntimeEnvironment.WindowsPhone_Silverlight;
26 SendBufferSizeBytes = ReceiveBufferSizeBytes = 8000;
27 #elif iOS
28 CurrentRuntimeEnvironment = RuntimeEnvironment.Xamarin_iOS;
29 SendBufferSizeBytes = ReceiveBufferSizeBytes = 8000;
30 #elif ANDROID
31 CurrentRuntimeEnvironment = RuntimeEnvironment.Xamarin_Android;
32 SendBufferSizeBytes = ReceiveBufferSizeBytes = 8000;
33 #elif NET2
34 if (Type.GetType("Mono.Runtime") != null)
35 {
36 CurrentRuntimeEnvironment = RuntimeEnvironment.Mono_Net2;
37 //Mono send buffer smaller as different large object heap limit
38 SendBufferSizeBytes = ReceiveBufferSizeBytes = 8000;
39 }
40 else
41 {
42 CurrentRuntimeEnvironment = RuntimeEnvironment.Native_Net2;
43 SendBufferSizeBytes = ReceiveBufferSizeBytes = 80000;
44 }
45 #elif NET35
46 if (Type.GetType("Mono.Runtime") != null)
47 {
48 CurrentRuntimeEnvironment = RuntimeEnvironment.Mono_Net35;
49 //Mono send buffer smaller as different large object heap limit
50 SendBufferSizeBytes = ReceiveBufferSizeBytes = 8000;
51 }
52 else
53 {
54 CurrentRuntimeEnvironment = RuntimeEnvironment.Native_Net35;
55 SendBufferSizeBytes = ReceiveBufferSizeBytes = 80000;
56 }
57 #else
58 if (Type.GetType("Mono.Runtime") != null)
59 {
60 CurrentRuntimeEnvironment = RuntimeEnvironment.Mono_Net4;
61 //Mono send buffer smaller as different large object heap limit
62 SendBufferSizeBytes = ReceiveBufferSizeBytes = 8000;
63 }
64 else
65 {
66 CurrentRuntimeEnvironment = RuntimeEnvironment.Native_Net4;
67 SendBufferSizeBytes = ReceiveBufferSizeBytes = 80000;
68 }
69 #endif
70
71 //We want to instantiate our own thread pool here
72 CommsThreadPool = new CommsThreadPool(1, Environment.ProcessorCount*2, Environment.ProcessorCount * 20, new TimeSpan(0, 0, 10));
73
74 //Initialise the core extensions
75 DPSManager.AddDataSerializer<ProtobufSerializer>();
76
77 DPSManager.AddDataSerializer<NullSerializer>();
78 DPSManager.AddDataProcessor<SevenZipLZMACompressor.LZMACompressor>();
79
80 #if !FREETRIAL
81 //Only the full version includes the encrypter
82 DPSManager.AddDataProcessor<RijndaelPSKEncrypter>();
83 #endif
84
85 #if !WINDOWS_PHONE
86 DPSManager.AddDataSerializer<BinaryFormaterSerializer>();
87 #endif
88
89 InternalFixedSendReceiveOptions = new SendReceiveOptions(DPSManager.GetDataSerializer<ProtobufSerializer>(),
90 new List<DataProcessor>(),
91 new Dictionary<string, string>());
92
93 DefaultSendReceiveOptions = new SendReceiveOptions(DPSManager.GetDataSerializer<ProtobufSerializer>(),
94 new List<DataProcessor>() { DPSManager.GetDataProcessor<SevenZipLZMACompressor.LZMACompressor>() },
95 new Dictionary<string, string>());
96 }
97
98 #region Local Host Information
99 /// <summary>
100 /// Returns the current machine hostname
101 /// </summary>
102 public static string HostName
103 {
104 get
105 {
106 #if WINDOWS_PHONE
107 return Windows.Networking.Connectivity.NetworkInformation.GetInternetConnectionProfile().ToString();
108 #else
109 return Dns.GetHostName();
110 #endif
111 }
112 }
113
114 /// <summary>
115 /// If set NetworkCommsDotNet will only operate on matching IP Addresses. Also see <see cref="AllowedAdaptorNames"/>.
116 /// Correct format is string[] { "192.168", "213.111.10" }. If multiple prefixes are provided the earlier prefix, if found, takes priority.
117 /// </summary>
118 public static string[] AllowedIPPrefixes { get; set; }
119
120 /// <summary>
121 /// If set NetworkCommsDotNet will only operate on specified adaptors. Correct format is string[] { "eth0", "en0", "wlan0" }.
122 /// </summary>
123 public static string[] AllowedAdaptorNames { get; set; }
124
125 /// <summary>
126 /// Returns all allowed local IP addresses.
127 /// If <see cref="AllowedAdaptorNames"/> has been set only returns IP addresses corresponding with specified adaptors.
128 /// If <see cref="AllowedIPPrefixes"/> has been set only returns matching addresses ordered in descending preference. i.e. Most preffered at [0].
129 /// </summary>
130 /// <returns></returns>
131 public static List<IPAddress> AllAllowedIPs()
132 {
133
134 #if WINDOWS_PHONE
135 //On windows phone we simply ignore ip addresses from the autoassigned range as well as those without a valid prefix
136 List<IPAddress> allowedIPs = new List<IPAddress>();
137
138 foreach (var hName in Windows.Networking.Connectivity.NetworkInformation.GetHostNames())
139 {
140 if (!hName.DisplayName.StartsWith("169.254"))
141 {
142 if (AllowedIPPrefixes != null)
143 {
144 bool valid = false;
145
146 for (int i = 0; i < AllowedIPPrefixes.Length; i++)
147 valid |= hName.DisplayName.StartsWith(AllowedIPPrefixes[i]);
148
149 if(valid)
150 allowedIPs.Add(IPAddress.Parse(hName.DisplayName));
151 }
152 else
153 allowedIPs.Add(IPAddress.Parse(hName.DisplayName));
154 }
155 }
156
157 return allowedIPs;
158 #else
159
160 //We want to ignore IP‘s that have been autoassigned
161 //169.254.0.0
162 IPAddress autoAssignSubnetv4 = new IPAddress(new byte[] { 169, 254, 0, 0 });
163 //255.255.0.0
164 IPAddress autoAssignSubnetMaskv4 = new IPAddress(new byte[] { 255, 255, 0, 0 });
165
166 List<IPAddress> validIPAddresses = new List<IPAddress>();
167 IPComparer comparer = new IPComparer();
168
169 #if ANDROID
170
171 var iFaces = Java.Net.NetworkInterface.NetworkInterfaces;
172 while (iFaces.HasMoreElements)
173 {
174 bool interfaceValid = false;
175 var iFace = iFaces.NextElement() as Java.Net.NetworkInterface;
176 var javaAddresses = iFace.InetAddresses;
177
178 while (javaAddresses.HasMoreElements)
179 {
180 var javaAddress = javaAddresses.NextElement() as Java.Net.InetAddress;
181 IPAddress address = default(IPAddress);
182 if (IPAddress.TryParse(javaAddress.HostAddress, out address))
183 {
184 if (address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.InterNetworkV6)
185 {
186 if (AllowedAdaptorNames != null)
187 {
188 foreach (var id in AllowedAdaptorNames)
189 if (id == iFace.Name)
190 {
191 interfaceValid = true;
192 break;
193 }
194 }
195 else
196 interfaceValid = true;
197
198 if (interfaceValid)
199 break;
200 }
201 }
202 }
203
204 if (!interfaceValid)
205 continue;
206
207 javaAddresses = iFace.InetAddresses;
208
209 while (javaAddresses.HasMoreElements)
210 {
211 var javaAddress = javaAddresses.NextElement() as Java.Net.InetAddress;
212 IPAddress address = default(IPAddress);
213
214 if (IPAddress.TryParse(javaAddress.HostAddress, out address))
215 {
216 if (address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.InterNetworkV6)
217 {
218 if (!IsAddressInSubnet(address, autoAssignSubnetv4, autoAssignSubnetMaskv4))
219 {
220 bool allowed = false;
221
222 if (AllowedAdaptorNames != null)
223 {
224 foreach (var id in AllowedAdaptorNames)
225 {
226 if (id == iFace.Name)
227 {
228 allowed = true;
229 break;
230 }
231 }
232 }
233 else
234 allowed = true;
235
236 if (!allowed)
237 continue;
238
239 allowed = false;
240
241 if (AllowedIPPrefixes != null)
242 {
243 foreach (var ip in AllowedIPPrefixes)
244 {
245 if (comparer.Equals(address.ToString(), ip))
246 {
247 allowed = true;
248 break;
249 }
250 }
251 }
252 else
253 allowed = true;
254
255 if (!allowed)
256 continue;
257
258 if (address != IPAddress.None)
259 validIPAddresses.Add(address);
260 }
261 }
262 }
263 }
264 }
265
266 #else
267
268
269 foreach (var iFace in NetworkInterface.GetAllNetworkInterfaces())
270 {
271 bool interfaceValid = false;
272 var unicastAddresses = iFace.GetIPProperties().UnicastAddresses;
273
274 foreach (var address in unicastAddresses)
275 {
276 if (address.Address.AddressFamily == AddressFamily.InterNetwork || address.Address.AddressFamily == AddressFamily.InterNetworkV6)
277 {
278 if (AllowedAdaptorNames != null)
279 {
280 foreach (var id in AllowedAdaptorNames)
281 if (iFace.Id == id)
282 {
283 interfaceValid = true;
284 break;
285 }
286 }
287 else
288 interfaceValid = true;
289
290 if (interfaceValid)
291 break;
292 }
293 }
294
295 if (!interfaceValid)
296 continue;
297
298 foreach (var address in unicastAddresses)
299 {
300 var addressInformation = address.Address;
301 if (addressInformation.AddressFamily == AddressFamily.InterNetwork || addressInformation.AddressFamily == AddressFamily.InterNetworkV6)
302 {
303 if (!IsAddressInSubnet(addressInformation, autoAssignSubnetv4, autoAssignSubnetMaskv4))
304 {
305 bool allowed = false;
306
307 if (AllowedAdaptorNames != null)
308 {
309 foreach (var id in AllowedAdaptorNames)
310 {
311 if(id == iFace.Id)
312 {
313 allowed = true;
314 break;
315 }
316 }
317 }
318 else
319 allowed = true;
320
321 if (!allowed)
322 continue;
323
324 allowed = false;
325
326 if (AllowedIPPrefixes != null)
327 {
328 foreach (var ip in AllowedIPPrefixes)
329 {
330 if (comparer.Equals(addressInformation.ToString(), ip))
331 {
332 allowed = true;
333 break;
334 }
335 }
336 }
337 else
338 allowed = true;
339
340 if (!allowed)
341 continue;
342
343 if (addressInformation != IPAddress.None)
344 validIPAddresses.Add(addressInformation);
345 }
346 }
347 }
348 }
349 #endif
350
351 if (AllowedIPPrefixes != null)
352 {
353 validIPAddresses.Sort((a, b) =>
354 {
355 for (int i = 0; i < AllowedIPPrefixes.Length; i++)
356 {
357 if (a.ToString().StartsWith(AllowedIPPrefixes[i]))
358 {
359 if (b.ToString().StartsWith(AllowedIPPrefixes[i]))
360 return 0;
361 else
362 return -1;
363 }
364 else if (b.ToString().StartsWith(AllowedIPPrefixes[i]))
365 return 1;
366 }
367
368 return 0;
369 });
370 }
371
372 return validIPAddresses;
373 #endif
374 }
375
376 /// <summary>
377 /// Custom comparer for IP addresses. Used by <see cref="AllAllowedIPs"/>
378 /// </summary>
379 class IPComparer : IEqualityComparer<string>
380 {
381 // Products are equal if their names and product numbers are equal.
382 public bool Equals(string x, string y)
383 {
384 //Check whether the compared objects reference the same data.
385 if (Object.ReferenceEquals(x, y)) return true;
386
387 //Check whether any of the compared objects is null.
388 if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
389 return false;
390
391 return (y.StartsWith(x) || x.StartsWith(y));
392 }
393
394 // If Equals() returns true for a pair of objects
395 // then GetHashCode() must return the same value for these objects.
396 public int GetHashCode(string ipAddress)
397 {
398 return ipAddress.GetHashCode();
399 }
400 }
401
402 /// <summary>
403 /// Returns true if the provided address exists within the provided subnet.
404 /// </summary>
405 /// <param name="address">The address to check, i.e. 192.168.0.10</param>
406 /// <param name="subnet">The subnet, i.e. 192.168.0.0</param>
407 /// <param name="mask">The subnet mask, i.e. 255.255.255.0</param>
408 /// <returns>True if address is in the provided subnet</returns>
409 public static bool IsAddressInSubnet(IPAddress address, IPAddress subnet, IPAddress mask)
410 {
411 if (address == null) throw new ArgumentNullException("address", "Provided IPAddress cannot be null.");
412 if (subnet == null) throw new ArgumentNullException("subnet", "Provided IPAddress cannot be null.");
413 if (mask == null) throw new ArgumentNullException("mask", "Provided IPAddress cannot be null.");
414
415 //Catch for IPv6
416 if (subnet.AddressFamily == AddressFamily.InterNetworkV6 ||
417 mask.AddressFamily == AddressFamily.InterNetworkV6)
418 throw new NotImplementedException("This method does not yet support IPv6. Please contact NetworkComms.Net support if you would like this functionality.");
419 //If we have provided IPV4 subnets and masks and we have an ipv6 address then return false
420 else if (address.AddressFamily == AddressFamily.InterNetworkV6)
421 return false;
422
423 byte[] addrBytes = address.GetAddressBytes();
424 byte[] maskBytes = mask.GetAddressBytes();
425 byte[] maskedAddressBytes = new byte[addrBytes.Length];
426
427 //Catch for IPv6
428 if (maskBytes.Length < maskedAddressBytes.Length)
429 return false;
430
431 for (int i = 0; i < maskedAddressBytes.Length; ++i)
432 maskedAddressBytes[i] = (byte)(addrBytes[i] & maskBytes[i]);
433
434 IPAddress maskedAddress = new IPAddress(maskedAddressBytes);
435 bool equal = subnet.Equals(maskedAddress);
436
437 return equal;
438 }
439
440 /// <summary>
441 /// The default port NetworkCommsDotNet will operate on
442 /// </summary>
443 public static int DefaultListenPort { get; set; }
444
445 /// <summary>
446 /// The local identifier for this instance of NetworkCommsDotNet. This is an application unique identifier.
447 /// </summary>
448 public static ShortGuid NetworkIdentifier { get; private set; }
449
450 /// <summary>
451 /// The current runtime environment. Detected automatically on startup. Performance may be adversly affected if this is changed.
452 /// </summary>
453 public static RuntimeEnvironment CurrentRuntimeEnvironment { get; set; }
454
455 /// <summary>
456 /// An internal random object
457 /// </summary>
458 internal static Random randomGen = new Random();
459
460 /// <summary>
461 /// A single boolean used to control a NetworkCommsDotNet shutdown
462 /// </summary>
463 internal static volatile bool commsShutdown;
464
465 /// <summary>
466 /// A running total of the number of packets sent on all connections. Used to initialise packet sequence counters to ensure duplicates can not occur.
467 /// </summary>
468 internal static long totalPacketSendCount;
469
470 /// <summary>
471 /// The number of millisconds over which to take an instance load (CurrentNetworkLoad) to be used in averaged values (AverageNetworkLoad).
472 /// Default is 2000ms. Shorter values can be used but less than 200ms may cause significant errors in the value of returned value, especially in mono environments.
473 /// </summary>
474 public static int NetworkLoadUpdateWindowMS { get; set; }
475
476 private static double currentNetworkLoadIncoming;
477 private static double currentNetworkLoadOutgoing;
478 #if !WINDOWS_PHONE && !ANDROID
479 private static Thread NetworkLoadThread = null;
480 private static CommsMath currentNetworkLoadValuesIncoming;
481 private static CommsMath currentNetworkLoadValuesOutgoing;
482 private static ManualResetEvent NetworkLoadThreadWait;
483 #endif
484
485 /// <summary>
486 /// The interface link speed in bits/sec used for network load calculations. Default is 100Mb/sec
487 /// </summary>
488 public static long InterfaceLinkSpeed { get; set; }
489
490 /// <summary>
491 /// Returns the current instance network usage, as a value between 0 and 1. Returns the largest value for any available network adaptor. Triggers load analysis upon first call.
492 /// </summary>
493 public static double CurrentNetworkLoadIncoming
494 {
495 get
496 {
497 #if !WINDOWS_PHONE && !ANDROID
498 //We start the load thread when we first access the network load
499 //this helps cut down on uncessary threads if unrequired
500 if (!commsShutdown && NetworkLoadThread == null)
501 {
502 lock (globalDictAndDelegateLocker)
503 {
504 if (!commsShutdown && NetworkLoadThread == null)
505 {
506 currentNetworkLoadValuesIncoming = new CommsMath();
507 currentNetworkLoadValuesOutgoing = new CommsMath();
508
509 NetworkLoadThread = new Thread(NetworkLoadWorker);
510 NetworkLoadThread.Name = "NetworkLoadThread";
511 NetworkLoadThread.Start();
512 }
513 }
514 }
515 #endif
516 return currentNetworkLoadIncoming;
517 }
518 private set { currentNetworkLoadIncoming = value; }
519 }
520
521 /// <summary>
522 /// Returns the current instance network usage, as a value between 0 and 1. Returns the largest value for any available network adaptor. Triggers load analysis upon first call.
523 /// </summary>
524 public static double CurrentNetworkLoadOutgoing
525 {
526 get
527 {
528 #if !WINDOWS_PHONE && !ANDROID
529 //We start the load thread when we first access the network load
530 //this helps cut down on uncessary threads if unrequired
531 if (!commsShutdown && NetworkLoadThread == null)
532 {
533 lock (globalDictAndDelegateLocker)
534 {
535 if (!commsShutdown && NetworkLoadThread == null)
536 {
537 currentNetworkLoadValuesIncoming = new CommsMath();
538 currentNetworkLoadValuesOutgoing = new CommsMath();
539
540 NetworkLoadThread = new Thread(NetworkLoadWorker);
541 NetworkLoadThread.Name = "NetworkLoadThread";
542 NetworkLoadThread.Start();
543 }
544 }
545 }
546 #endif
547 return currentNetworkLoadOutgoing;
548 }
549 private set { currentNetworkLoadOutgoing = value; }
550 }
551
552 /// <summary>
553 /// Returns the averaged value of CurrentNetworkLoadIncoming, as a value between 0 and 1, for a time window of upto 254 seconds. Triggers load analysis upon first call.
554 /// </summary>
555 /// <param name="secondsToAverage">Number of seconds over which historial data should be used to arrive at an average</param>
556 /// <returns>Average network load as a double between 0 and 1</returns>
557 public static double AverageNetworkLoadIncoming(byte secondsToAverage)
558 {
559 #if !WINDOWS_PHONE && !ANDROID
560
561 if (!commsShutdown && NetworkLoadThread == null)
562 {
563 lock (globalDictAndDelegateLocker)
564 {
565 if (!commsShutdown && NetworkLoadThread == null)
566 {
567 currentNetworkLoadValuesIncoming = new CommsMath();
568 currentNetworkLoadValuesOutgoing = new CommsMath();
569
570 NetworkLoadThread = new Thread(NetworkLoadWorker);
571 NetworkLoadThread.Name = "NetworkLoadThread";
572 NetworkLoadThread.Start();
573 }
574 }
575 }
576
577 return currentNetworkLoadValuesIncoming.CalculateMean((int)((secondsToAverage * 1000.0) / NetworkLoadUpdateWindowMS));
578 #else
579 return 0;
580 #endif
581 }
582
583 /// <summary>
584 /// Returns the averaged value of CurrentNetworkLoadIncoming, as a value between 0 and 1, for a time window of upto 254 seconds. Triggers load analysis upon first call.
585 /// </summary>
586 /// <param name="secondsToAverage">Number of seconds over which historial data should be used to arrive at an average</param>
587 /// <returns>Average network load as a double between 0 and 1</returns>
588 public static double AverageNetworkLoadOutgoing(byte secondsToAverage)
589 {
590 #if !WINDOWS_PHONE && !ANDROID
591 if (!commsShutdown && NetworkLoadThread == null)
592 {
593 lock (globalDictAndDelegateLocker)
594 {
595 if (!commsShutdown && NetworkLoadThread == null)
596 {
597 currentNetworkLoadValuesIncoming = new CommsMath();
598 currentNetworkLoadValuesOutgoing = new CommsMath();
599
600 NetworkLoadThread = new Thread(NetworkLoadWorker);
601 NetworkLoadThread.Name = "NetworkLoadThread";
602 NetworkLoadThread.Start();
603 }
604 }
605 }
606
607 return currentNetworkLoadValuesOutgoing.CalculateMean((int)((secondsToAverage * 1000.0) / NetworkLoadUpdateWindowMS));
608 #else
609 return 0;
610 #endif
611 }
612
613 /// <summary>
614 /// Determines the most appropriate local end point to contact the provided remote end point.
615 /// Testing shows this method takes on average 1.6ms to return.
616 /// </summary>
617 /// <param name="remoteIPEndPoint">The remote end point</param>
618 /// <returns>The selected local end point</returns>
619 public static IPEndPoint BestLocalEndPoint(IPEndPoint remoteIPEndPoint)
620 {
621 if (remoteIPEndPoint == null) throw new ArgumentNullException("remoteIPEndPoint", "Provided IPEndPoint cannot be null.");
622
623 #if WINDOWS_PHONE
624 var t = Windows.Networking.Sockets.DatagramSocket.GetEndpointPairsAsync(new Windows.Networking.HostName(remoteIPEndPoint.Address.ToString()), remoteIPEndPoint.Port.ToString()).AsTask();
625 if (t.Wait(20) && t.Result.Count > 0)
626 {
627 var enumerator = t.Result.GetEnumerator();
628 enumerator.MoveNext();
629
630 var endpointPair = enumerator.Current;
631 return new IPEndPoint(IPAddress.Parse(endpointPair.LocalHostName.DisplayName.ToString()), int.Parse(endpointPair.LocalServiceName));
632 }
633 else
634 throw new ConnectionSetupException("Unable to determine correct local end point.");
635 #else
636 //We use UDP as its connectionless hence faster
637 IPEndPoint result;
638 using (Socket testSocket = new Socket(remoteIPEndPoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp))
639 {
640 testSocket.Connect(remoteIPEndPoint);
641 result = (IPEndPoint)testSocket.LocalEndPoint;
642 }
643
644 return result;
645 #endif
646 }
647
648 #if !WINDOWS_PHONE && !ANDROID
649 /// <summary>
650 /// Takes a network load snapshot (CurrentNetworkLoad) every NetworkLoadUpdateWindowMS
651 /// </summary>
652 private static void NetworkLoadWorker()
653 {
654 NetworkLoadThreadWait = new ManualResetEvent(false);
655
656 //Get all interfaces
657 NetworkInterface[] interfacesToUse = NetworkInterface.GetAllNetworkInterfaces();
658
659 long[] startSent, startReceived, endSent, endReceived;
660
661 while (!commsShutdown)
662 {
663 try
664 {
665 //we need to look at the load across all adaptors, by default we will probably choose the adaptor with the highest usage
666 DateTime startTime = DateTime.Now;
667
668 IPv4InterfaceStatistics[] stats = new IPv4InterfaceStatistics[interfacesToUse.Length];
669 startSent = new long[interfacesToUse.Length];
670 startReceived = new long[interfacesToUse.Length];
671
672 for (int i = 0; i < interfacesToUse.Length; ++i)
673 {
674 stats[i] = interfacesToUse[i].GetIPv4Statistics();
675 startSent[i] = stats[i].BytesSent;
676 startReceived[i] = stats[i].BytesReceived;
677 }
678
679 if (commsShutdown) return;
680
681 //Thread.Sleep(NetworkLoadUpdateWindowMS);
682 NetworkLoadThreadWait.WaitOne(NetworkLoadUpdateWindowMS);
683
684 if (commsShutdown) return;
685
686 stats = new IPv4InterfaceStatistics[interfacesToUse.Length];
687 endSent = new long[interfacesToUse.Length];
688 endReceived = new long[interfacesToUse.Length];
689
690 for (int i = 0; i < interfacesToUse.Length; ++i)
691 {
692 stats[i] = interfacesToUse[i].GetIPv4Statistics();
693 endSent[i] = stats[i].BytesSent;
694 endReceived[i] = stats[i].BytesReceived;
695 }
696
697 DateTime endTime = DateTime.Now;
698
699 List<double> outUsage = new List<double>();
700 List<double> inUsage = new List<double>();
701 for(int i=0; i<startSent.Length; i++)
702 {
703 outUsage.Add((double)(endSent[i] - startSent[i]) / ((double)(InterfaceLinkSpeed * (endTime - startTime).TotalMilliseconds) / 8000));
704 inUsage.Add((double)(endReceived[i] - startReceived[i]) / ((double)(InterfaceLinkSpeed * (endTime - startTime).TotalMilliseconds) / 8000));
705 }
706
707 //double loadValue = Math.Max(outUsage.Max(), inUsage.Max());
708 double inMax = double.MinValue, outMax = double.MinValue;
709 for (int i = 0; i < startSent.Length; ++i)
710 {
711 if (inUsage[i] > inMax) inMax = inUsage[i];
712 if (outUsage[i] > outMax) outMax = outUsage[i];
713 }
714
715 //If either of the usage levels have gone above 2 it suggests we are most likely on a faster connection that we think
716 //As such we will bump the interfacelinkspeed upto 1Gbps so that future load calcualtions more acurately reflect the
717 //actual load.
718 if (inMax > 2 || outMax > 2) InterfaceLinkSpeed = 950000000;
719
720 //Limit to one
721 CurrentNetworkLoadIncoming = (inMax > 1 ? 1 : inMax);
722 CurrentNetworkLoadOutgoing = (outMax > 1 ? 1 : outMax);
723
724 currentNetworkLoadValuesIncoming.AddValue(CurrentNetworkLoadIncoming);
725 currentNetworkLoadValuesOutgoing.AddValue(CurrentNetworkLoadOutgoing);
726
727 //We can only have upto 255 seconds worth of data in the average list
728 int maxListSize = (int)(255000.0 / NetworkLoadUpdateWindowMS);
729 currentNetworkLoadValuesIncoming.TrimList(maxListSize);
730 currentNetworkLoadValuesOutgoing.TrimList(maxListSize);
731 }
732 catch (Exception ex)
733 {
734 LogError(ex, "NetworkLoadWorker");
735
736 //It may be the interfaces available to the OS have changed so we will reset them here
737 interfacesToUse = NetworkInterface.GetAllNetworkInterfaces();
738 //If an error has happened we dont want to thrash the problem, we wait for 5 seconds and hope whatever was wrong goes away
739 Thread.Sleep(5000);
740 }
741 }
742 }
743 #endif
744 #endregion
745
746 #region Established Connections
747 /// <summary>
748 /// Locker for connection dictionaries
749 /// </summary>
750 internal static object globalDictAndDelegateLocker = new object();
751
752 /// <summary>
753 /// Primary connection dictionary stored by network indentifier
754 /// </summary>
755 internal static Dictionary<ShortGuid, Dictionary<ConnectionType, List<Connection>>> allConnectionsById = new Dictionary<ShortGuid, Dictionary<ConnectionType, List<Connection>>>();
756
757 /// <summary>
758 /// Secondary connection dictionary stored by ip end point. Allows for quick cross referencing.
759 /// </summary>
760 internal static Dictionary<IPEndPoint, Dictionary<ConnectionType, Connection>> allConnectionsByEndPoint = new Dictionary<IPEndPoint, Dictionary<ConnectionType, Connection>>();
761
762 /// <summary>
763 /// Old connection cache so that requests for connectionInfo can be returned even after a connection has been closed.
764 /// </summary>
765 internal static Dictionary<ShortGuid, Dictionary<ConnectionType, List<ConnectionInfo>>> oldNetworkIdentifierToConnectionInfo = new Dictionary<ShortGuid, Dictionary<ConnectionType, List<ConnectionInfo>>>();
766 #endregion
767
768 #region Incoming Data and Connection Config
769 /// <summary>
770 /// Used for switching between async and sync connectionListen modes. Default is false. No noticable performance difference between the two modes.
771 /// </summary>
772 public static bool ConnectionListenModeUseSync { get; set; }
773
774 /// <summary>
775 /// Used for switching between listening on a single interface or multiple interfaces. Default is true. See <see cref="AllowedIPPrefixes"/> and <see cref="AllowedAdaptorNames"/>
776 /// </summary>
777 public static bool ListenOnAllAllowedInterfaces { get; set; }
778
779 /// <summary>
780 /// Receive data buffer size. Default is 80KB. CAUTION: Changing the default value can lead to performance degredation.
781 /// </summary>
782 public static int ReceiveBufferSizeBytes { get; set; }
783
784 /// <summary>
785 /// Send data buffer size. Default is 80KB. CAUTION: Changing the default value can lead to performance degredation.
786 /// </summary>
787 public static int SendBufferSizeBytes { get; set; }
788
789 /// <summary>
790 /// The threadpool used by networkComms.Net to execute incoming packet handlers.
791 /// </summary>
792 public static CommsThreadPool CommsThreadPool { get; set; }
793
794 /// <summary>
795 /// Once we have received all incoming data we handle it further. This is performed at the global level to help support different priorities.
796 /// </summary>
797 /// <param name="itemAsObj">Possible PriorityQueueItem. If null is provided an item will be removed from the global item queue</param>
798 internal static void CompleteIncomingItemTask(object itemAsObj)
799 {
800 if (itemAsObj == null)
801 throw new ArgumentNullException("itemAsObj", "Provided parameter itemAsObj cannot be null.");
802
803 PriorityQueueItem item = null;
804 try
805 {
806 //If the packetBytes are null we need to ask the incoming packet queue for what we should be running
807 item = itemAsObj as PriorityQueueItem;
808
809 if (item == null)
810 throw new InvalidCastException("Cast from object to PriorityQueueItem resulted in null reference, unable to continue.");
811
812 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Handling a " + item.PacketHeader.PacketType + " packet from " + item.Connection.ConnectionInfo + " with a priority of " + item.Priority.ToString() + ".");
813
814 #if !WINDOWS_PHONE
815 if (Thread.CurrentThread.Priority != (ThreadPriority)item.Priority) Thread.CurrentThread.Priority = (ThreadPriority)item.Priority;
816 #endif
817
818 //Check for a shutdown connection
819 if (item.Connection.ConnectionInfo.ConnectionState == ConnectionState.Shutdown) return;
820
821 //We only look at the check sum if we want to and if it has been set by the remote end
822 if (NetworkComms.EnablePacketCheckSumValidation && item.PacketHeader.ContainsOption(PacketHeaderStringItems.CheckSumHash))
823 {
824 var packetHeaderHash = item.PacketHeader.GetOption(PacketHeaderStringItems.CheckSumHash);
825
826 //Validate the checkSumhash of the data
827 string packetDataSectionMD5 = NetworkComms.MD5Bytes(item.DataStream);
828 if (packetHeaderHash != packetDataSectionMD5)
829 {
830 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Warn(" ... corrupted packet detected, expected " + packetHeaderHash + " but received " + packetDataSectionMD5 + ".");
831
832 //We have corruption on a resend request, something is very wrong so we throw an exception.
833 if (item.PacketHeader.PacketType == Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.CheckSumFailResend)) throw new CheckSumException("Corrupted md5CheckFailResend packet received.");
834
835 if (item.PacketHeader.PayloadPacketSize < NetworkComms.CheckSumMismatchSentPacketCacheMaxByteLimit)
836 {
837 //Instead of throwing an exception we can request the packet to be resent
838 Packet returnPacket = new Packet(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.CheckSumFailResend), packetHeaderHash, NetworkComms.InternalFixedSendReceiveOptions);
839 item.Connection.SendPacket(returnPacket);
840 //We need to wait for the packet to be resent before going further
841 return;
842 }
843 else
844 throw new CheckSumException("Corrupted packet detected from " + item.Connection.ConnectionInfo + ", expected " + packetHeaderHash + " but received " + packetDataSectionMD5 + ".");
845 }
846 }
847
848 //Remote end may have requested packet receive confirmation so we send that now
849 if (item.PacketHeader.ContainsOption(PacketHeaderStringItems.ReceiveConfirmationRequired))
850 {
851 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace(" ... sending requested receive confirmation packet.");
852
853 var hash = item.PacketHeader.ContainsOption(PacketHeaderStringItems.CheckSumHash) ? item.PacketHeader.GetOption(PacketHeaderStringItems.CheckSumHash) : "";
854
855 Packet returnPacket = new Packet(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Confirmation), hash, NetworkComms.InternalFixedSendReceiveOptions);
856 item.Connection.SendPacket(returnPacket);
857 }
858
859 //We can now pass the data onto the correct delegate
860 //First we have to check for our reserved packet types
861 //The following large sections have been factored out to make reading and debugging a little easier
862 if (item.PacketHeader.PacketType == Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.CheckSumFailResend))
863 item.Connection.CheckSumFailResendHandler(item.DataStream);
864 else if (item.PacketHeader.PacketType == Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.ConnectionSetup))
865 item.Connection.ConnectionSetupHandler(item.DataStream);
866 else if (item.PacketHeader.PacketType == Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.AliveTestPacket) &&
867 (NetworkComms.InternalFixedSendReceiveOptions.DataSerializer.DeserialiseDataObject<byte[]>(item.DataStream,
868 NetworkComms.InternalFixedSendReceiveOptions.DataProcessors,
869 NetworkComms.InternalFixedSendReceiveOptions.Options))[0] == 0)
870 {
871 //If we have received a ping packet from the originating source we reply with true
872 Packet returnPacket = new Packet(Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.AliveTestPacket), new byte[1] { 1 }, NetworkComms.InternalFixedSendReceiveOptions);
873 item.Connection.SendPacket(returnPacket);
874 }
875
876 //We allow users to add their own custom handlers for reserved packet types here
877 //else
878 if (true)
879 {
880 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Triggering handlers for packet of type ‘" + item.PacketHeader.PacketType + "‘ from " + item.Connection.ConnectionInfo);
881
882 //We trigger connection specific handlers first
883 bool connectionSpecificHandlersTriggered = item.Connection.TriggerSpecificPacketHandlers(item.PacketHeader, item.DataStream, item.SendReceiveOptions);
884
885 //We trigger global handlers second
886 NetworkComms.TriggerGlobalPacketHandlers(item.PacketHeader, item.Connection, item.DataStream, item.SendReceiveOptions, connectionSpecificHandlersTriggered);
887
888 //This is a really bad place to put a garbage collection, comment left in so that it doesn‘t get added again at some later date
889 //We don‘t want the CPU to JUST be trying to garbage collect the WHOLE TIME
890 //GC.Collect();
891 }
892 }
893 catch (CommunicationException)
894 {
895 if (item != null)
896 {
897 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Fatal("A communcation exception occured in CompleteIncomingPacketWorker(), connection with " + item.Connection.ConnectionInfo + " be closed.");
898 item.Connection.CloseConnection(true, 2);
899 }
900 }
901 catch (DuplicateConnectionException ex)
902 {
903 if (item != null)
904 {
905 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Warn(ex.Message != null ? ex.Message : "A possible duplicate connection was detected with " + item.Connection + ". Closing connection.");
906 item.Connection.CloseConnection(true, 42);
907 }
908 }
909 catch (Exception ex)
910 {
911 NetworkComms.LogError(ex, "CompleteIncomingItemTaskError");
912
913 if (item != null)
914 {
915 //If anything goes wrong here all we can really do is log the exception
916 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Fatal("An unhandled exception occured in CompleteIncomingPacketWorker(), connection with " + item.Connection.ConnectionInfo + " be closed. See log file for more information.");
917 item.Connection.CloseConnection(true, 3);
918 }
919 }
920 finally
921 {
922 //We need to dispose the data stream correctly
923 if (item!=null) item.DataStream.Close();
924
925 #if !WINDOWS_PHONE
926 //Ensure the thread returns to the pool with a normal priority
927 if (Thread.CurrentThread.Priority != ThreadPriority.Normal) Thread.CurrentThread.Priority = ThreadPriority.Normal;
928 #endif
929 }
930 }
931 #endregion
932
933 #if !WINDOWS_PHONE
934 #region High CPU Usage Tuning
935 /// <summary>
936 /// In times of high CPU usage we need to ensure that certain time critical functions, like connection handshaking do not timeout.
937 /// This sets the thread priority for those processes.
938 /// </summary>
939 internal static ThreadPriority timeCriticalThreadPriority = ThreadPriority.AboveNormal;
940 #endregion
941 #endif
942
943 #region Checksum Config
944 /// <summary>
945 /// When enabled uses an MD5 checksum to validate all received packets. Default is false, relying on any possible connection checksum alone.
946 /// Also when enabled any packets sent less than CheckSumMismatchSentPacketCacheMaxByteLimit will be cached for a duration to ensure successful delivery.
947 /// Default false.
948 /// </summary>
949 public static bool EnablePacketCheckSumValidation { get; set; }
950
951 /// <summary>
952 /// When checksum validation is enabled sets the limit below which sent packets are cached to ensure successful delivery. Default 75KB.
953 /// </summary>
954 public static int CheckSumMismatchSentPacketCacheMaxByteLimit { get; set; }
955
956 /// <summary>
957 /// When a sent packet has been cached for a possible resend this is the minimum length of time it will be retained. Default is 1.0 minutes.
958 /// </summary>
959 public static double MinimumSentPacketCacheTimeMinutes { get; set; }
960
961 /// <summary>
962 /// Records the last sent packet cache cleanup time. Prevents the sent packet cache from being checked too frequently.
963 /// </summary>
964 internal static DateTime LastSentPacketCacheCleanup { get; set; }
965 #endregion
966
967 #region PacketType Config and Global Handlers
968 /// <summary>
969 /// An internal reference copy of all reservedPacketTypeNames.
970 /// </summary>
971 internal static string[] reservedPacketTypeNames = Enum.GetNames(typeof(ReservedPacketType));
972
973 /// <summary>
974 /// Dictionary of all custom packetHandlers. Key is packetType.
975 /// </summary>
976 static Dictionary<string, List<IPacketTypeHandlerDelegateWrapper>> globalIncomingPacketHandlers = new Dictionary<string, List<IPacketTypeHandlerDelegateWrapper>>();
977
978 /// <summary>
979 /// Dictionary of any non default custom packet unwrappers. Key is packetType.
980 /// </summary>
981 static Dictionary<string, PacketTypeUnwrapper> globalIncomingPacketUnwrappers = new Dictionary<string, PacketTypeUnwrapper>();
982
983 /// <summary>
984 /// Delegate for handling incoming packets. See AppendGlobalIncomingPacketHandler members.
985 /// </summary>
986 /// <typeparam name="T">The type of object which is expected for this handler</typeparam>
987 /// <param name="packetHeader">The <see cref="PacketHeader"/> of the incoming packet</param>
988 /// <param name="connection">The connection with which this packet was received</param>
989 /// <param name="incomingObject">The incoming object of specified type T</param>
990 public delegate void PacketHandlerCallBackDelegate<T>(PacketHeader packetHeader, Connection connection, T incomingObject);
991
992 /// <summary>
993 /// If true any unknown incoming packet types are ignored. Default is false and will result in an error file being created if an unknown packet type is received.
994 /// </summary>
995 public static bool IgnoreUnknownPacketTypes { get; set; }
996
997 /// <summary>
998 /// Add an incoming packet handler using default SendReceiveOptions. Multiple handlers for the same packet type will be executed in the order they are added.
999 /// </summary>
1000 /// <typeparam name="T">The type of incoming object</typeparam>
1001 /// <param name="packetTypeStr">The packet type for which this handler will be executed</param>
1002 /// <param name="packetHandlerDelgatePointer">The delegate to be executed when a packet of packetTypeStr is received</param>
1003 public static void AppendGlobalIncomingPacketHandler<T>(string packetTypeStr, PacketHandlerCallBackDelegate<T> packetHandlerDelgatePointer)
1004 {
1005 AppendGlobalIncomingPacketHandler<T>(packetTypeStr, packetHandlerDelgatePointer, DefaultSendReceiveOptions);
1006 }
1007
1008 /// <summary>
1009 /// Add an incoming packet handler using the provided SendReceiveOptions. Multiple handlers for the same packet type will be executed in the order they are added.
1010 /// </summary>
1011 /// <typeparam name="T">The type of incoming object</typeparam>
1012 /// <param name="packetTypeStr">The packet type for which this handler will be executed</param>
1013 /// <param name="packetHandlerDelgatePointer">The delegate to be executed when a packet of packetTypeStr is received</param>
1014 /// <param name="sendReceiveOptions">The SendReceiveOptions to be used for the provided packet type</param>
1015 public static void AppendGlobalIncomingPacketHandler<T>(string packetTypeStr, PacketHandlerCallBackDelegate<T> packetHandlerDelgatePointer, SendReceiveOptions sendReceiveOptions)
1016 {
1017 if (packetTypeStr == null) throw new ArgumentNullException("packetTypeStr", "Provided packetType string cannot be null.");
1018 if (packetHandlerDelgatePointer == null) throw new ArgumentNullException("packetHandlerDelgatePointer", "Provided PacketHandlerCallBackDelegate<T> cannot be null.");
1019 if (sendReceiveOptions == null) throw new ArgumentNullException("sendReceiveOptions", "Provided SendReceiveOptions cannot be null.");
1020
1021 lock (globalDictAndDelegateLocker)
1022 {
1023
1024 if (globalIncomingPacketUnwrappers.ContainsKey(packetTypeStr))
1025 {
1026 //Make sure if we already have an existing entry that it matches with the provided
1027 if (!globalIncomingPacketUnwrappers[packetTypeStr].Options.OptionsCompatible(sendReceiveOptions))
1028 throw new PacketHandlerException("The proivded SendReceiveOptions are not compatible with existing SendReceiveOptions already specified for this packetTypeStr.");
1029 }
1030 else
1031 globalIncomingPacketUnwrappers.Add(packetTypeStr, new PacketTypeUnwrapper(packetTypeStr, sendReceiveOptions));
1032
1033
1034 //Ad the handler to the list
1035 if (globalIncomingPacketHandlers.ContainsKey(packetTypeStr))
1036 {
1037 //Make sure we avoid duplicates
1038 PacketTypeHandlerDelegateWrapper<T> toCompareDelegate = new PacketTypeHandlerDelegateWrapper<T>(packetHandlerDelgatePointer);
1039
1040 bool delegateAlreadyExists = false;
1041 foreach (var handler in globalIncomingPacketHandlers[packetTypeStr])
1042 {
1043 if (handler == toCompareDelegate)
1044 {
1045 delegateAlreadyExists = true;
1046 break;
1047 }
1048 }
1049
1050 if (delegateAlreadyExists)
1051 throw new PacketHandlerException("This specific packet handler delegate already exists for the provided packetTypeStr.");
1052
1053 globalIncomingPacketHandlers[packetTypeStr].Add(new PacketTypeHandlerDelegateWrapper<T>(packetHandlerDelgatePointer));
1054 }
1055 else
1056 globalIncomingPacketHandlers.Add(packetTypeStr, new List<IPacketTypeHandlerDelegateWrapper>() { new PacketTypeHandlerDelegateWrapper<T>(packetHandlerDelgatePointer) });
1057
1058 if (LoggingEnabled) logger.Info("Added incoming packetHandler for ‘" + packetTypeStr + "‘ packetType.");
1059 }
1060 }
1061
1062 /// <summary>
1063 /// Removes the provided delegate for the specified packet type. If the provided delegate does not exist for this packet type just returns.
1064 /// </summary>
1065 /// <param name="packetTypeStr">The packet type for which the delegate will be removed</param>
1066 /// <param name="packetHandlerDelgatePointer">The delegate to be removed</param>
1067 public static void RemoveGlobalIncomingPacketHandler(string packetTypeStr, Delegate packetHandlerDelgatePointer)
1068 {
1069 lock (globalDictAndDelegateLocker)
1070 {
1071 if (globalIncomingPacketHandlers.ContainsKey(packetTypeStr))
1072 {
1073 //Remove any instances of this handler from the delegates
1074 //The bonus here is if the delegate has not been added we continue quite happily
1075 IPacketTypeHandlerDelegateWrapper toRemove = null;
1076
1077 foreach (var handler in globalIncomingPacketHandlers[packetTypeStr])
1078 {
1079 if (handler.EqualsDelegate(packetHandlerDelgatePointer))
1080 {
1081 toRemove = handler;
1082 break;
1083 }
1084 }
1085
1086 if (toRemove != null)
1087 globalIncomingPacketHandlers[packetTypeStr].Remove(toRemove);
1088
1089 if (globalIncomingPacketHandlers[packetTypeStr] == null || globalIncomingPacketHandlers[packetTypeStr].Count == 0)
1090 {
1091 globalIncomingPacketHandlers.Remove(packetTypeStr);
1092 globalIncomingPacketUnwrappers.Remove(packetTypeStr);
1093
1094 if (LoggingEnabled) logger.Info("Removed a packetHandler for ‘" + packetTypeStr + "‘ packetType. No handlers remain.");
1095 }
1096 else
1097 if (LoggingEnabled) logger.Info("Removed a packetHandler for ‘" + packetTypeStr + "‘ packetType. Handlers remain.");
1098 }
1099 }
1100 }
1101
1102 /// <summary>
1103 /// Removes all delegates for the provided packet type.
1104 /// </summary>
1105 /// <param name="packetTypeStr">Packet type for which all delegates should be removed</param>
1106 public static void RemoveGlobalIncomingPacketHandler(string packetTypeStr)
1107 {
1108 lock (globalDictAndDelegateLocker)
1109 {
1110 //We don‘t need to check for potentially removing a critical reserved packet handler here because those cannot be removed.
1111 if (globalIncomingPacketHandlers.ContainsKey(packetTypeStr))
1112 {
1113 globalIncomingPacketHandlers.Remove(packetTypeStr);
1114 globalIncomingPacketUnwrappers.Remove(packetTypeStr);
1115
1116 if (LoggingEnabled) logger.Info("Removed all incoming packetHandlers for ‘" + packetTypeStr + "‘ packetType.");
1117 }
1118 }
1119 }
1120
1121 /// <summary>
1122 /// Removes all delegates for all packet types
1123 /// </summary>
1124 public static void RemoveGlobalIncomingPacketHandler()
1125 {
1126 lock (globalDictAndDelegateLocker)
1127 {
1128 globalIncomingPacketHandlers = new Dictionary<string, List<IPacketTypeHandlerDelegateWrapper>>();
1129 globalIncomingPacketUnwrappers = new Dictionary<string, PacketTypeUnwrapper>();
1130
1131 if (LoggingEnabled) logger.Info("Removed all incoming packetHandlers for all packetTypes");
1132 }
1133 }
1134
1135 /// <summary>
1136 /// Trigger incoming packet delegates for the provided parameters.
1137 /// </summary>
1138 /// <param name="packetHeader">The packet header</param>
1139 /// <param name="connection">The incoming connection</param>
1140 /// <param name="incomingDataStream">The bytes corresponding to the incoming object</param>
1141 /// <param name="options">The SendReceiveOptions to be used to convert incomingObjectBytes back to the desired object</param>
1142 public static void TriggerGlobalPacketHandlers(PacketHeader packetHeader, Connection connection, MemoryStream incomingDataStream, SendReceiveOptions options)
1143 {
1144 TriggerGlobalPacketHandlers(packetHeader, connection, incomingDataStream, options, IgnoreUnknownPacketTypes);
1145 }
1146
1147 /// <summary>
1148 /// Trigger incoming packet delegates for the provided parameters.
1149 /// </summary>
1150 /// <param name="packetHeader">The packet header</param>
1151 /// <param name="connection">The incoming connection</param>
1152 /// <param name="incomingDataStream">The bytes corresponding to the incoming object</param>
1153 /// <param name="options">The SendReceiveOptions to be used to convert incomingObjectBytes back to the desired object</param>
1154 /// <param name="ignoreUnknownPacketTypeOverride">Used to potentially override NetworkComms.IgnoreUnknownPacketTypes property</param>
1155 internal static void TriggerGlobalPacketHandlers(PacketHeader packetHeader, Connection connection, MemoryStream incomingDataStream, SendReceiveOptions options, bool ignoreUnknownPacketTypeOverride = false)
1156 {
1157 try
1158 {
1159 if (options == null) throw new PacketHandlerException("Provided sendReceiveOptions should not be null for packetType " + packetHeader.PacketType);
1160
1161 //We take a copy of the handlers list incase it is modified outside of the lock
1162 List<IPacketTypeHandlerDelegateWrapper> handlersCopy = null;
1163 lock (globalDictAndDelegateLocker)
1164 if (globalIncomingPacketHandlers.ContainsKey(packetHeader.PacketType))
1165 handlersCopy = new List<IPacketTypeHandlerDelegateWrapper>(globalIncomingPacketHandlers[packetHeader.PacketType]);
1166
1167 if (handlersCopy == null && !IgnoreUnknownPacketTypes && !ignoreUnknownPacketTypeOverride)
1168 {
1169 //We may get here if we have not added any custom delegates for reserved packet types
1170 bool isReservedType = false;
1171
1172 for (int i = 0; i < reservedPacketTypeNames.Length; i++)
1173 {
1174 if (reservedPacketTypeNames[i] == packetHeader.PacketType)
1175 {
1176 isReservedType = true;
1177 break;
1178 }
1179 }
1180
1181 if (!isReservedType)
1182 {
1183 //Change this to just a log because generally a packet of the wrong type is nothing to really worry about
1184 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Warn("The received packet type ‘" + packetHeader.PacketType + "‘ has no configured handler and network comms is not set to ignore unknown packet types. Set NetworkComms.IgnoreUnknownPacketTypes=true to prevent this error.");
1185 LogError(new UnexpectedPacketTypeException("The received packet type ‘" + packetHeader.PacketType + "‘ has no configured handler and network comms is not set to ignore unknown packet types. Set NetworkComms.IgnoreUnknownPacketTypes=true to prevent this error."), "PacketHandlerErrorGlobal_" + packetHeader.PacketType);
1186 }
1187
1188 return;
1189 }
1190 else if (handlersCopy == null && (IgnoreUnknownPacketTypes || ignoreUnknownPacketTypeOverride))
1191 //If we have received and unknown packet type and we are choosing to ignore them we just finish here
1192 return;
1193 else
1194 {
1195 //Idiot check
1196 if (handlersCopy.Count == 0)
1197 throw new PacketHandlerException("An entry exists in the packetHandlers list but it contains no elements. This should not be possible.");
1198
1199 //Deserialise the object only once
1200 object returnObject = handlersCopy[0].DeSerialize(incomingDataStream, options);
1201
1202 //Pass the data onto the handler and move on.
1203 if (LoggingEnabled) logger.Trace(" ... passing completed data packet of type ‘" + packetHeader.PacketType + "‘ to " + handlersCopy.Count.ToString() + " selected global handlers.");
1204
1205 //Pass the object to all necessary delgates
1206 //We need to use a copy because we may modify the original delegate list during processing
1207 foreach (IPacketTypeHandlerDelegateWrapper wrapper in handlersCopy)
1208 {
1209 try
1210 {
1211 wrapper.Process(packetHeader, connection, returnObject);
1212 }
1213 catch (Exception ex)
1214 {
1215 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Fatal("An unhandled exception was caught while processing a packet handler for a packet type ‘" + packetHeader.PacketType + "‘. Make sure to catch errors in packet handlers. See error log file for more information.");
1216 NetworkComms.LogError(ex, "PacketHandlerErrorGlobal_" + packetHeader.PacketType);
1217 }
1218 }
1219
1220 if (LoggingEnabled) logger.Trace(" ... all handlers for packet of type ‘" + packetHeader.PacketType + "‘ completed.");
1221 }
1222 }
1223 catch (Exception ex)
1224 {
1225 //If anything goes wrong here all we can really do is log the exception
1226 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Fatal("An exception occured in TriggerPacketHandler() for a packet type ‘" + packetHeader.PacketType + "‘. See error log file for more information.");
1227 NetworkComms.LogError(ex, "PacketHandlerErrorGlobal_" + packetHeader.PacketType);
1228 }
1229 }
1230
1231 /// <summary>
1232 /// Returns the unwrapper <see cref="SendReceiveOptions"/> for the provided packet type. If no specific options are registered returns null.
1233 /// </summary>
1234 /// <param name="packetTypeStr">The packet type for which the <see cref="SendReceiveOptions"/> are required</param>
1235 /// <returns>The requested <see cref="SendReceiveOptions"/> otherwise null</returns>
1236 public static SendReceiveOptions GlobalPacketTypeUnwrapperOptions(string packetTypeStr)
1237 {
1238 SendReceiveOptions options = null;
1239
1240 //If we find a global packet unwrapper for this packetType we used those options
1241 lock (globalDictAndDelegateLocker)
1242 {
1243 if (globalIncomingPacketUnwrappers.ContainsKey(packetTypeStr))
1244 options = globalIncomingPacketUnwrappers[packetTypeStr].Options;
1245 }
1246
1247 return options;
1248 }
1249
1250 /// <summary>
1251 /// Returns true if a global packet handler exists for the provided packet type.
1252 /// </summary>
1253 /// <param name="packetTypeStr">The packet type for which to check incoming packet handlers</param>
1254 /// <returns>True if a global packet handler exists</returns>
1255 public static bool GlobalIncomingPacketHandlerExists(string packetTypeStr)
1256 {
1257 lock (globalDictAndDelegateLocker)
1258 return globalIncomingPacketHandlers.ContainsKey(packetTypeStr);
1259 }
1260
1261 /// <summary>
1262 /// Returns true if the provided global packet handler has been added for the provided packet type.
1263 /// </summary>
1264 /// <param name="packetTypeStr">The packet type within which to check packet handlers</param>
1265 /// <param name="packetHandlerDelgatePointer">The packet handler to look for</param>
1266 /// <returns>True if a global packet handler exists for the provided packetType</returns>
1267 public static bool GlobalIncomingPacketHandlerExists(string packetTypeStr, Delegate packetHandlerDelgatePointer)
1268 {
1269 lock (globalDictAndDelegateLocker)
1270 {
1271 if (globalIncomingPacketHandlers.ContainsKey(packetTypeStr))
1272 {
1273 foreach (var handler in globalIncomingPacketHandlers[packetTypeStr])
1274 {
1275 if (handler.EqualsDelegate(packetHandlerDelgatePointer))
1276 return true;
1277 }
1278 }
1279 }
1280
1281 return false;
1282 }
1283 #endregion
1284
1285 #region Connection Establish and Shutdown
1286 /// <summary>
1287 /// Delegate which is executed when a connection is established or shutdown. See <see cref="AppendGlobalConnectionEstablishHandler"/> and <see cref="AppendGlobalConnectionCloseHandler"/>.
1288 /// </summary>
1289 /// <param name="connection">The connection which has been established or shutdown.</param>
1290 public delegate void ConnectionEstablishShutdownDelegate(Connection connection);
1291
1292 /// <summary>
1293 /// Multicast delegate pointer for connection shutdowns.
1294 /// </summary>
1295 internal static ConnectionEstablishShutdownDelegate globalConnectionShutdownDelegates;
1296
1297 /// <summary>
1298 /// Delegate counter for debugging.
1299 /// </summary>
1300 internal static int globalConnectionShutdownDelegateCount = 0;
1301
1302 /// <summary>
1303 /// Multicast delegate pointer for connection establishments, run asynchronously.
1304 /// </summary>
1305 internal static ConnectionEstablishShutdownDelegate globalConnectionEstablishDelegatesAsync;
1306
1307 /// <summary>
1308 /// Multicast delegate pointer for connection establishments, run synchronously.
1309 /// </summary>
1310 internal static ConnectionEstablishShutdownDelegate globalConnectionEstablishDelegatesSync;
1311
1312 /// <summary>
1313 /// Delegate counter for debugging.
1314 /// </summary>
1315 internal static int globalConnectionEstablishDelegateCount = 0;
1316
1317 /// <summary>
1318 /// Comms shutdown event. This will be triggered when calling NetworkComms.Shutdown
1319 /// </summary>
1320 public static event EventHandler<EventArgs> OnCommsShutdown;
1321
1322 /// <summary>
1323 /// Add a new connection shutdown delegate which will be called for every connection as it is closes.
1324 /// </summary>
1325 /// <param name="connectionShutdownDelegate">The delegate to call on all connection shutdowns</param>
1326 public static void AppendGlobalConnectionCloseHandler(ConnectionEstablishShutdownDelegate connectionShutdownDelegate)
1327 {
1328 lock (globalDictAndDelegateLocker)
1329 {
1330 if (globalConnectionShutdownDelegates == null)
1331 globalConnectionShutdownDelegates = connectionShutdownDelegate;
1332 else
1333 globalConnectionShutdownDelegates += connectionShutdownDelegate;
1334
1335 globalConnectionShutdownDelegateCount++;
1336
1337 if (LoggingEnabled) logger.Info("Added globalConnectionShutdownDelegates. " + globalConnectionShutdownDelegateCount.ToString());
1338 }
1339 }
1340
1341 /// <summary>
1342 /// Remove a connection shutdown delegate.
1343 /// </summary>
1344 /// <param name="connectionShutdownDelegate">The delegate to remove from connection shutdown events</param>
1345 public static void RemoveGlobalConnectionCloseHandler(ConnectionEstablishShutdownDelegate connectionShutdownDelegate)
1346 {
1347 lock (globalDictAndDelegateLocker)
1348 {
1349 globalConnectionShutdownDelegates -= connectionShutdownDelegate;
1350 globalConnectionShutdownDelegateCount--;
1351
1352 if (LoggingEnabled) logger.Info("Removed globalConnectionShutdownDelegates. " + globalConnectionShutdownDelegateCount.ToString());
1353 }
1354 }
1355
1356 /// <summary>
1357 /// Add a new connection establish delegate which will be called for every connection once it has been succesfully established.
1358 /// </summary>
1359 /// <param name="connectionEstablishDelegate">The delegate to call after all connection establishments.</param>
1360 /// <param name="runSynchronously">If true this ConnectionEstablishShutdownDelegate will be called synchronously during the connection establish. The connection will not be considered established until the ConnectionEstablishShutdownDelegate has completed.</param>
1361 public static void AppendGlobalConnectionEstablishHandler(ConnectionEstablishShutdownDelegate connectionEstablishDelegate, bool runSynchronously = false)
1362 {
1363 lock (globalDictAndDelegateLocker)
1364 {
1365 if (runSynchronously)
1366 {
1367 if (globalConnectionEstablishDelegatesSync == null)
1368 globalConnectionEstablishDelegatesSync = connectionEstablishDelegate;
1369 else
1370 globalConnectionEstablishDelegatesSync += connectionEstablishDelegate;
1371 }
1372 else
1373 {
1374 if (globalConnectionEstablishDelegatesAsync == null)
1375 globalConnectionEstablishDelegatesAsync = connectionEstablishDelegate;
1376 else
1377 globalConnectionEstablishDelegatesAsync += connectionEstablishDelegate;
1378 }
1379
1380 globalConnectionEstablishDelegateCount++;
1381
1382 if (LoggingEnabled) logger.Info("Added globalConnectionEstablishDelegates. " + globalConnectionEstablishDelegateCount.ToString());
1383 }
1384 }
1385
1386 /// <summary>
1387 /// Remove a connection establish delegate.
1388 /// </summary>
1389 /// <param name="connectionEstablishDelegate">The delegate to remove from connection establish events</param>
1390 public static void RemoveGlobalConnectionEstablishHandler(ConnectionEstablishShutdownDelegate connectionEstablishDelegate)
1391 {
1392 lock (globalDictAndDelegateLocker)
1393 {
1394 //Remove from either async or sync delegates
1395 globalConnectionEstablishDelegatesAsync -= connectionEstablishDelegate;
1396 globalConnectionEstablishDelegatesSync -= connectionEstablishDelegate;
1397
1398 globalConnectionEstablishDelegateCount--;
1399
1400 if (LoggingEnabled) logger.Info("Removed globalConnectionEstablishDelegates. " + globalConnectionEstablishDelegateCount.ToString());
1401 }
1402 }
1403
1404 /// <summary>
1405 /// Shutdown all connections, comms threads and execute OnCommsShutdown event. Any packet handlers are left unchanged. If any comms activity has taken place this should be called on application close.
1406 /// </summary>
1407 /// <param name="threadShutdownTimeoutMS">The time to wait for worker threads to close before attempting a thread abort.</param>
1408 public static void Shutdown(int threadShutdownTimeoutMS = 1000)
1409 {
1410 if (LoggingEnabled) logger.Trace("NetworkCommsDotNet shutdown initiated.");
1411 commsShutdown = true;
1412
1413 CommsThreadPool.BeginShutdown();
1414 Connection.ShutdownBase(threadShutdownTimeoutMS);
1415 TCPConnection.Shutdown(threadShutdownTimeoutMS);
1416 UDPConnection.Shutdown();
1417
1418 try
1419 {
1420 CloseAllConnections();
1421 }
1422 catch (CommsException)
1423 {
1424
1425 }
1426 catch (Exception ex)
1427 {
1428 LogError(ex, "CommsShutdownError");
1429 }
1430
1431 #if !WINDOWS_PHONE && !ANDROID
1432 try
1433 {
1434 if (NetworkLoadThread != null)
1435 {
1436 NetworkLoadThreadWait.Set();
1437 if (!NetworkLoadThread.Join(threadShutdownTimeoutMS))
1438 {
1439 NetworkLoadThread.Abort();
1440 throw new CommsSetupShutdownException("Timeout waiting for NetworkLoadThread thread to shutdown after " + threadShutdownTimeoutMS.ToString() + " ms. ");
1441 }
1442 }
1443 }
1444 catch (Exception ex)
1445 {
1446 LogError(ex, "CommsShutdownError");
1447 }
1448 #endif
1449
1450 try
1451 {
1452 if (OnCommsShutdown != null) OnCommsShutdown(null, new EventArgs());
1453 }
1454 catch (Exception ex)
1455 {
1456 LogError(ex, "CommsShutdownError");
1457 }
1458
1459 CommsThreadPool.EndShutdown(threadShutdownTimeoutMS);
1460
1461 commsShutdown = false;
1462 if (LoggingEnabled) logger.Info("NetworkCommsDotNet has shutdown");
1463
1464 #if !WINDOWS_PHONE && !NO_LOGGING
1465 //Mono bug fix
1466 //Sometimes NLog ends up in a deadlock on close, workaround provided on NLog website
1467 if (Logger != null)
1468 {
1469 LogManager.Flush();
1470 Logger.Factory.Flush();
1471
1472 if (NetworkComms.CurrentRuntimeEnvironment == RuntimeEnvironment.Mono_Net2 ||
1473 NetworkComms.CurrentRuntimeEnvironment == RuntimeEnvironment.Mono_Net35 ||
1474 NetworkComms.CurrentRuntimeEnvironment == RuntimeEnvironment.Mono_Net4)
1475 LogManager.Configuration = null;
1476 }
1477 #endif
1478 }
1479 #endregion
1480
1481 #region Timeouts
1482 /// <summary>
1483 /// Time to wait in milliseconds before throwing an exception when waiting for a connection to be established. Default is 30000.
1484 /// </summary>
1485 public static int ConnectionEstablishTimeoutMS { get; set; }
1486
1487 /// <summary>
1488 /// Time to wait in milliseconds before throwing an exception when waiting for confirmation of packet receipt. Default is 5000.
1489 /// </summary>
1490 public static int PacketConfirmationTimeoutMS { get; set; }
1491
1492 /// <summary>
1493 /// Time to wait in milliseconds before assuming a remote connection is dead when doing a connection test. Default is 1000.
1494 /// </summary>
1495 public static int ConnectionAliveTestTimeoutMS { get; set; }
1496
1497 /// <summary>
1498 /// By default NetworkComms.Net closes connections for which sends take a long time. The timeout is calculated based on previous connection send performances. Set this to true to disable this feature.
1499 /// </summary>
1500 public static bool DisableConnectionSendTimeouts { get; set; }
1501 #endregion
1502
1503 #region Logging
1504 /// <summary>
1505 /// Returns true if comms logging has been enabled.
1506 /// </summary>
1507 public static bool LoggingEnabled { get; private set; }
1508
1509 private static Logger logger = null;
1510
1511 /// <summary>
1512 /// Access the NetworkCommsDotNet logger externally.
1513 /// </summary>
1514 public static Logger Logger
1515 {
1516 get { return logger; }
1517 }
1518
1519 #if NO_LOGGING
1520 /// <summary>
1521 /// Enable basic logging using the provided logFileLocation
1522 /// </summary>
1523 /// <param name="loggingConfiguration"></param>
1524 public static void EnableLogging(string logFileLocation)
1525 {
1526 lock (globalDictAndDelegateLocker)
1527 {
1528 LoggingEnabled = true;
1529 logger = new Logger();
1530 logger.LogFileLocation = logFileLocation;
1531 }
1532 }
1533
1534 /// <summary>
1535 /// Disable all logging in NetworkCommsDotNet
1536 /// </summary>
1537 public static void DisableLogging()
1538 {
1539 lock (globalDictAndDelegateLocker)
1540 {
1541 LoggingEnabled = false;
1542 logger = null;
1543 }
1544 }
1545 #else
1546 /// <summary>
1547 /// Enable logging using a default config. All log output is written directly to the local console.
1548 /// </summary>
1549 public static void EnableLogging()
1550 {
1551 LoggingConfiguration logConfig = new LoggingConfiguration();
1552 NLog.Targets.ConsoleTarget consoleTarget = new NLog.Targets.ConsoleTarget();
1553 consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} [${level}] - ${message}";
1554 logConfig.AddTarget("console", consoleTarget);
1555 logConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, consoleTarget));
1556 EnableLogging(logConfig);
1557 }
1558
1559 /// <summary>
1560 /// Enable logging using the provided config. See examples for usage.
1561 /// </summary>
1562 /// <param name="loggingConfiguration"></param>
1563 public static void EnableLogging(LoggingConfiguration loggingConfiguration)
1564 {
1565 lock (globalDictAndDelegateLocker)
1566 {
1567 LoggingEnabled = true;
1568 LogManager.Configuration = loggingConfiguration;
1569 logger = LogManager.GetCurrentClassLogger();
1570 LogManager.EnableLogging();
1571 }
1572 }
1573
1574 /// <summary>
1575 /// Disable all logging in NetworkCommsDotNet
1576 /// </summary>
1577 public static void DisableLogging()
1578 {
1579 lock (globalDictAndDelegateLocker)
1580 {
1581 LoggingEnabled = false;
1582 LogManager.DisableLogging();
1583 }
1584 }
1585 #endif
1586
1587 /// <summary>
1588 /// Locker for LogError() which ensures thread safe saves.
1589 /// </summary>
1590 static object errorLocker = new object();
1591
1592 /// <summary>
1593 /// Appends the provided logString to end of fileName.txt. If the file does not exist it will be created.
1594 /// </summary>
1595 /// <param name="fileName">The filename to use. The extension .txt will be appended automatically</param>
1596 /// <param name="logString">The string to append.</param>
1597 public static void AppendStringToLogFile(string fileName, string logString)
1598 {
1599 try
1600 {
1601 lock (errorLocker)
1602 {
1603 using (System.IO.StreamWriter sw = new System.IO.StreamWriter(fileName + ".txt", true))
1604 sw.WriteLine(logString);
1605 }
1606 }
1607 catch (Exception)
1608 {
1609 //If an error happens here, such as if the file is locked then we lucked out.
1610 }
1611 }
1612
1613 /// <summary>
1614 /// Logs the provided exception to a file to assist troubleshooting.
1615 /// </summary>
1616 /// <param name="ex">The exception to be logged</param>
1617 /// <param name="fileName">The filename to use. A timestamp and extension .txt will be appended automatically</param>
1618 /// <param name="optionalCommentStr">An optional string which will appear at the top of the error file</param>
1619 /// <returns>The entire fileName used.</returns>
1620 public static string LogError(Exception ex, string fileName, string optionalCommentStr = "")
1621 {
1622 string entireFileName;
1623
1624 lock (errorLocker)
1625 {
1626
1627 #if iOS
1628 //We need to ensure we add the correct document path for iOS
1629 entireFileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), fileName + " " + DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " " + DateTime.Now.ToString("dd-MM-yyyy" + " [" + Thread.CurrentThread.ManagedThreadId.ToString() + "]"));
1630 #elif ANDROID
1631 entireFileName = Path.Combine(global::Android.OS.Environment.ExternalStorageDirectory.AbsolutePath, fileName + " " + DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " " + DateTime.Now.ToString("dd-MM-yyyy" + " [" + Thread.CurrentThread.ManagedThreadId.ToString() + "]"));
1632 #elif WINDOWS_PHONE
1633 entireFileName = fileName + " " + DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " " + DateTime.Now.ToString("dd-MM-yyyy" + " [" + Thread.CurrentThread.ManagedThreadId.ToString() + "]");
1634 #else
1635 using (Process currentProcess = System.Diagnostics.Process.GetCurrentProcess())
1636 entireFileName = fileName + " " + DateTime.Now.Hour.ToString() + "." + DateTime.Now.Minute.ToString() + "." + DateTime.Now.Second.ToString() + "." + DateTime.Now.Millisecond.ToString() + " " + DateTime.Now.ToString("dd-MM-yyyy" + " [" + currentProcess.Id.ToString() + "-" + Thread.CurrentContext.ContextID.ToString() + "]");
1637 #endif
1638
1639 if (LoggingEnabled) logger.Fatal(entireFileName, ex);
1640
1641 try
1642 {
1643 using (System.IO.StreamWriter sw = new System.IO.StreamWriter(entireFileName + ".txt", false))
1644 {
1645 if (optionalCommentStr != "")
1646 {
1647 sw.WriteLine("Comment: " + optionalCommentStr);
1648 sw.WriteLine("");
1649 }
1650
1651 if (ex.GetBaseException() != null)
1652 sw.WriteLine("Base Exception Type: " + ex.GetBaseException().ToString());
1653
1654 if (ex.InnerException != null)
1655 sw.WriteLine("Inner Exception Type: " + ex.InnerException.ToString());
1656
1657 if (ex.StackTrace != null)
1658 {
1659 sw.WriteLine("");
1660 sw.WriteLine("Stack Trace: " + ex.StackTrace.ToString());
1661 }
1662 }
1663 }
1664 catch (Exception)
1665 {
1666 //This should never really happen, but just incase.
1667 }
1668 }
1669
1670 return entireFileName;
1671 }
1672 #endregion
1673
1674 #region Serializers and Compressors
1675
1676 /// <summary>
1677 /// The following are used for internal comms objects, packet headers, connection establishment etc.
1678 /// We generally seem to increase the size of our data if compressing small objects (~50 bytes)
1679 /// Given the typical header size is 40 bytes we might as well not compress these objects.
1680 /// </summary>
1681 internal static SendReceiveOptions InternalFixedSendReceiveOptions { get; set; }
1682
1683 /// <summary>
1684 /// Default options for sending and receiving in the absence of specific values
1685 /// </summary>
1686 public static SendReceiveOptions DefaultSendReceiveOptions { get; set; }
1687 #endregion
1688
1689 #region Connection Access
1690 /// <summary>
1691 /// Send the provided object to the specified destination using TCP. Uses default sendReceiveOptions. For more control over options see connection specific methods.
1692 /// </summary>
1693 /// <param name="packetTypeStr">Packet type to use for send</param>
1694 /// <param name="destinationIPAddress">The destination ip address</param>
1695 /// <param name="destinationPort">The destination listen port</param>
1696 /// <param name="sendObject">The obect to send</param>
1697 public static void SendObject(string packetTypeStr, string destinationIPAddress, int destinationPort, object sendObject)
1698 {
1699 TCPConnection conn = TCPConnection.GetConnection(new ConnectionInfo(destinationIPAddress, destinationPort));
1700 conn.SendObject(packetTypeStr, sendObject);
1701 }
1702
1703 /// <summary>
1704 /// Send the provided object to the specified destination and wait for a return object using TCP. Uses default sendReceiveOptions. For more control over options see connection specific methods.
1705 /// </summary>
1706 /// <typeparam name="returnObjectType">The expected return object type, i.e. string, int[], etc</typeparam>
1707 /// <param name="sendingPacketTypeStr">Packet type to use during send</param>
1708 /// <param name="destinationIPAddress">The destination ip address</param>
1709 /// <param name="destinationPort">The destination listen port</param>
1710 /// <param name="expectedReturnPacketTypeStr">Expected packet type used for return object</param>
1711 /// <param name="returnPacketTimeOutMilliSeconds">Time to wait in milliseconds for return object</param>
1712 /// <param name="sendObject">Object to send</param>
1713 /// <returns>The expected return object</returns>
1714 public static returnObjectType SendReceiveObject<returnObjectType>(string sendingPacketTypeStr, string destinationIPAddress, int destinationPort, string expectedReturnPacketTypeStr, int returnPacketTimeOutMilliSeconds, object sendObject)
1715 {
1716 TCPConnection conn = TCPConnection.GetConnection(new ConnectionInfo(destinationIPAddress, destinationPort));
1717 return conn.SendReceiveObject<returnObjectType>(sendingPacketTypeStr, expectedReturnPacketTypeStr, returnPacketTimeOutMilliSeconds, sendObject);
1718 }
1719
1720 /// <summary>
1721 /// Return the MD5 hash of the provided memory stream as a string. Stream position will be equal to the length of stream on return, this ensures the MD5 is consistent.
1722 /// </summary>
1723 /// <param name="streamToMD5">The bytes which will be checksummed</param>
1724 /// <returns>The MD5 checksum as a string</returns>
1725 public static string MD5Bytes(Stream streamToMD5)
1726 {
1727 if (streamToMD5 == null) throw new ArgumentNullException("streamToMD5", "Provided Stream cannot be null.");
1728
1729 string resultStr;
1730
1731 using (System.Security.Cryptography.HashAlgorithm md5 =
1732 #if WINDOWS_PHONE
1733 new DPSBase.MD5Managed())
1734 #else
1735 System.Security.Cryptography.MD5.Create())
1736 #endif
1737 {
1738 //If we don‘t ensure the position is consistent the MD5 changes
1739 streamToMD5.Seek(0, SeekOrigin.Begin);
1740 resultStr = BitConverter.ToString(md5.ComputeHash(streamToMD5)).Replace("-", "");
1741 }
1742
1743 return resultStr;
1744 }
1745
1746 /// <summary>
1747 /// Return the MD5 hash of the provided memory stream as a string. Stream position will be equal to the length of stream on return, this ensures the MD5 is consistent.
1748 /// </summary>
1749 /// <param name="streamToMD5">The bytes which will be checksummed</param>
1750 /// <param name="start">The start position in the stream</param>
1751 /// <param name="length">The length in the stream to MD5</param>
1752 /// <returns>The MD5 checksum as a string</returns>
1753 public static string MD5Bytes(Stream streamToMD5, long start, int length)
1754 {
1755 if (streamToMD5 == null) throw new ArgumentNullException("streamToMD5", "Provided Stream cannot be null.");
1756
1757 using (MemoryStream stream = new MemoryStream(length))
1758 {
1759 StreamWriteWithTimeout.Write(streamToMD5, start, length, stream, 8000, 100, 2000);
1760 return MD5Bytes(stream);
1761 }
1762 }
1763
1764 /// <summary>
1765 /// Return the MD5 hash of the provided byte array as a string
1766 /// </summary>
1767 /// <param name="bytesToMd5">The bytes which will be checksummed</param>
1768 /// <returns>The MD5 checksum as a string</returns>
1769 public static string MD5Bytes(byte[] bytesToMd5)
1770 {
1771 if (bytesToMd5 == null) throw new ArgumentNullException("bytesToMd5", "Provided byte[] cannot be null.");
1772
1773 using(MemoryStream stream = new MemoryStream(bytesToMd5, 0, bytesToMd5.Length, false, true))
1774 return MD5Bytes(stream);
1775 }
1776
1777 /// <summary>
1778 /// Returns a ConnectionInfo array containing information for all connections
1779 /// </summary>
1780 /// <param name="includeClosedConnections">If true information for closed connections will also be included</param>
1781 /// <returns>List of ConnectionInfo containing information for all requested connections</returns>
1782 public static List<ConnectionInfo> AllConnectionInfo(bool includeClosedConnections = false)
1783 {
1784 List<ConnectionInfo> returnList = new List<ConnectionInfo>();
1785
1786 lock (globalDictAndDelegateLocker)
1787 {
1788 foreach (var connectionsByEndPoint in allConnectionsByEndPoint)
1789 {
1790 foreach (var connection in connectionsByEndPoint.Value.Values)
1791 {
1792 if (connection.ConnectionInfo != null)
1793 returnList.Add(connection.ConnectionInfo);
1794 }
1795 }
1796
1797 if (includeClosedConnections)
1798 {
1799 foreach (var pair in oldNetworkIdentifierToConnectionInfo)
1800 {
1801 foreach (var infoList in pair.Value.Values)
1802 {
1803 returnList.AddRange(infoList);
1804 }
1805 }
1806 }
1807 }
1808
1809 List<ConnectionInfo> distinctList = new List<ConnectionInfo>();
1810 foreach (var info in returnList)
1811 if (!distinctList.Contains(info))
1812 distinctList.Add(info);
1813
1814 return distinctList;
1815 }
1816
1817 /// <summary>
1818 /// Returns a ConnectionInfo array containing information for all connections which have the provided networkIdentifier. It is also possible to include information for closed connections.
1819 /// </summary>
1820 /// <param name="networkIdentifier">The networkIdentifier corresponding to the desired connectionInfo information</param>
1821 /// <param name="includeClosedConnections">If true will include information for connections which are closed. Otherwise only active connections will be included.</param>
1822 /// <returns>List of ConnectionInfo containing information for matching connections</returns>
1823 public static List<ConnectionInfo> AllConnectionInfo(ShortGuid networkIdentifier, bool includeClosedConnections = false)
1824 {
1825 List<ConnectionInfo> returnList = new List<ConnectionInfo>();
1826
1827 lock (globalDictAndDelegateLocker)
1828 {
1829 foreach (var pair in allConnectionsByEndPoint)
1830 {
1831 foreach (var connection in pair.Value.Values)
1832 {
1833 if (connection.ConnectionInfo != null && connection.ConnectionInfo.NetworkIdentifier == networkIdentifier)
1834 returnList.Add(connection.ConnectionInfo);
1835 }
1836 }
1837
1838 if (includeClosedConnections)
1839 {
1840 foreach (var pair in oldNetworkIdentifierToConnectionInfo)
1841 {
1842 if (pair.Key == networkIdentifier)
1843 {
1844 foreach (var infoList in pair.Value.Values)
1845 foreach (var info in infoList)
1846 returnList.Add(info);
1847
1848 break;
1849 }
1850 }
1851 }
1852 }
1853
1854 List<ConnectionInfo> distinctList = new List<ConnectionInfo>();
1855 foreach (var info in returnList)
1856 if (!distinctList.Contains(info))
1857 distinctList.Add(info);
1858
1859 return distinctList;
1860 }
1861
1862 /// <summary>
1863 /// Returns the total number of connections
1864 /// </summary>
1865 /// <returns>Total number of connections</returns>
1866 public static int TotalNumConnections()
1867 {
1868 lock (globalDictAndDelegateLocker)
1869 {
1870 int sum = 0;
1871
1872 foreach (var current in allConnectionsByEndPoint)
1873 sum += current.Value.Count;
1874
1875 return sum;
1876 }
1877 }
1878
1879 /// <summary>
1880 /// Returns the total number of connections where the <see cref="ConnectionInfo.RemoteEndPoint"/> matches the provided <see cref="IPAddress"/>
1881 /// </summary>
1882 /// <param name="matchIP">The <see cref="IPAddress"/> to match</param>
1883 /// <returns>Total number of connections where the <see cref="ConnectionInfo.RemoteEndPoint "/> matches the provided <see cref="IPAddress"/></returns>
1884 public static int TotalNumConnections(IPAddress matchIP)
1885 {
1886 lock (globalDictAndDelegateLocker)
1887 {
1888 int sum = 0;
1889
1890 foreach (var current in allConnectionsByEndPoint)
1891 foreach (var connection in current.Value)
1892 if (connection.Value.ConnectionInfo.RemoteEndPoint.Address.Equals(matchIP))
1893 sum++;
1894
1895 return sum;
1896 }
1897 }
1898
1899 /// <summary>
1900 /// Close all connections
1901 /// </summary>
1902 public static void CloseAllConnections()
1903 {
1904 CloseAllConnections(ConnectionType.Undefined, new IPEndPoint[0]);
1905 }
1906
1907 /// <summary>
1908 /// Close all connections of the provided <see cref="ConnectionType"/>
1909 /// </summary>
1910 /// <param name="connectionType">The type of connections to be closed</param>
1911 public static void CloseAllConnections(ConnectionType connectionType)
1912 {
1913 CloseAllConnections(connectionType, new IPEndPoint[0]);
1914 }
1915
1916 /// <summary>
1917 /// Close all connections of the provided <see cref="ConnectionType"/> except to provided <see cref="IPEndPoint"/> array.
1918 /// </summary>
1919 /// <param name="connectionTypeToClose">The type of connections to be closed. ConnectionType.<see cref="ConnectionType.Undefined"/> matches all types.</param>
1920 /// <param name="closeAllExceptTheseEndPoints">Close all except those with provided <see cref="IPEndPoint"/> array</param>
1921 public static void CloseAllConnections(ConnectionType connectionTypeToClose, IPEndPoint[] closeAllExceptTheseEndPoints)
1922 {
1923 List<Connection> connectionsToClose = new List<Connection>();
1924
1925 lock (globalDictAndDelegateLocker)
1926 {
1927 foreach (var pair in allConnectionsByEndPoint)
1928 {
1929 foreach (var innerPair in pair.Value)
1930 {
1931 if (innerPair.Value != null && (connectionTypeToClose == ConnectionType.Undefined || innerPair.Key == connectionTypeToClose))
1932 {
1933 bool dontClose = false;
1934
1935 foreach (var endPointToNotClose in closeAllExceptTheseEndPoints)
1936 {
1937 if (endPointToNotClose == innerPair.Value.ConnectionInfo.RemoteEndPoint)
1938 {
1939 dontClose = true;
1940 break;
1941 }
1942 }
1943
1944 if (!dontClose )
1945 connectionsToClose.Add(innerPair.Value);
1946 }
1947 }
1948 }
1949 }
1950
1951 if (LoggingEnabled) logger.Trace("Closing " + connectionsToClose.Count.ToString() + " connections.");
1952
1953 foreach (Connection connection in connectionsToClose)
1954 connection.CloseConnection(false, -6);
1955 }
1956
1957 /// <summary>
1958 /// Returns a list of all connections
1959 /// </summary>
1960 /// <returns>A list of requested connections. If no matching connections exist returns empty list.</returns>
1961 public static List<Connection> GetExistingConnection()
1962 {
1963 return GetExistingConnection(ConnectionType.Undefined);
1964 }
1965
1966 /// <summary>
1967 /// Returns a list of all connections matching the provided <see cref="ConnectionType"/>
1968 /// </summary>
1969 /// <param name="connectionType">The type of connections to return. ConnectionType.<see cref="ConnectionType.Undefined"/> matches all types.</param>
1970 /// <returns>A list of requested connections. If no matching connections exist returns empty list.</returns>
1971 public static List<Connection> GetExistingConnection(ConnectionType connectionType)
1972 {
1973 List<Connection> result = new List<Connection>();
1974 lock (globalDictAndDelegateLocker)
1975 {
1976 foreach (var current in allConnectionsByEndPoint)
1977 {
1978 foreach (var inner in current.Value)
1979 {
1980 if (connectionType == ConnectionType.Undefined || inner.Key == connectionType)
1981 result.Add(inner.Value);
1982 }
1983 }
1984 }
1985
1986 if (LoggingEnabled) logger.Trace("RetrieveConnection by connectionType=‘" + connectionType.ToString() + "‘. Returning list of " + result.Count.ToString() + " connections.");
1987
1988 return result;
1989 }
1990
1991 /// <summary>
1992 /// Retrieve a list of connections with the provided <see cref="ShortGuid"/> networkIdentifier of the provided <see cref="ConnectionType"/>.
1993 /// </summary>
1994 /// <param name="networkIdentifier">The <see cref="ShortGuid"/> corresponding with the desired peer networkIdentifier</param>
1995 /// <param name="connectionType">The <see cref="ConnectionType"/> desired</param>
1996 /// <returns>A list of connections to the desired peer. If no matching connections exist returns empty list.</returns>
1997 public static List<Connection> GetExistingConnection(ShortGuid networkIdentifier, ConnectionType connectionType)
1998 {
1999 List<Connection> resultList = new List<Connection>();
2000 lock (globalDictAndDelegateLocker)
2001 {
2002 foreach (var pair in allConnectionsById)
2003 {
2004 if (pair.Key == networkIdentifier && pair.Value.ContainsKey(connectionType))
2005 {
2006 resultList.AddRange(pair.Value[connectionType]);
2007 break;
2008 }
2009 }
2010 }
2011
2012 if (LoggingEnabled) logger.Trace("RetrieveConnection by networkIdentifier=‘" + networkIdentifier + "‘ and connectionType=‘" + connectionType.ToString() + "‘. Returning list of " + resultList.Count.ToString() + " connections.");
2013
2014 return resultList;
2015 }
2016
2017 /// <summary>
2018 /// Retrieve an existing connection with the provided ConnectionInfo.
2019 /// </summary>
2020 /// <param name="connectionInfo">ConnectionInfo corresponding with the desired connection</param>
2021 /// <returns>The desired connection. If no matching connection exists returns null.</returns>
2022 public static Connection GetExistingConnection(ConnectionInfo connectionInfo)
2023 {
2024 if (connectionInfo == null) throw new ArgumentNullException("connectionInfo", "Provided ConnectionInfo cannot be null.");
2025
2026 Connection result = null;
2027 lock (globalDictAndDelegateLocker)
2028 {
2029 foreach (var pair in allConnectionsByEndPoint)
2030 {
2031 if(pair.Key.Equals(connectionInfo.RemoteEndPoint) && pair.Value.ContainsKey(connectionInfo.ConnectionType))
2032 {
2033 result = pair.Value[connectionInfo.ConnectionType];
2034 break;
2035 }
2036 }
2037 }
2038
2039 if (LoggingEnabled)
2040 {
2041 if (result == null)
2042 logger.Trace("RetrieveConnection by connectionInfo=‘"+connectionInfo+"‘. No matching connection was found.");
2043 else
2044 logger.Trace("RetrieveConnection by connectionInfo=‘"+connectionInfo+"‘. Matching connection was found.");
2045 }
2046
2047 return result;
2048 }
2049
2050 /// <summary>
2051 /// Retrieve an existing connection with the provided <see cref="IPEndPoint"/> of the provided <see cref="ConnectionType"/>.
2052 /// </summary>
2053 /// <param name="remoteEndPoint">IPEndPoint corresponding with the desired connection</param>
2054 /// <param name="connectionType">The <see cref="ConnectionType"/> desired</param>
2055 /// <returns>The desired connection. If no matching connection exists returns null.</returns>
2056 public static Connection GetExistingConnection(IPEndPoint remoteEndPoint, ConnectionType connectionType)
2057 {
2058 Connection result = null;
2059 lock (globalDictAndDelegateLocker)
2060 {
2061 //return (from current in NetworkComms.allConnectionsByEndPoint where current.Key == IPEndPoint && current.Value.ContainsKey(connectionType) select current.Value[connectionType]).FirstOrDefault();
2062 //return (from current in NetworkComms.allConnectionsByEndPoint where current.Key == IPEndPoint select current.Value[connectionType]).FirstOrDefault();
2063 if (allConnectionsByEndPoint.ContainsKey(remoteEndPoint))
2064 {
2065 if (allConnectionsByEndPoint[remoteEndPoint].ContainsKey(connectionType))
2066 result = allConnectionsByEndPoint[remoteEndPoint][connectionType];
2067 }
2068 }
2069
2070 if (LoggingEnabled)
2071 {
2072 string connectionTypeStr = connectionType.ToString();
2073 if (result == null)
2074 logger.Trace("RetrieveConnection by remoteEndPoint=‘" + remoteEndPoint.Address + ":" + remoteEndPoint.Port.ToString() + "‘ and connectionType=‘" + connectionTypeStr + "‘. No matching connection was found.");
2075 else
2076 logger.Trace("RetrieveConnection by remoteEndPoint=‘" + remoteEndPoint.Address + ":" + remoteEndPoint.Port.ToString() + "‘ and connectionType=‘" + connectionTypeStr + "‘. Matching connection was found.");
2077 }
2078
2079 return result;
2080 }
2081
2082 /// <summary>
2083 /// Check if a connection exists with the provided IPEndPoint and ConnectionType
2084 /// </summary>
2085 /// <param name="connectionInfo">ConnectionInfo corresponding with the desired connection</param>
2086 /// <returns>True if a matching connection exists, otherwise false</returns>
2087 public static bool ConnectionExists(ConnectionInfo connectionInfo)
2088 {
2089 if (connectionInfo == null) throw new ArgumentNullException("connectionInfo", "Provided ConnectionInfo cannot be null.");
2090
2091 bool result = false;
2092 lock (globalDictAndDelegateLocker)
2093 {
2094 if (allConnectionsByEndPoint.ContainsKey(connectionInfo.RemoteEndPoint))
2095 result = allConnectionsByEndPoint[connectionInfo.RemoteEndPoint].ContainsKey(connectionInfo.ConnectionType);
2096 }
2097
2098 if (LoggingEnabled) logger.Trace("Checking for existing connection by connectionInfo=‘" + connectionInfo +"‘");
2099 return result;
2100 }
2101
2102 /// <summary>
2103 /// Check if a connection exists with the provided networkIdentifier and ConnectionType
2104 /// </summary>
2105 /// <param name="networkIdentifier">The <see cref="ShortGuid"/> corresponding with the desired peer networkIdentifier</param>
2106 /// <param name="connectionType">The <see cref="ConnectionType"/> desired</param>
2107 /// <returns>True if a matching connection exists, otherwise false</returns>
2108 public static bool ConnectionExists(ShortGuid networkIdentifier, ConnectionType connectionType)
2109 {
2110 bool result = false;
2111 lock (globalDictAndDelegateLocker)
2112 {
2113 if (allConnectionsById.ContainsKey(networkIdentifier))
2114 {
2115 if (allConnectionsById[networkIdentifier].ContainsKey(connectionType))
2116 result = allConnectionsById[networkIdentifier][connectionType].Count > 0;
2117 }
2118 }
2119
2120 if (LoggingEnabled)
2121 {
2122 string connectionTypeStr = connectionType.ToString();
2123 logger.Trace("Checking for existing connection by identifier=‘" + networkIdentifier + "‘ and connectionType=‘" + connectionTypeStr + "‘");
2124 }
2125 return result;
2126 }
2127
2128 /// <summary>
2129 /// Check if a connection exists with the provided IPEndPoint and ConnectionType
2130 /// </summary>
2131 /// <param name="remoteEndPoint">IPEndPoint corresponding with the desired connection</param>
2132 /// <param name="connectionType">The <see cref="ConnectionType"/> desired</param>
2133 /// <returns>True if a matching connection exists, otherwise false</returns>
2134 public static bool ConnectionExists(IPEndPoint remoteEndPoint, ConnectionType connectionType)
2135 {
2136 bool result = false;
2137 lock (globalDictAndDelegateLocker)
2138 {
2139 if (allConnectionsByEndPoint.ContainsKey(remoteEndPoint))
2140 result = allConnectionsByEndPoint[remoteEndPoint].ContainsKey(connectionType);
2141 }
2142
2143 if (LoggingEnabled)
2144 {
2145 string connectionTypeStr = connectionType.ToString();
2146 logger.Trace("Checking for existing connection by endPoint=‘" + remoteEndPoint.Address + ":" + remoteEndPoint.Port.ToString() + "‘ and connectionType=‘" + connectionTypeStr + "‘");
2147 }
2148 return result;
2149 }
2150
2151 /// <summary>
2152 /// Removes the reference to the provided connection from within networkComms. DOES NOT CLOSE THE CONNECTION. Returns true if the provided connection reference existed and was removed, false otherwise.
2153 /// </summary>
2154 /// <param name="connection"></param>
2155 /// <param name="maintainConnectionInfoHistory"></param>
2156 /// <returns></returns>
2157 internal static bool RemoveConnectionReference(Connection connection, bool maintainConnectionInfoHistory = true)
2158 {
2159 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Entering RemoveConnectionReference for " + connection.ConnectionInfo);
2160
2161 //We don‘t have the connection identifier until the connection has been established.
2162 //if (!connection.ConnectionInfo.ConnectionEstablished && !connection.ConnectionInfo.ConnectionShutdown)
2163 // return false;
2164
2165 if (connection.ConnectionInfo.ConnectionState == ConnectionState.Established && !(connection.ConnectionInfo.ConnectionState == ConnectionState.Shutdown))
2166 throw new ConnectionShutdownException("A connection can only be removed once correctly shutdown.");
2167
2168 bool returnValue = false;
2169
2170 //Ensure connection references are removed from networkComms
2171 //Once we think we have closed the connection it‘s time to get rid of our other references
2172 lock (globalDictAndDelegateLocker)
2173 {
2174 #region Update NetworkComms Connection Dictionaries
2175 ShortGuid currentNetworkIdentifier = connection.ConnectionInfo.NetworkIdentifier;
2176
2177 //We establish whether we have already done this step
2178 if ((allConnectionsById.ContainsKey(currentNetworkIdentifier) &&
2179 allConnectionsById[currentNetworkIdentifier].ContainsKey(connection.ConnectionInfo.ConnectionType) &&
2180 allConnectionsById[currentNetworkIdentifier][connection.ConnectionInfo.ConnectionType].Contains(connection))
2181 ||
2182 (allConnectionsByEndPoint.ContainsKey(connection.ConnectionInfo.RemoteEndPoint) &&
2183 allConnectionsByEndPoint[connection.ConnectionInfo.RemoteEndPoint].ContainsKey(connection.ConnectionInfo.ConnectionType)))
2184 {
2185 //Maintain a reference if this is our first connection close
2186 returnValue = true;
2187 }
2188
2189 //Keep a reference of the connection for possible debugging later
2190 if (maintainConnectionInfoHistory)
2191 {
2192 if (oldNetworkIdentifierToConnectionInfo.ContainsKey(currentNetworkIdentifier))
2193 {
2194 if (oldNetworkIdentifierToConnectionInfo[currentNetworkIdentifier].ContainsKey(connection.ConnectionInfo.ConnectionType))
2195 oldNetworkIdentifierToConnectionInfo[currentNetworkIdentifier][connection.ConnectionInfo.ConnectionType].Add(connection.ConnectionInfo);
2196 else
2197 oldNetworkIdentifierToConnectionInfo[currentNetworkIdentifier].Add(connection.ConnectionInfo.ConnectionType, new List<ConnectionInfo>() { connection.ConnectionInfo });
2198 }
2199 else
2200 oldNetworkIdentifierToConnectionInfo.Add(currentNetworkIdentifier, new Dictionary<ConnectionType, List<ConnectionInfo>>() { { connection.ConnectionInfo.ConnectionType, new List<ConnectionInfo>() { connection.ConnectionInfo } } });
2201 }
2202
2203 if (allConnectionsById.ContainsKey(currentNetworkIdentifier) &&
2204 allConnectionsById[currentNetworkIdentifier].ContainsKey(connection.ConnectionInfo.ConnectionType))
2205 {
2206 //if (!allConnectionsById[currentNetworkIdentifier][connection.ConnectionInfo.ConnectionType].Contains(connection))
2207 // throw new ConnectionShutdownException("A reference to the connection being closed was not found in the allConnectionsById dictionary.");
2208 //else
2209 if (allConnectionsById[currentNetworkIdentifier][connection.ConnectionInfo.ConnectionType].Contains(connection))
2210 allConnectionsById[currentNetworkIdentifier][connection.ConnectionInfo.ConnectionType].Remove(connection);
2211
2212 //Remove the connection type reference if it is empty
2213 if (allConnectionsById[currentNetworkIdentifier][connection.ConnectionInfo.ConnectionType].Count == 0)
2214 allConnectionsById[currentNetworkIdentifier].Remove(connection.ConnectionInfo.ConnectionType);
2215
2216 //Remove the identifier reference
2217 if (allConnectionsById[currentNetworkIdentifier].Count == 0)
2218 allConnectionsById.Remove(currentNetworkIdentifier);
2219
2220 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Removed connection reference by ID for " + connection.ConnectionInfo);
2221 }
2222
2223 //We can now remove this connection by end point as well
2224 if (allConnectionsByEndPoint.ContainsKey(connection.ConnectionInfo.RemoteEndPoint))
2225 {
2226 if (allConnectionsByEndPoint[connection.ConnectionInfo.RemoteEndPoint].ContainsKey(connection.ConnectionInfo.ConnectionType))
2227 allConnectionsByEndPoint[connection.ConnectionInfo.RemoteEndPoint].Remove(connection.ConnectionInfo.ConnectionType);
2228
2229 //If this was the last connection type for this endpoint we can remove the endpoint reference as well
2230 if (allConnectionsByEndPoint[connection.ConnectionInfo.RemoteEndPoint].Count == 0)
2231 allConnectionsByEndPoint.Remove(connection.ConnectionInfo.RemoteEndPoint);
2232
2233 if (NetworkComms.LoggingEnabled) NetworkComms.Logger.Trace("Removed connection reference by endPoint for " + connection.ConnectionInfo);
2234 }
2235 #endregion
2236 }
2237
2238 return returnValue;
2239 }
2240
2241 /// <summary>
2242 /// Adds a reference by IPEndPoint to the provided connection within networkComms.
2243 /// </summary>
2244 /// <param name="connection"></param>
2245 /// <param name="endPointToUse">An optional override which forces a specific IPEndPoint</param>
2246 internal static void AddConnectionByReferenceEndPoint(Connection connection, IPEndPoint endPointToUse = null)
2247 {
2248 if (NetworkComms.LoggingEnabled)
2249 NetworkComms.Logger.Trace("Adding connection reference by endPoint. Connection=‘"+connection.ConnectionInfo+"‘." +
2250 (endPointToUse != null ? " Provided override endPoint of " + endPointToUse.Address + ":" + endPointToUse.Port.ToString() : ""));
2251
2252 //If the remoteEndPoint is IPAddress.Any we don‘t record it by endPoint
2253 if (connection.ConnectionInfo.RemoteEndPoint.Address.Equals(IPAddress.Any) || (endPointToUse != null && endPointToUse.Address.Equals(IPAddress.Any)))
2254 return;
2255
2256 if (connection.ConnectionInfo.ConnectionState == ConnectionState.Established || connection.ConnectionInfo.ConnectionState == ConnectionState.Shutdown)
2257 throw new ConnectionSetupException("Connection reference by endPoint should only be added before a connection is established. This is to prevent duplicate connections.");
2258
2259 if (endPointToUse == null) endPointToUse = connection.ConnectionInfo.RemoteEndPoint;
2260
2261 //We can double check for an existing connection here first so that it occurs outside the lock
2262 Connection existingConnection = GetExistingConnection(endPointToUse, connection.ConnectionInfo.ConnectionType);
2263 if (existingConnection != null && existingConnection.ConnectionInfo.ConnectionState == ConnectionState.Established && connection!=existingConnection)
2264 existingConnection.ConnectionAlive();
2265
2266 //How do we prevent multiple threads from trying to create a duplicate connection??
2267 lock (globalDictAndDelegateLocker)
2268 {
2269 //We now check for an existing connection again from within the lock
2270 if (ConnectionExists(endPointToUse, connection.ConnectionInfo.ConnectionType))
2271 {
2272 //If a connection still exist we don‘t assume it is the same as above
2273 existingConnection = GetExistingConnection(endPointToUse, connection.ConnectionInfo.ConnectionType);
2274 if (existingConnection != connection)
2275 {
2276 throw new DuplicateConnectionException("A different connection already exists with the desired endPoint (" + endPointToUse.Address + ":" + endPointToUse.Port.ToString() + "). This can occasionaly occur if two peers try to connect to each other simultaneously. New connection is " + (existingConnection.ConnectionInfo.ServerSide ? "server side" : "client side") + " - " + connection.ConnectionInfo +
2277 ". Existing connection is " + (existingConnection.ConnectionInfo.ServerSide ? "server side" : "client side") + ", " + existingConnection.ConnectionInfo.ConnectionState.ToString() + " - " + (existingConnection.ConnectionInfo.ConnectionState == ConnectionState.Establishing ? "creationTime:" + existingConnection.ConnectionInfo.ConnectionCreationTime.ToString() : "establishedTime:" + existingConnection.ConnectionInfo.ConnectionEstablishedTime.ToString()) + " - " + " details - " + existingConnection.ConnectionInfo);
2278 }
2279 else
2280 {
2281 //We have just tried to add the same reference twice, no need to do anything this time around
2282 }
2283 }
2284 else
2285 {
2286 #if FREETRIAL
2287 //If this is a free trial we only allow a single connection. We will throw an exception if any connections already exist
2288 if (TotalNumConnections() != 0)
2289 throw new NotSupportedException("Unable to create connection as this version of NetworkComms.Net is limited to only one connection. Please purchase a commerical license from www.networkcomms.net which supports an unlimited number of connections.");
2290 #endif
2291
2292 //Add reference to the endPoint dictionary
2293 if (allConnectionsByEndPoint.ContainsKey(endPointToUse))
2294 {
2295 if (allConnectionsByEndPoint[endPointToUse].ContainsKey(connection.ConnectionInfo.ConnectionType))
2296 throw new Exception("Idiot check fail. The method ConnectionExists should have prevented execution getting here!!");
2297 else
2298 allConnectionsByEndPoint[endPointToUse].Add(connection.ConnectionInfo.ConnectionType, connection);
2299 }
2300 else
2301 allConnectionsByEndPoint.Add(endPointToUse, new Dictionary<ConnectionType, Connection>() { { connection.ConnectionInfo.ConnectionType, connection } });
2302 }
2303 }
2304 }
2305
2306 /// <summary>
2307 /// Update the endPoint reference for the provided connection with the newEndPoint. If there is no change just returns
2308 /// </summary>
2309 /// <param name="connection"></param>
2310 /// <param name="newRemoteEndPoint"></param>
2311 internal static void UpdateConnectionReferenceByEndPoint(Connection connection, IPEndPoint newRemoteEndPoint)
2312 {
2313 if (NetworkComms.LoggingEnabled)
2314 NetworkComms.Logger.Trace("Updating connection reference by endPoint. Connection=‘" + connection.ConnectionInfo + "‘." + (newRemoteEndPoint != null ? " Provided new endPoint of " + newRemoteEndPoint.Address + ":" + newRemoteEndPoint.Port.ToString() : ""));
2315
2316 if (!connection.ConnectionInfo.RemoteEndPoint.Equals(newRemoteEndPoint))
2317 {
2318 lock (globalDictAndDelegateLocker)
2319 {
2320 RemoveConnectionReference(connection, false);
2321 AddConnectionByReferenceEndPoint(connection, newRemoteEndPoint);
2322 }
2323 }
2324 }
2325
2326 /// <summary>
2327 /// Add a reference by networkIdentifier to the provided connection within NetworkComms. Requires a reference by IPEndPoint to already exist.
2328 /// </summary>
2329 /// <param name="connection"></param>
2330 internal static void AddConnectionReferenceByIdentifier(Connection connection)
2331 {
2332 if (!(connection.ConnectionInfo.ConnectionState == ConnectionState.Established) || connection.ConnectionInfo.ConnectionState == ConnectionState.Shutdown)
2333 throw new ConnectionSetupException("Connection reference by identifier should only be added once a connection is established. This is to prevent duplicate connections.");
2334
2335 if (connection.ConnectionInfo.NetworkIdentifier == ShortGuid.Empty)
2336 throw new ConnectionSetupException("Should not be calling AddConnectionByIdentifierReference unless the connection remote identifier has been set.");
2337
2338 if (NetworkComms.LoggingEnabled)
2339 NetworkComms.Logger.Trace("Adding connection reference by identifier. Connection=" + connection.ConnectionInfo + ".");
2340
2341 lock (globalDictAndDelegateLocker)
2342 {
2343 //There should already be a reference to this connection in the endPoint dictionary
2344 if (!ConnectionExists(connection.ConnectionInfo.RemoteEndPoint, connection.ConnectionInfo.ConnectionType))
2345 throw new ConnectionSetupException("A reference by identifier should only be added if a reference by endPoint already exists.");
2346
2347 //Check for an existing reference first, if there is one and it matches this connection then no worries
2348 if (allConnectionsById.ContainsKey(connection.ConnectionInfo.NetworkIdentifier))
2349 {
2350 if (allConnectionsById[connection.ConnectionInfo.NetworkIdentifier].ContainsKey(connection.ConnectionInfo.ConnectionType))
2351 {
2352 if (!allConnectionsById[connection.ConnectionInfo.NetworkIdentifier][connection.ConnectionInfo.ConnectionType].Contains(connection))
2353 {
2354 foreach (var current in allConnectionsById[connection.ConnectionInfo.NetworkIdentifier][connection.ConnectionInfo.ConnectionType])
2355 {
2356 if (current.ConnectionInfo.RemoteEndPoint.Equals(connection.ConnectionInfo.RemoteEndPoint))
2357 throw new ConnectionSetupException("A different connection to the same remoteEndPoint already exists. Duplicate connections should be prevented elsewhere. Existing connection " + current.ConnectionInfo + ", new connection " + connection.ConnectionInfo);
2358 }
2359 }
2360 else
2361 {
2362 //We are trying to add the same connection twice, so just do nothing here.
2363 }
2364 }
2365 else
2366 allConnectionsById[connection.ConnectionInfo.NetworkIdentifier].Add(connection.ConnectionInfo.ConnectionType, new List<Connection>() { connection });
2367 }
2368 else
2369 allConnectionsById.Add(connection.ConnectionInfo.NetworkIdentifier, new Dictionary<ConnectionType, List<Connection>>() { { connection.ConnectionInfo.ConnectionType, new List<Connection>() {connection}} });
2370 }
2371 }
2372 #endregion
2373 }
基于此系统编写了几个都不大的小项目
服务器端采用 win server 2003 .net框架2.0 数据库mssql2005
客户端 红米手机 或者其他安卓手机
能够顺利的实现在手机上提交数据到服务器，或者从服务器上获取数据。
这几天有时间会整理一个小demo出来，给大家参考，敬请期待。
www.cnblogs.com/networkcomms
www.networkcomms.cn(建设中)
时间： 2024-10-26 21:17:40