From a9bcd06b2b10fdac5ff76ab5bebebf9f658f3da5 Mon Sep 17 00:00:00 2001
From: "parallelbgls@outlook.com" <parallelbgls@outlook.com>
Date: Wed, 8 Apr 2015 15:41:20 +0800
Subject: [PATCH] 2015-04-08 update 1 change some code in TCP Connector to
 implement async method

---
 Modbus.Net/ModBus.Net/BaseConnector.cs      |  17 ++
 Modbus.Net/ModBus.Net/BaseProtocal.cs       |   1 +
 Modbus.Net/ModBus.Net/ComConnector.cs       |  15 ++
 Modbus.Net/ModBus.Net/ModBus.Net.csproj     |  10 +
 Modbus.Net/ModBus.Net/ModbusUtility.cs      |   1 +
 Modbus.Net/ModBus.Net/ProtocalLinker.cs     |   1 +
 Modbus.Net/ModBus.Net/SimenseTcpProtocal.cs |   2 +-
 Modbus.Net/ModBus.Net/SimenseUtility.cs     |  14 +-
 Modbus.Net/ModBus.Net/TcpConnector.cs       | 206 +++++++++-----------
 Modbus.Net/ModBus.Net/TcpProtocalLinker.cs  |   3 +-
 Modbus.Net/ModBus.Net/ValueHelper.cs        |  10 +-
 Modbus.Net/ModBus.Net/key.pfx               | Bin 0 -> 1764 bytes
 12 files changed, 158 insertions(+), 122 deletions(-)
 create mode 100644 Modbus.Net/ModBus.Net/key.pfx

diff --git a/Modbus.Net/ModBus.Net/BaseConnector.cs b/Modbus.Net/ModBus.Net/BaseConnector.cs
index a6f97f6..4f24c16 100644
--- a/Modbus.Net/ModBus.Net/BaseConnector.cs
+++ b/Modbus.Net/ModBus.Net/BaseConnector.cs
@@ -15,6 +15,11 @@ namespace ModBus.Net
         /// <returns></returns>
         public abstract bool Connect();
         /// <summary>
+        /// 连接PLC，异步
+        /// </summary>
+        /// /// <returns></returns>
+        public abstract Task<bool> ConnectAsync();
+        /// <summary>
         /// 断开PLC
         /// </summary>
         /// <returns></returns>
@@ -26,10 +31,22 @@ namespace ModBus.Net
         /// <returns></returns>
         public abstract bool SendMsgWithoutReturn(byte[] message);
         /// <summary>
+        /// 无返回发送数据，异步
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public abstract Task<bool> SendMsgWithoutReturnAsync(byte[] message);
+        /// <summary>
         /// 带返回发送数据
         /// </summary>
         /// <param name="message"></param>
         /// <returns></returns>
         public abstract byte[] SendMsg(byte[] message);
+        /// <summary>
+        /// 带返回发送数据，异步
+        /// </summary>
+        /// <param name="message"></param>
+        /// <returns></returns>
+        public abstract Task<byte[]> SendMsgAsync(byte[] message);
     }
 }
diff --git a/Modbus.Net/ModBus.Net/BaseProtocal.cs b/Modbus.Net/ModBus.Net/BaseProtocal.cs
index 407a9ab..9e41617 100644
--- a/Modbus.Net/ModBus.Net/BaseProtocal.cs
+++ b/Modbus.Net/ModBus.Net/BaseProtocal.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Threading.Tasks;
 
 namespace ModBus.Net
 {
diff --git a/Modbus.Net/ModBus.Net/ComConnector.cs b/Modbus.Net/ModBus.Net/ComConnector.cs
index e7dfe30..b8fec78 100644
--- a/Modbus.Net/ModBus.Net/ComConnector.cs
+++ b/Modbus.Net/ModBus.Net/ComConnector.cs
@@ -52,6 +52,11 @@ namespace ModBus.Net
             return false;
         }
 
+        public override Task<bool> ConnectAsync()
+        {
+            return Task.FromResult(Connect());
+        }
+
         public override bool Disconnect()
         {
             if (serialPort1 != null)
@@ -77,6 +82,11 @@ namespace ModBus.Net
 
         }
 
+        public override Task<bool> SendMsgWithoutReturnAsync(byte[] message)
+        {
+            return Task.FromResult(SendMsgWithoutReturn(message));
+        }
+
         public override byte[] SendMsg(byte[] sendbytes)
         {
             try
@@ -95,6 +105,11 @@ namespace ModBus.Net
             }
         }
 
