using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MECF.Framework.RT.Core.IoProviders.Siemens;
using MECF.Framework.RT.Core.IoProviders.Siemens.IMessage;
using MECF.Framework.RT.Core.IoProviders.Siemens.Net;
using MECF.Framework.RT.Core.IoProviders.Siemens.Transfer;
#if !NET35
using System.Threading.Tasks;
#endif
namespace MECF.Framework.RT.Core.IoProviders.Siemens.Net.NetworkBase
{
///
/// 设备类的基类,提供了基础的字节读写方法
///
/// 指定了消息的解析规则
/// 指定了数据转换的规则
/// 需要继承实现采用使用。
public class NetworkDeviceBase : NetworkDoubleBase , IReadWriteNet where TNetMessage : INetMessage, new() where TTransform : IByteTransform, new()
{
#region Virtual Method
/**************************************************************************************************
*
* 说明:子类中需要重写基础的读取和写入方法,来支持不同的数据访问规则
*
* 此处没有将读写位纳入进来,因为各种设备的支持不尽相同,比较麻烦
*
**************************************************************************************************/
///
/// 从设备读取原始数据
///
/// 起始地址
/// 地址长度
/// 带有成功标识的结果对象
/// 需要在继承类中重写实现,并且实现地址解析操作
public virtual OperateResult Read( string address, ushort length )
{
return new OperateResult( );
}
///
/// 将原始数据写入设备
///
/// 起始地址
/// 原始数据
/// 带有成功标识的结果对象
/// 需要在继承类中重写实现,并且实现地址解析操作
public virtual OperateResult Write( string address, byte[] value )
{
return new OperateResult( );
}
#endregion
#region Protect Member
///
/// 单个数据字节的长度,西门子为2,三菱,欧姆龙,modbusTcp就为1,AB PLC无效
///
/// 对设备来说,一个地址的数据对应的字节数,或是1个字节或是2个字节
protected ushort WordLength { get; set; } = 1;
#endregion
#region Customer Support
///
/// 读取自定义类型的数据,需要规定解析规则
///
/// 类型名称
/// 起始地址
/// 带有成功标识的结果对象
///
/// 需要是定义一个类,选择好相对于的ByteTransform实例,才能调用该方法。
///
///
/// 此处演示三菱的读取示例,先定义一个类,实现接口
///
/// 接下来就可以实现数据的读取了
///
///
public OperateResult ReadCustomer( string address ) where T : IDataTransfer, new()
{
OperateResult result = new OperateResult( );
T Content = new T( );
OperateResult read = Read( address, Content.ReadCount );
if (read.IsSuccess)
{
Content.ParseSource( read.Content );
result.Content = Content;
result.IsSuccess = true;
}
else
{
result.ErrorCode = read.ErrorCode;
result.Message = read.Message;
}
return result;
}
///
/// 写入自定义类型的数据到设备去,需要规定生成字节的方法
///
/// 自定义类型
/// 起始地址
/// 实例对象
/// 带有成功标识的结果对象
///
/// 需要是定义一个类,选择好相对于的实例,才能调用该方法。
///
///
/// 此处演示三菱的读取示例,先定义一个类,实现接口
///
/// 接下来就可以实现数据的读取了
///
///
public OperateResult WriteCustomer( string address, T data ) where T : IDataTransfer, new()
{
return Write( address, data.ToSource( ) );
}
#endregion
#region Read Support
///
/// 读取设备的short类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadInt16( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadInt16( address, 1 ) );
}
///
/// 读取设备的short类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadInt16( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength) ), m => ByteTransform.TransInt16( m, 0, length ) );
}
///
/// 读取设备的ushort数据类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadUInt16( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadUInt16( address, 1 ) );
}
///
/// 读取设备的ushort类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadUInt16( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength) ), m => ByteTransform.TransUInt16( m, 0, length ) );
}
///
/// 读取设备的int类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadInt32( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadInt32( address, 1 ) );
}
///
/// 读取设备的int类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadInt32( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 2) ), m => ByteTransform.TransInt32( m, 0, length ) );
}
///
/// 读取设备的uint类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadUInt32( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadUInt32( address, 1 ) );
}
///
/// 读取设备的uint类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadUInt32( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 2) ), m => ByteTransform.TransUInt32( m, 0, length ) );
}
///
/// 读取设备的float类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadFloat( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadFloat( address, 1 ) );
}
///
/// 读取设备的float类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadFloat( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 2) ), m => ByteTransform.TransSingle( m, 0, length ) );
}
///
/// 读取设备的long类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadInt64( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadInt64( address, 1 ) );
}
///
/// 读取设备的long类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadInt64( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 4) ), m => ByteTransform.TransInt64( m, 0, length ) );
}
///
/// 读取设备的ulong类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadUInt64( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadUInt64( address, 1 ) );
}
///
/// 读取设备的ulong类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadUInt64( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 4) ), m => ByteTransform.TransUInt64( m, 0, length ) );
}
///
/// 读取设备的double类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadDouble( string address )
{
return ByteTransformHelper.GetResultFromArray( ReadDouble( address, 1 ) );
}
///
/// 读取设备的double类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult ReadDouble( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, (ushort)(length * WordLength * 4) ), m => ByteTransform.TransDouble( m, 0, length ) );
}
///
/// 读取设备的字符串数据,编码为ASCII
///
/// 起始地址
/// 地址长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadString( string address, ushort length )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, length ), m => ByteTransform.TransString( m, 0, m.Length, Encoding.ASCII ) );
}
///
/// 读取设备的字符串数据,编码为指定的编码信息
///
/// 起始地址
/// 地址长度
/// 编码机制
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult ReadString( string address, ushort length, Encoding encoding )
{
return ByteTransformHelper.GetResultFromBytes( Read( address, length ), m => ByteTransform.TransString( m, 0, m.Length, encoding ) );
}
#endregion
#region Read Write Async Support
#if !NET35
///
/// 使用异步的操作从原始的设备中读取数据信息
///
/// 起始地址
/// 地址长度
/// 带有成功标识的结果对象
public Task> ReadAsync(string address, ushort length )
{
return Task.Run( ( ) => Read( address, length ) );
}
///
/// 异步读取设备的short类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadInt16Async( string address )
{
return Task.Run( ( ) => ReadInt16( address ) );
}
///
/// 异步读取设备的ushort类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadInt16Async( string address, ushort length )
{
return Task.Run( ( ) => ReadInt16( address, length ) );
}
///
/// 异步读取设备的ushort数据类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadUInt16Async( string address )
{
return Task.Run( ( ) => ReadUInt16( address ) );
}
///
/// 异步读取设备的ushort类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadUInt16Async( string address, ushort length )
{
return Task.Run( ( ) => ReadUInt16( address, length ) );
}
///
/// 异步读取设备的int类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadInt32Async( string address )
{
return Task.Run( ( ) => ReadInt32( address ) );
}
///
/// 异步读取设备的int类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadInt32Async( string address, ushort length )
{
return Task.Run( ( ) => ReadInt32( address, length ) );
}
///
/// 异步读取设备的uint类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadUInt32Async( string address )
{
return Task.Run( ( ) => ReadUInt32( address ) );
}
///
/// 异步读取设备的uint类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadUInt32Async( string address, ushort length )
{
return Task.Run( ( ) => ReadUInt32( address, length ) );
}
///
/// 异步读取设备的float类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadFloatAsync( string address )
{
return Task.Run( ( ) => ReadFloat( address ) );
}
///
/// 异步读取设备的float类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadFloatAsync( string address, ushort length )
{
return Task.Run( ( ) => ReadFloat( address, length ) );
}
///
/// 异步读取设备的long类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadInt64Async( string address )
{
return Task.Run( ( ) => ReadInt64( address ) );
}
///
/// 异步读取设备的long类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadInt64Async( string address, ushort length )
{
return Task.Run( ( ) => ReadInt64( address, length ) );
}
///
/// 异步读取设备的ulong类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadUInt64Async( string address )
{
return Task.Run( ( ) => ReadUInt64( address ) );
}
///
/// 异步读取设备的ulong类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadUInt64Async( string address, ushort length )
{
return Task.Run( ( ) => ReadUInt64( address, length ) );
}
///
/// 异步读取设备的double类型的数据
///
/// 起始地址
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadDoubleAsync( string address )
{
return Task.Run( ( ) => ReadDouble( address ) );
}
///
/// 异步读取设备的double类型的数组
///
/// 起始地址
/// 数组长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadDoubleAsync( string address, ushort length )
{
return Task.Run( ( ) => ReadDouble( address, length ) );
}
///
/// 异步读取设备的字符串数据,编码为ASCII
///
/// 起始地址
/// 地址长度
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadStringAsync( string address, ushort length )
{
return Task.Run( ( ) => ReadString( address, length ) );
}
///
/// 读取设备的字符串数据,编码为指定的编码信息
///
/// 起始地址
/// 地址长度
/// 编码机制
/// 带成功标志的结果数据对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task> ReadStringAsync( string address, ushort length, Encoding encoding )
{
return Task.Run( ( ) => ReadString( address, length, encoding ) );
}
///
/// 异步将原始数据写入设备
///
/// 起始地址
/// 原始数据
/// 带有成功标识的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, byte[] value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入short数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, short[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入short数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, short value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入ushort数组,返回是否写入成功
///
/// 要写入的数据地址
/// 要写入的实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, ushort[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入ushort数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, ushort value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入int数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, int[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入int数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, int value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入uint数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, uint[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入uint数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, uint value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入float数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 返回写入结果
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, float[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入float数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 返回写入结果
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, float value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入long数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, long[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入long数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, long value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向P设备中写入ulong数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, ulong[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入ulong数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, ulong value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入double数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, double[] values )
{
return Task.Run( ( ) => Write( address, values ) );
}
///
/// 异步向设备中写入double数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, double value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入字符串,编码格式为ASCII
///
/// 数据地址
/// 字符串数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, string value )
{
return Task.Run( ( ) => Write( address, value ) );
}
///
/// 异步向设备中写入字符串,使用指定的字符编码
///
/// 数据地址
/// 字符串数据
/// 字符编码
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, string value, Encoding encoding )
{
return Task.Run( ( ) => Write( address, value, encoding ) );
}
///
/// 异步向设备中写入指定长度的字符串,超出截断,不够补0,编码格式为ASCII
///
/// 数据地址
/// 字符串数据
/// 指定的字符串长度,必须大于0
/// 是否写入成功的结果对象 -> Whether to write a successful result object
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, string value, int length )
{
return Task.Run( ( ) => Write( address, value, length ) );
}
///
/// 异步向设备中写入指定长度的字符串,超出截断,不够补0,指定的编码格式
///
/// 数据地址
/// 字符串数据
/// 指定的字符串长度,必须大于0
/// 指定的编码格式
/// 是否写入成功的结果对象 -> Whether to write a successful result object
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public Task WriteAsync( string address, string value, int length, Encoding encoding )
{
return Task.Run( ( ) => Write( address, value, length, encoding ) );
}
///
/// 异步向设备中写入字符串,编码格式为Unicode
///
/// 数据地址
/// 字符串数据
/// 是否写入成功的结果对象
public Task WriteUnicodeStringAsync( string address, string value )
{
return Task.Run( ( ) => WriteUnicodeString( address, value ) );
}
///
/// 异步向设备中写入指定长度的字符串,超出截断,不够补0,编码格式为Unicode
///
/// 数据地址
/// 字符串数据
/// 指定的字符串长度,必须大于0
/// 是否写入成功的结果对象 -> Whether to write a successful result object
public Task WriteUnicodeStringAsync( string address, string value, int length )
{
return Task.Run( ( ) => WriteUnicodeString( address, value, length ) );
}
///
/// 异步读取自定义类型的数据,需要规定解析规则
///
/// 类型名称
/// 起始地址
/// 带有成功标识的结果对象
///
/// 需要是定义一个类,选择好相对于的ByteTransform实例,才能调用该方法。
///
///
/// 此处演示三菱的读取示例,先定义一个类,实现接口
///
/// 接下来就可以实现数据的读取了
///
///
public Task> ReadCustomerAsync( string address ) where T : IDataTransfer, new()
{
return Task.Run( ( ) => ReadCustomer( address ) );
}
///
/// 异步写入自定义类型的数据到设备去,需要规定生成字节的方法
///
/// 自定义类型
/// 起始地址
/// 实例对象
/// 带有成功标识的结果对象
///
/// 需要是定义一个类,选择好相对于的实例,才能调用该方法。
///
///
/// 此处演示三菱的读取示例,先定义一个类,实现接口
///
/// 接下来就可以实现数据的读取了
///
///
public Task WriteCustomerAsync( string address, T data ) where T : IDataTransfer, new()
{
return Task.Run( ( ) => WriteCustomer( address, data ) );
}
#endif
#endregion
#region Write Int16
///
/// 向设备中写入short数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, short[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入short数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, short value )
{
return Write( address, new short[] { value } );
}
#endregion
#region Write UInt16
///
/// 向设备中写入ushort数组,返回是否写入成功
///
/// 要写入的数据地址
/// 要写入的实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, ushort[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入ushort数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, ushort value )
{
return Write( address, new ushort[] { value } );
}
#endregion
#region Write Int32
///
/// 向设备中写入int数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, int[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入int数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, int value )
{
return Write( address, new int[] { value } );
}
#endregion
#region Write UInt32
///
/// 向设备中写入uint数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, uint[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入uint数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, uint value )
{
return Write( address, new uint[] { value } );
}
#endregion
#region Write Float
///
/// 向设备中写入float数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 返回写入结果
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, float[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入float数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 返回写入结果
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, float value )
{
return Write( address, new float[] { value } );
}
#endregion
#region Write Int64
///
/// 向设备中写入long数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, long[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入long数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, long value )
{
return Write( address, new long[] { value } );
}
#endregion
#region Write UInt64
///
/// 向P设备中写入ulong数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, ulong[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入ulong数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, ulong value )
{
return Write( address, new ulong[] { value } );
}
#endregion
#region Write Double
///
/// 向设备中写入double数组,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, double[] values )
{
return Write( address, ByteTransform.TransByte( values ) );
}
///
/// 向设备中写入double数据,返回是否写入成功
///
/// 数据地址
/// 实际数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public OperateResult Write( string address, double value )
{
return Write( address, new double[] { value } );
}
#endregion
#region Write String
///
/// 向设备中写入字符串,编码格式为ASCII
///
/// 数据地址
/// 字符串数据
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, string value )
{
return Write( address, value, Encoding.ASCII );
}
///
/// 向设备中写入指定编码的字符串
///
/// 数据地址
/// 字符串数据
/// 字节编码
/// 是否写入成功的结果对象
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, string value, Encoding encoding )
{
byte[] temp = ByteTransform.TransByte( value, encoding );
if (WordLength == 1) temp = SoftBasic.ArrayExpandToLengthEven( temp );
return Write( address, temp );
}
///
/// 向设备中写入指定长度的字符串,超出截断,不够补0,编码格式为ASCII
///
/// 数据地址
/// 字符串数据
/// 指定的字符串长度,必须大于0
/// 是否写入成功的结果对象 -> Whether to write a successful result object
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, string value, int length )
{
return Write( address, value, length, Encoding.ASCII );
}
///
/// 向设备中写入指定长度并且指定编码的字符串,超出截断,不够补0
///
/// 数据地址
/// 字符串数据
/// 指定的长度,按照转换后的字节计算
/// 字符编码
/// 是否写入成功的结果对象 -> Whether to write a successful result object
///
/// 以下为三菱的连接对象示例,其他的设备读写情况参照下面的代码:
///
///
public virtual OperateResult Write( string address, string value, int length, Encoding encoding )
{
byte[] temp = ByteTransform.TransByte( value, encoding );
if (WordLength == 1) temp = SoftBasic.ArrayExpandToLengthEven( temp );
temp = SoftBasic.ArrayExpandToLength( temp, length );
return Write( address, temp );
}
///
/// 向设备中写入字符串,编码格式为Unicode
///
/// 数据地址
/// 字符串数据
/// 是否写入成功的结果对象
public virtual OperateResult WriteUnicodeString( string address, string value )
{
byte[] temp = ByteTransform.TransByte( value, Encoding.Unicode );
return Write( address, temp );
}
///
/// 向设备中写入指定长度的字符串,超出截断,不够补0,编码格式为Unicode
///
/// 数据地址
/// 字符串数据
/// 指定的字符串长度,必须大于0
/// 是否写入成功的结果对象 -> Whether to write a successful result object
public virtual OperateResult WriteUnicodeString( string address, string value, int length )
{
byte[] temp = ByteTransform.TransByte( value, Encoding.Unicode );
temp = SoftBasic.ArrayExpandToLength( temp, length * 2 );
return Write( address, temp );
}
#endregion
#region Object Override
///
/// 返回表示当前对象的字符串
///
/// 字符串数据
public override string ToString( )
{
return $"NetworkDeviceBase<{typeof(TNetMessage)}, {typeof(TTransform)}>[{IpAddress}:{Port}]";
}
#endregion
}
}