+        public override Task<byte[]> SendMsgAsync(byte[] message)
+        {
+            return Task.FromResult(SendMsg(message));
+        }
+
         public override bool SendMsgWithoutReturn(byte[] sendbytes)
         {
             try
diff --git a/Modbus.Net/ModBus.Net/ModBus.Net.csproj b/Modbus.Net/ModBus.Net/ModBus.Net.csproj
index 290f210..9dd7969 100644
--- a/Modbus.Net/ModBus.Net/ModBus.Net.csproj
+++ b/Modbus.Net/ModBus.Net/ModBus.Net.csproj
@@ -30,6 +30,12 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>key.pfx</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
     <Reference Include="System.Core" />
@@ -42,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AddressTranslator.cs" />
+    <Compile Include="AsyncHelper.cs" />
     <Compile Include="BaseProtocal.cs" />
     <Compile Include="BaseUtility.cs" />
     <Compile Include="ComConnector.cs" />
@@ -82,6 +89,9 @@
       <LastGenOutput>ConfigurationManager.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="key.pfx" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Modbus.Net/ModBus.Net/ModbusUtility.cs b/Modbus.Net/ModBus.Net/ModbusUtility.cs
index 56fd508..09cc448 100644
--- a/Modbus.Net/ModBus.Net/ModbusUtility.cs
+++ b/Modbus.Net/ModBus.Net/ModbusUtility.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using System.Windows.Forms;
 
 /// <summary>
diff --git a/Modbus.Net/ModBus.Net/ProtocalLinker.cs b/Modbus.Net/ModBus.Net/ProtocalLinker.cs
index ae33d7d..9d085e8 100644
--- a/Modbus.Net/ModBus.Net/ProtocalLinker.cs
+++ b/Modbus.Net/ModBus.Net/ProtocalLinker.cs
@@ -1,4 +1,5 @@
 using System.Reflection;
+using System.Threading.Tasks;
 
 namespace ModBus.Net
 {
diff --git a/Modbus.Net/ModBus.Net/SimenseTcpProtocal.cs b/Modbus.Net/ModBus.Net/SimenseTcpProtocal.cs
index 08bc32b..3c5033b 100644
--- a/Modbus.Net/ModBus.Net/SimenseTcpProtocal.cs
+++ b/Modbus.Net/ModBus.Net/SimenseTcpProtocal.cs
@@ -62,7 +62,7 @@ namespace ModBus.Net
             ProtocalLinker = new SimenseTcpProtocalLinker(_ip);
             var inputStruct = new CreateReferenceSimenseInputStruct(0x1a, _taspSrc, _tsapDst);
             var outputStruct =
-                (CreateReferenceSimenseOutputStruct) ForceSendReceive(this[typeof(CreateReferenceSimenseProtocal)], inputStruct);
+                (CreateReferenceSimenseOutputStruct)ForceSendReceive(this[typeof(CreateReferenceSimenseProtocal)], inputStruct);
             if (!ProtocalLinker.IsConnected) return;
             var inputStruct2 = new EstablishAssociationSimenseInputStruct(0x0101, _maxCalling, _maxCalled, _maxPdu);
             var outputStruct2 = (EstablishAssociationSimenseOutputStruct)SendReceive(this[typeof(EstablishAssociationSimenseProtocal)], inputStruct2);
diff --git a/Modbus.Net/ModBus.Net/SimenseUtility.cs b/Modbus.Net/ModBus.Net/SimenseUtility.cs
index d727dae..dcb612e 100644
--- a/Modbus.Net/ModBus.Net/SimenseUtility.cs
+++ b/Modbus.Net/ModBus.Net/SimenseUtility.cs
@@ -34,6 +34,16 @@ namespace ModBus.Net
                             _maxPdu = 0x03c0;
                             break;
                         }
+                    case "300":
+                    case "400":
+                    {
+                        _taspSrc = 0x4b54;
+                        _tsapDst = 0x0302;
+                        _maxCalling = 0x0001;
+                        _maxCalled = 0x0001;
+                        _maxPdu = 0x00f0;
+                        break;
+                    }
                 }
                 _connectionString = splitStrings[0];              
             }
@@ -90,8 +100,8 @@ namespace ModBus.Net
         {
             var readRequestSimenseInputStruct = new ReadRequestSimenseInputStruct(0xd3c7, SimenseTypeCode.Byte, startAddress, (ushort)getByteCount, AddressTranslator);
             var readRequestSimenseOutputStruct =
-                (ReadRequestSimenseOutputStruct)
-                    Wrapper.SendReceive(Wrapper[typeof(ReadRequestSimenseProtocal)], readRequestSimenseInputStruct);
+                 (ReadRequestSimenseOutputStruct)
+                     Wrapper.SendReceive(Wrapper[typeof(ReadRequestSimenseProtocal)], readRequestSimenseInputStruct);
             return readRequestSimenseOutputStruct.GetValue;
         }
 
diff --git a/Modbus.Net/ModBus.Net/TcpConnector.cs b/Modbus.Net/ModBus.Net/TcpConnector.cs
index 4bdc014..22cf8a9 100644
--- a/Modbus.Net/ModBus.Net/TcpConnector.cs
+++ b/Modbus.Net/ModBus.Net/TcpConnector.cs
@@ -1,6 +1,9 @@
 using System;
+using System.IO;
+using System.Net;
 using System.Net.Sockets;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace ModBus.Net
 {
@@ -23,68 +26,73 @@ namespace ModBus.Net
     /// </summary>
     public class TcpConnector : BaseConnector, IDisposable
     {
-        public delegate void ErrorShutdownEventHandler(object sender, EventArgs e);
 
-        public delegate void ReceiveMessageHandler(object sender, SocketMessageEventArgs e);
+        private readonly string _host;
 
-        private readonly bool b_AsyncReceive = true;
-        private readonly string host;
+        private int _sendCount;
+        private int _receiveCount;
+        private int _errorCount;
+        private NetworkStream _stream;
 
         // 2MB 的接收缓冲区，目的是一次接收完服务器发回的消息
-        private readonly byte[] m_receiveBuffer = new byte[1024];
-        private readonly int port;
-        public int m_errorCount = 0;
-        public int m_receiveCount = 0;
-        public int m_sendCount = 0;
-        private TcpClient m_socketClient;
+        private readonly byte[] _receiveBuffer = new byte[1024];
+        private readonly int _port;
+        private TcpClient _socketClient;
 
-        public TcpConnector(string ipaddress, int port, bool isAsync)
+        public int TimeoutTime { get; set; }
+
+        public TcpConnector(string ipaddress, int port, int timeoutTime)
         {
-            host = ipaddress;
-            this.port = port;
-            b_AsyncReceive = isAsync;
+            _host = ipaddress;
+            _port = port;
+            //TimeoutTime = timeoutTime;
         }
 
         public override bool IsConnected
         {
-            get { return m_socketClient != null && m_socketClient.Connected; }
+            get { return _socketClient != null && _socketClient.Connected; }
         }
 
         public void Dispose()
         {
-            if (m_socketClient != null)
+            if (_socketClient != null)
             {
                 CloseClientSocket();
-                m_socketClient.Client.Dispose();
-            }
-        }
-
-        public event ReceiveMessageHandler MessageReceive;
-        public event ErrorShutdownEventHandler SocketErrorShutdown;
-
-        private void ReceiveMessage(byte[] message)
-        {
-            if (MessageReceive != null)
-            {
-                MessageReceive(this, new SocketMessageEventArgs(message));
+                _socketClient.Client.Dispose();
             }
         }
 
         public override bool Connect()
         {
-            if (m_socketClient != null)
+            return AsyncHelper.RunSync(ConnectAsync);
+        }
+
+        public override async Task<bool> ConnectAsync()
+        {
+            if (_socketClient != null)
             {
                 Disconnect();
             }
-            lock (this)
-            {
                 try
                 {
-                    m_socketClient = new TcpClient(host, port);
-                    m_socketClient.ReceiveTimeout = 10*1000;
-
-                    if (m_socketClient.Connected)
+                    _socketClient = new TcpClient
                     {
+                        SendTimeout = TimeoutTime, 
+                        ReceiveTimeout = TimeoutTime
+                        
+                    };
+
+                    try
+                    {
+                        await _socketClient.ConnectAsync(_host, _port);
+                    }
+                    catch (Exception e)
+                    {
+                        AddInfo("client connected exception: " + e.Message);
+                    }
+                    if (_socketClient.Connected)
+                    {
+                        _stream = _socketClient.GetStream();
                         AddInfo("client connected.");
                         return true;
                     }
@@ -96,33 +104,29 @@ namespace ModBus.Net
                     AddInfo("client connect exception: " + err.Message);
                     return false;
                 }
-            }
         }
 
         public override bool Disconnect()
         {
-            lock (this)
+            if (_socketClient == null)
             {
-                if (m_socketClient == null)
-                {
-                    return true;
-                }
+                return true;
+            }
 
-                try
-                {
-                    m_socketClient.Close();
-                    AddInfo("client disconnected successfully.");
-                    return true;
-                }
-                catch (Exception err)
-                {
-                    AddInfo("client disconnected exception: " + err.Message);
-                    return false;
-                }
-                finally
-                {
-                    m_socketClient = null;
-                }
+            try
+            {
+                _socketClient.Close();
+                AddInfo("client disconnected successfully.");
+                return true;
+            }
+            catch (Exception err)
+            {
+                AddInfo("client disconnected exception: " + err.Message);
+                return false;
+            }
+            finally
+            {
+                _socketClient = null;
             }
         }
 
@@ -131,18 +135,28 @@ namespace ModBus.Net
             Console.WriteLine(message);
         }
 
+        public override bool SendMsgWithoutReturn(byte[] message)
+        {
+            return AsyncHelper.RunSync(() => SendMsgWithoutReturnAsync(message));
+        }
+
         /// <summary>
         ///     发送数据，不需要返回任何值
         /// </summary>
         /// <param name="message">发送的信息</param>
         /// <returns>是否发送成功</returns>
-        public override bool SendMsgWithoutReturn(byte[] message)
+        public override async Task<bool> SendMsgWithoutReturnAsync(byte[] message)
         {
             byte[] datagram = message;
 
             try
             {
-                m_socketClient.Client.Send(datagram);
+                if (!IsConnected)
+                {
+                    await ConnectAsync();
+                }
+                
+                await _stream.WriteAsync(datagram, 0, datagram.Length);
 
                 RefreshSendCount();
                 //this.AddInfo("send text len = " + datagramText.Length.ToString());
@@ -156,12 +170,17 @@ namespace ModBus.Net
             }
         }
 
+        public override byte[] SendMsg(byte[] message)
+        {
+            return AsyncHelper.RunSync(() => SendMsgAsync(message));
+        }
+
         /// <summary>
         ///     发送数据，需要返回
         /// </summary>
         /// <param name="message">发送的数据</param>
         /// <returns>是否发送成功</returns>
-        public override byte[] SendMsg(byte[] message)
+        public override async Task<byte[]> SendMsgAsync(byte[] message)
         {
             byte[] datagram = message;
 
@@ -169,14 +188,16 @@ namespace ModBus.Net
             {
                 if (!IsConnected)
                 {
-                    Connect();
+                    await ConnectAsync();
                 }
-                m_socketClient.Client.Send(datagram);
+
+                var stream = _socketClient.GetStream();
+                await stream.WriteAsync(datagram, 0, datagram.Length);
 
                 RefreshSendCount();
                 //this.AddInfo("send text len = " + datagramText.Length.ToString());
 
-                return Receive();
+                return await ReceiveAsync(stream);
             }
             catch (Exception err)
             {
@@ -186,19 +207,12 @@ namespace ModBus.Net
             }
         }
 
-        public byte[] Receive()
+        protected async Task<byte[]> ReceiveAsync(NetworkStream stream)
         {
             try
             {
+                int len = await stream.ReadAsync(_receiveBuffer, 0, _receiveBuffer.Length);
                 // 异步接收回答
-                if (b_AsyncReceive)
-                {
-                    m_socketClient.Client.BeginReceive(m_receiveBuffer, 0, m_receiveBuffer.Length, SocketFlags.None,
-                        EndReceiveDatagram, this);
-                    return null;
-                }
-                    // 同步接收回答
-                int len = m_socketClient.Client.Receive(m_receiveBuffer, 0, m_receiveBuffer.Length, SocketFlags.None);
                 if (len > 0)
                 {
                     return CheckReplyDatagram(len);
@@ -220,10 +234,9 @@ namespace ModBus.Net
         private byte[] CheckReplyDatagram(int len)
         {
             var replyMessage = new byte[len];
-            Array.Copy(m_receiveBuffer, replyMessage, len);
+            Array.Copy(_receiveBuffer, replyMessage, len);
 
             //this.AddInfo("reply: " + replyMesage);
-            ReceiveMessage(replyMessage);
             RefreshReceiveCount();
 
             if (len <= 0)
@@ -236,63 +249,30 @@ namespace ModBus.Net
 
         private void RefreshSendCount()
         {
-            m_sendCount++;
+            _sendCount++;
         }
 
         private void RefreshReceiveCount()
         {
-            m_receiveCount++;
+            _receiveCount++;
         }
 
         private void RefreshErrorCount()
         {
-            m_errorCount++;
+            _errorCount++;
         }
 
         private void CloseClientSocket()
         {
             try
             {
-                m_socketClient.Client.Shutdown(SocketShutdown.Both);
-                m_socketClient.Client.Close();
-                if (!IsConnected)
-                {
-                    if (SocketErrorShutdown != null)
-                    {
-                        Thread.Sleep(1000);
-                        SocketErrorShutdown(this, new EventArgs());
-                        AddInfo("socket error disconnected!");
-                    }
-                }
+                _stream.Close();
+                _socketClient.Client.Shutdown(SocketShutdown.Both);
+                _socketClient.Client.Close();
             }
             catch (Exception ex)
             {
-                //this.AddInfo("client close exception: " + ex.Message);
-            }
-        }
-
-        /// <summary>
-        ///     异步接收消息返回函数
-        /// </summary>
-        /// <param name="iar">异步参数</param>
-        private void EndReceiveDatagram(IAsyncResult iar)
-        {
-            try
-            {
-                int readBytesLength = m_socketClient.Client.EndReceive(iar);
-                if (readBytesLength == 0)
-                {
-                    CloseClientSocket();
-                }
-                else // 正常数据包
-                {
-                    CheckReplyDatagram(readBytesLength);
-                }
-            }
-            catch (Exception err)
-            {
-                AddInfo("receive exception: " + err.Message);
-                CloseClientSocket();
+                AddInfo("client close exception: " + ex.Message);
             }
         }
     }
diff --git a/Modbus.Net/ModBus.Net/TcpProtocalLinker.cs b/Modbus.Net/ModBus.Net/TcpProtocalLinker.cs
index e12f7a2..bc5b3e9 100644
--- a/Modbus.Net/ModBus.Net/TcpProtocalLinker.cs
+++ b/Modbus.Net/ModBus.Net/TcpProtocalLinker.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 
 namespace ModBus.Net
 {
@@ -17,7 +18,7 @@ namespace ModBus.Net
 
         protected TcpProtocalLinker(string ip, int port)
         {
-            _baseConnector = new TcpConnector(ip, port, false);
+            _baseConnector = new TcpConnector(ip, port, 10000);
         }
     }   
 }
\ No newline at end of file
diff --git a/Modbus.Net/ModBus.Net/ValueHelper.cs b/Modbus.Net/ModBus.Net/ValueHelper.cs
index 69b43e5..cd03000 100644
--- a/Modbus.Net/ModBus.Net/ValueHelper.cs
+++ b/Modbus.Net/ModBus.Net/ValueHelper.cs
@@ -25,7 +25,7 @@ namespace ModBus.Net
             {"System.Double", 8}
         };
 
-        protected static bool _littleEndian = false;
+        protected static bool _littleEndian = true;
 
         protected ValueHelper()
         {
@@ -41,7 +41,7 @@ namespace ModBus.Net
             {
                 _littleEndian = value;
                 //这里需要重点说明，因为.net默认是小端构造法，所以目标协议是大端的话反而需要调用小端构造协议，把小端反转为大端。
-                _Instance = LittleEndian ? new ValueHelper() : new LittleEndianValueHelper();
+                _Instance = LittleEndian ? new LittleEndianValueHelper() : new ValueHelper();
             }
         }
 
@@ -58,7 +58,7 @@ namespace ModBus.Net
             {
                 if (_Instance == null)
                 {
-                    _Instance = LittleEndian ? new ValueHelper() : new LittleEndianValueHelper();
+                    _Instance = LittleEndian ? new LittleEndianValueHelper() : new ValueHelper();
                 }
                 return _Instance;
             }
@@ -285,7 +285,7 @@ namespace ModBus.Net
             byte temp = data[pos];
             for (int i = 0; i < 8; i++)
             {
-                t[7 - i] = temp%2 > 0;
+                t[i] = temp % 2 > 0;
                 temp /= 2;
             }
             pos += 1;
@@ -709,7 +709,7 @@ namespace ModBus.Net
             byte temp = data[pos];
             for (int i = 0; i < 8; i++)
             {
-                t[i] = temp%2 > 0;
+                t[7 - i] = temp % 2 > 0;
                 temp /= 2;
             }
             pos += 1;
diff --git a/Modbus.Net/ModBus.Net/key.pfx b/Modbus.Net/ModBus.Net/key.pfx
new file mode 100644
index 0000000000000000000000000000000000000000..e6d56aaa96f18dc8b51d1dd8bea1577216c01f92
GIT binary patch
literal 1764
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
E0&E)gVE_OC

literal 0
HcmV?d00001