博客园_happyhippy

C#使用TCP/IP与ModBus进行通讯

2011-07-17T15:28:00Z

1. ModBus的 Client/Server模型
2. 数据包格式及MBAP header (MODBUS Application Protocol header)
3. 大小端转换
4. 事务标识和缓冲清理
5. 示例代码

0. MODBUS MESSAGING ON TCP/IP IMPLEMENTATION GUIDE

下载地址：http://www.modbus.org/docs/Modbus_Messaging_Implementation_Guide_V1_0b.pdf

1. ModBus的 Client/Server模型

Client与Server之间有两种通讯方式：一种是TCP/IP，另一种是通过串口(Serial Port)，本文重点介绍第一种通讯方式。第二种方式留了接口，暂时还没有实现。

2. 数据包格式及MBAP header (MODBUS Application Protocol header)

2.1 数据包格式

数据交换过程中，数据包的格式由三部分组成：协议头 + 功能码 + 数据(请求或接受的数据)。
    这里主要用到下列两个功能码（十进制）：
    3: 读取寄存器中的值（Read Multiple Register）
    16: 往寄存器中写值（Write Multiple Register）

2.2 MBAP header

协议头具体包括下列4个字段：
(1) Transaction Identifier：事务ID标识，Client每发送一个Request数据包的时候，需要带上该标识；当Server响应该请求的时候，会把该标识复制到Response中；这样客户端就可以进行容错判断，防止数据包发串了。
(2) Protocal Identifier：协议标识，ModBus协议中，该值为0；
(3) Length：整个数据包中，从当个前这个字节之后开始计算，后续数据量的大小(按byte计算)。
(4) Unit Identifier：-_-

3. 大小端转换

ModBus使用Big-Endian表示地址和数据项。因此在发送或者接受数据的过程中，需要对数据进行转换。

3.1 判断大小端

对于整数1，在两种机器上有两种不同的标示方式，如上图所示；因此，我们可以用&操作符来取其地址，再转换成指向byte的指针(byte*)，最后再取该指针的值；若得到的byte值为1，则为Little-Endian，否则为Big-Endian。

   1: unsafe   2: {   3:     int tester = 1;   4:     bool littleEndian = (*(byte*)(&tester)) == (byte)1;   5: }

3.2 整数/浮点数转换成Byte数组

.Net提供了现成的API，可以BitConverter.GetBytes(value)和BitConverter.ToXXOO(Byte[] data)来进行转换。下面的代码对该转换进行了封装，加入了Little-Endian转Big-Endian的处理（以int为例）：

   1: public class ValueHelper //Big-Endian可以直接转换   2: {   3:         public virtual Byte[] GetBytes(int value)   4:         {   5:             return BitConverter.GetBytes(value);   6:         }   7:         public virtual int GetInt(byte[] data)   8:         {   9:             return BitConverter.ToInt32(data, 0);  10:         }  11: }  12:    13: internal class LittleEndianValueHelper : ValueHelper //Little-Endian，转换时需要做翻转处理。  14: {  15:         public override Byte[] GetBytes(int value)  16:         {  17:             return this.Reverse(BitConverter.GetBytes(value));  18:         }  19:         public virtual int GetInt(byte[] data)  20:         {  21:             return BitConverter.ToInt32(this.Reverse(data), 0);  22:         }  23:         private Byte[] Reverse(Byte[] data)  24:         {  25:             Array.Reverse(data);  26:             return data;  27:         }  28: }

4. 事务标识和缓冲处理

4.1 Transaction Identifier

上面2.2节中提到，Client每发送一个Request数据包的时候，需要带上一个标识；当Server响应该请求的时候，会把该标识复制到Response中，返回给Client。这样Client就可以用来判断数据包有没有发串。在程序中，可以可以用一个变量及记录该标识：

   1: private byte dataIndex = 0;   2:     3: protected byte CurrentDataIndex   4: {   5:        get { return this.dataIndex; }   6: }   7:     8: protected byte NextDataIndex()   9: {  10:        return ++this.dataIndex;  11: }

每次Client发送数据的时候，调用NextDataIndex()来取得事务标识；接着当Client读取Server的返回值的时候，需要判断数据包中的数据标识是否与发送时的标志一致；如果一致，则认为数据包有效；否则丢掉无效的数据包。

4.2 缓冲处理

上节中提到，如果Client接收到的响应数据包中的标识，与发送给Server的数据标识不一致，则认为Server返回的数据包无效，并丢弃该数据包。

如果只考虑正常情况，即数据木有差错，Client每次发送请求后，其请求包里面包含需要读取的寄存器数量，能算出从Server返回的数据两大小，这样就能确定读完Server返回的所有缓冲区中的数据；每次交互后，Socket缓冲区中都为空，则整个过程没有问题。但是问题是：如果Server端出错，或者数据串包等异常情况下，Client不能确定Server返回的数据包(占用的缓冲区)有多大；如果缓冲区中的数据没有读完，下次再从缓冲区中接着读的时候，数据包必然是不正确的，而且会错误会一直延续到后续的读取操作中。

因此，每次读取数据时，要么全部读完缓冲区中的数据，要么读到错误的时候，就必须清楚缓冲区中剩余的数据。网上搜了半天，木有找到Windows下如何清理Socket缓冲区的。有篇文章倒是提到一个狠招，每次读完数据后，直接把Socket给咔嚓掉；然后下次需要读取或发送数据的时候，再重新建立Socket连接。

回过头再来看，其实，在Client与Server进行交互的过程中，Server每次返回的数据量都不大，也就一个MBAP Header + 几十个寄存器的值。因此，另一个处理方式，就是每次读取尽可能多的数据(多过缓冲区中的数据量)，多读的内容，再忽略掉。暂时这么处理，期待有更好的解决方法。

5. 源代码

5.1 类图结构：

5.2 使用示例

(1) 写入数据：

   1: this.Wrapper.Send(Encoding.ASCII.GetBytes(this.tbxSendText.Text.Trim()));   2:     3: public override void Send(byte[] data)   4: {   5:     //[0]:填充0，清掉剩余的寄存器   6:     if (data.Length < 60)   7:     {   8:         var input = data;   9:         data = new Byte[60];  10:         Array.Copy(input, data, input.Length);  11:     }  12:     this.Connect();  13:     List<byte> values = new List<byte>(255);  14:    15:     //[1].Write Header：MODBUS Application Protocol header  16:     values.AddRange(ValueHelper.Instance.GetBytes(this.NextDataIndex()));//1~2.(Transaction Identifier)  17:     values.AddRange(new Byte[] { 0, 0 });//3~4:Protocol Identifier,0 = MODBUS protocol  18:     values.AddRange(ValueHelper.Instance.GetBytes((byte)(data.Length + 7)));//5~6:后续的Byte数量  19:     values.Add(0);//7:Unit Identifier:This field is used for intra-system routing purpose.  20:     values.Add((byte)FunctionCode.Write);//8.Function Code : 16 (Write Multiple Register)  21:     values.AddRange(ValueHelper.Instance.GetBytes(StartingAddress));//9~10.起始地址  22:     values.AddRange(ValueHelper.Instance.GetBytes((short)(data.Length / 2)));//11~12.寄存器数量  23:     values.Add((byte)data.Length);//13.数据的Byte数量  24:    25:     //[2].增加数据  26:     values.AddRange(data);//14~End:需要发送的数据  27:    28:     //[3].写数据  29:     this.socketWrapper.Write(values.ToArray());  30:    31:     //[4].防止连续读写引起前台UI线程阻塞  32:     Application.DoEvents();  33:    34:     //[5].读取Response: 写完后会返回12个byte的结果  35:     byte[] responseHeader = this.socketWrapper.Read(12);  36: }

(2) 读取数据：

   1: this.tbxReceiveText.Text = Encoding.ASCII.GetString(this.Wrapper.Receive());   2:     3:         public override byte[] Receive()   4:         {   5:             this.Connect();   6:             List<byte> sendData = new List<byte>(255);   7:     8:             //[1].Send   9:             sendData.AddRange(ValueHelper.Instance.GetBytes(this.NextDataIndex()));//1~2.(Transaction Identifier)  10:             sendData.AddRange(new Byte[] { 0, 0 });//3~4:Protocol Identifier,0 = MODBUS protocol  11:             sendData.AddRange(ValueHelper.Instance.GetBytes((short)6));//5~6:后续的Byte数量（针对读请求，后续为6个byte）  12:             sendData.Add(0);//7:Unit Identifier:This field is used for intra-system routing purpose.  13:             sendData.Add((byte)FunctionCode.Read);//8.Function Code : 3 (Read Multiple Register)  14:             sendData.AddRange(ValueHelper.Instance.GetBytes(StartingAddress));//9~10.起始地址  15:             sendData.AddRange(ValueHelper.Instance.GetBytes((short)30));//11~12.需要读取的寄存器数量  16:             this.socketWrapper.Write(sendData.ToArray()); //发送读请求  17:    18:             //[2].防止连续读写引起前台UI线程阻塞  19:             Application.DoEvents();  20:    21:             //[3].读取Response Header : 完后会返回8个byte的Response Header  22:             byte[] receiveData = this.socketWrapper.Read(256);//缓冲区中的数据总量不超过256byte，一次读256byte，防止残余数据影响下次读取  23:             short identifier = (short)((((short)receiveData[0]) << 8) + receiveData[1]);  24:    25:             //[4].读取返回数据：根据ResponseHeader，读取后续的数据  26:             if (identifier != this.CurrentDataIndex) //请求的数据标识与返回的标识不一致，则丢掉数据包  27:             {  28:                 return new Byte[0];  29:             }  30:             byte length = receiveData[8];//最后一个字节，记录寄存器中数据的Byte数  31:             byte[] result = new byte[length];  32:             Array.Copy(receiveData, 9, result, 0, length);  33:             return result;  34:         }

(3) 测试发送和读取：

ModBus-TCP Client Tool（可以从网上下载，用来测试）中，可以点击“Edit Values”，修改寄存器中的值；然后再在测试程序中，点击“接收”，可以解析到修改后的值。这里只是测试发送和接收字符串，如果需要处理复杂的数字/字符串组合啥的，就需要自己定义数据格式和解析方式了。

5.3 代码下载

CSharpModBusExample

标签: ModBus,大小端,TCP/IP,Socket缓冲区

本文链接

ProtocolException : 已超过传入消息(65536)的最大消息大小配额。

2011-07-02T13:40:00Z

SilverLight调用WCF，提交的是一个List<Linq2SqlEntity>；当List中数据量不大的时候，不会报错；当数据量稍微大一点儿，就会出现这个错误。发生了 System.ServiceModel.ProtocolException
Message=已超过传入消息(65536)的最大消息大小配额。若要增加配额，请使用相应绑定元素上的 MaxReceivedMessageSize 属性。
Source=System.ServiceModel
StackTrace:
在 System.ServiceModel.Channels.HttpInput.ThrowHttpProtocolException(String message, HttpStatusCode statusCode, String statusDescription)

费了牛劲在网上搜了一通，有的说是要修改behavior的maxItemsInObjectGraph，有的说要修改binding的maxBufferSize/maxReceivedMessageSize，有的说要增加readerQuotas，有的是endpoint没有与自定义binding配置节关联起来，有的说要客户端和服务器端都要改(我的应用中，接受数据的是服务器端，客户端负责提交，所以应该不关客户端的事儿)。。。然后把server端的配置文件调整成下面这样：

   1: <system.serviceModel>   2:   <behaviors>   3:     <serviceBehaviors>   4:       <behavior name="MessageHeaderOperationBehaviourAuthenticationBehavior">   5:         <dataContractSerializer maxItemsInObjectGraph="2147483647"/>   6:         <serviceMetadata httpGetEnabled="true"/>   7:         <serviceDebug includeExceptionDetailInFaults="true"/>   8:       </behavior>   9:     </serviceBehaviors>  10:   </behaviors>  11:   <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true"/>  12:   <services>  13:     <service behaviorConfiguration="MessageHeaderOperationBehaviourAuthenticationBehavior"  14:              name="MessageHeaderOperationBehaviourAuthentication">  15:       <endpoint address="" binding="basicHttpBinding" bindingConfiguration="LargeSize" contract="DyeService">  16:       </endpoint>  17:     </service>  18:   </services>  19:   <bindings>  20:     <basicHttpBinding>  21:       <binding name="LargeSize"  maxBufferSize="2147483647"  22:                maxBufferPoolSize="21474836471" maxReceivedMessageSize="2147483647">  23:         <readerQuotas maxDepth="2147483647" maxStringContentLength="2147483647"  24:                       maxArrayLength="2147483647" maxBytesPerRead="2147483647"  25:                       maxNameTableCharCount="2147483647" />  26:         <security mode="None" />  27:       </binding>  28:     </basicHttpBinding>  29:   </bindings>  30: </system.serviceModel>

但是问题依旧。最后在stackoverflow找到了正解：WCF Error - unexpected response: (400) Bad Request.，里面链接到了另一篇帖子：Cannot get the MaxReceivedMessageSize higher than (65536)

解决办法就是：配置文件中，service 的name属性必须与服务的类型全名称保持一致，才能应用上自定义的配置节。

按着这个方法，调整之后的配置文件如下所示（删掉了其他无关的maxItemsInObjectGraph、readerQuotas等）：

   1:     2:   <system.serviceModel>   3:     <behaviors>   4:       <serviceBehaviors>   5:         <behavior name="MessageHeaderOperationBehaviourAuthenticationBehavior">   6:           <serviceMetadata httpGetEnabled="true"/>   7:           <serviceDebug includeExceptionDetailInFaults="true"/>   8:         </behavior>   9:       </serviceBehaviors>  10:     </behaviors>  11:     <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true"/>  12:     <services>  13:       <service behaviorConfiguration="MessageHeaderOperationBehaviourAuthenticationBehavior"  14:                name="NameSpace.DyeService">  15:         <endpoint address="" binding="basicHttpBinding" bindingConfiguration="LargeSize" contract="NameSpace.DyeService">  16:         </endpoint>  17:       </service>  18:     </services>  19:     <bindings>  20:       <basicHttpBinding>  21:         <binding name="LargeSize"  maxBufferSize="2147483647"  22:                  maxBufferPoolSize="21474836471" maxReceivedMessageSize="2147483647">  23:         </binding>  24:       </basicHttpBinding>  25:     </bindings>  26:   </system.serviceModel>

标签: WCF,ProtocalException,65535,SilverLight

本文链接

ESC/P打印：程序控制打印机自动进退纸

2011-06-25T16:00:00Z

打印连续纸张的时候，经常会遇到需要自动进退纸的功能，譬如下列场景：
1. 打印完一个小标；(自动进纸)
2. 用户撕断打印出来的小标；
3. (自动退纸，纸张归位) 接着打印下一个小标；

下列代码在爱普生LQ 730k打印机上测试通过：

   1: //使用示例   2: new PrintDirect("PrinterName").PrintESC(1);//打印后进纸   3: new PrintDirect("PrinterName").PrintESC(0);//打印前退纸

源代码：

   1:     2:     [StructLayout(LayoutKind.Sequential)]   3:     public struct DOCINFO   4:     {   5:         [MarshalAs(UnmanagedType.LPWStr)]   6:         public string pDocName;   7:         [MarshalAs(UnmanagedType.LPWStr)]   8:         public string pOutputFile;   9:         [MarshalAs(UnmanagedType.LPWStr)]  10:         public string pDataType;  11:     }  12:    13:     public class PrintDirect  14:     {  15:         private string PrintPort { get; set; }  16:         public PrintDirect(string port)  17:         {  18:             this.PrintPort = port;  19:         }  20:    21:         [DllImport("winspool.drv", CharSet = CharSet.Unicode, ExactSpelling = false, CallingConvention = CallingConvention.StdCall)]  22:         public static extern long OpenPrinter(string pPrinterName, ref IntPtr phPrinter, int pDefault);  23:    24:         [DllImport("winspool.drv", CharSet = CharSet.Unicode, ExactSpelling = false, CallingConvention = CallingConvention.StdCall)]  25:         public static extern long StartDocPrinter(IntPtr hPrinter, int Level, ref DOCINFO pDocInfo);  26:    27:         [DllImport("winspool.drv", CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]  28:         public static extern long StartPagePrinter(IntPtr hPrinter);  29:    30:         [DllImport("winspool.drv", CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]  31:         public static extern long WritePrinter(IntPtr hPrinter, string data, int buf, ref int pcWritten);  32:    33:         [DllImport("winspool.drv", CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]  34:         public static extern long EndPagePrinter(IntPtr hPrinter);  35:    36:         [DllImport("winspool.drv", CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]  37:         public static extern long EndDocPrinter(IntPtr hPrinter);  38:    39:         [DllImport("winspool.drv", CharSet = CharSet.Unicode, ExactSpelling = true, CallingConvention = CallingConvention.StdCall)]  40:         public static extern long ClosePrinter(IntPtr hPrinter);  41:    42:         public void PrintESC(int type)  43:         {  44:             System.IntPtr lhPrinter = new System.IntPtr();  45:             DOCINFO di = new DOCINFO();  46:             int pcWritten = 0;  47:             di.pDocName = "进退纸Document";  48:             di.pDataType = "RAW";  49:    50:             try  51:             {  52:                 PrintDirect.OpenPrinter(this.PrintPort, ref lhPrinter, 0);  53:                 if (lhPrinter == IntPtr.Zero)  54:                 {  55:                     MessageBox.Show(string.Format("没有连接打印机或者打印机端口不是{0}！", this.PrintPort),  56:                         "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);  57:                     return;  58:                 }  59:                 PrintDirect.StartDocPrinter(lhPrinter, 1, ref di);  60:                 PrintDirect.StartPagePrinter(lhPrinter);  61:                 string send = string.Empty;  62:                 for (int j = 0; j < 3; j++)  63:                 {  64:                     switch (type)  65:                     {  66:                         case 0:  67:                             send = "" + (char)(27) + (char)(64) + (char)(27) + 'j' + (char)(180);//退纸  68:                             break;  69:                         case 1:  70:                             send = "" + (char)(27) + (char)(64) + (char)(27) + 'J' + (char)(180);//进纸  71:                             break;  72:                         case 2:  73:                             send = "" + (char)(27) + (char)(64) + (char)(12);   //换行（未测试）  74:                             break;  75:                         default:  76:                             send = "" + (char)(27) + (char)(64) + (char)(12);   //换行（未测试）  77:                             break;  78:                     }  79:                     byte[] buf = new byte[80];  80:                     for (int i = 0; i < send.Length; i++)  81:                     {  82:                         buf[i] = (byte)send[i];  83:                     }  84:                     PrintDirect.WritePrinter(lhPrinter, send, send.Length, ref pcWritten);  85:                 }  86:             }  87:             catch (Exception e)  88:             {  89:                 MessageBox.Show(e.Message);  90:             }  91:             finally  92:             {  93:                 if (lhPrinter != IntPtr.Zero)  94:                 {  95:                     PrintDirect.EndPagePrinter(lhPrinter);  96:                     PrintDirect.EndDocPrinter(lhPrinter);  97:                     PrintDirect.ClosePrinter(lhPrinter);  98:                 }  99:             } 100:         } 101:     }

标签: ESC/P,打印,自动进纸,自动退纸

本文链接

判断泛型的值是否为default(T)

2011-06-21T15:00:00Z

   1: public static bool IsDefault<T>(this T value)    2: {   3:       //...   4: }

1. ==的问题

如果用==直接判断(default(T) == value)，编译时会提示错误：Error CS0019: 运算符“==”无法应用于“T”和“T”类型的操作数 (CS0019)。

2. object.Equals的问题

object提供了一个静态方法，可用于比较两个对象是否相等：

   1: public static bool Equals(object objA, object objB)   2: {   3:     if (objA == objB)   4:     {   5:         return true;   6:     }   7:     if (objA == null || objB == null)   8:     {   9:         return false;  10:     }  11:     return objA.Equals(objB);  12: }

但是该方法接收的是引用类型的实例，如果传入的是值类型(譬如int、enum、struct等)，则会对值类型进行装箱(boxing)。

3. EqualityComparer<T>.Default.Equals

最给力的方法，还是用EqualityComparer<T>.Default.Equals，

   1: public static bool IsDefault<T>(this T value)    2: {   3:      return EqualityComparer<T>.Default.Equals(value, default(T));    4: }

其实现了一个默认的比较器，可以比较Byte、Nullable<T>、Enum、Object、以及实现了IEquatable<T>接口(譬如int、bool、自定义类型等)的所有类型，可以用ILSpy来查看该类型的具体实现：

   1: private static EqualityComparer<T> defaultComparer;   2: public static EqualityComparer<T> Default   3: {   4:     [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries"), SecuritySafeCritical]   5:     get   6:     {   7:         EqualityComparer<T> equalityComparer = EqualityComparer<T>.defaultComparer;   8:         if (equalityComparer == null)   9:         {  10:             equalityComparer = EqualityComparer<T>.CreateComparer();  11:             EqualityComparer<T>.defaultComparer = equalityComparer;  12:         }  13:         return equalityComparer;  14:     }  15: }  16: [SecuritySafeCritical]  17: private static EqualityComparer<T> CreateComparer()  18: {  19:     RuntimeType runtimeType = (RuntimeType)typeof(T);  20:     if (runtimeType == typeof(byte))//其实byte也实现了IEquatable<Byte>，不知道为神马要把byte单独提出来？？？  21:     {  22:         return (EqualityComparer<T>)new ByteEqualityComparer();  23:     }  24:     if (typeof(IEquatable<T>).IsAssignableFrom(runtimeType))//如果类型实现了IEquatable<T>，则在运行时构造GenericEqualityComparer<T>，调用类型自身提供(重写)的equals方法。  25:     {  26:         return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(GenericEqualityComparer<int>), runtimeType);  27:     }  28:     if (runtimeType.IsGenericType && runtimeType.GetGenericTypeDefinition() == typeof(Nullable))  29:     {  30:         RuntimeType runtimeType2 = (RuntimeType)runtimeType.GetGenericArguments()[0];  31:         if (typeof(IEquatable).MakeGenericType(new Type[]  32:         {  33:             runtimeType2  34:         }).IsAssignableFrom(runtimeType2))  35:         {  36:             return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(NullableEqualityComparer<int>), runtimeType2);  37:         }  38:     }  39:     if (runtimeType.IsEnum && Enum.GetUnderlyingType(runtimeType) == typeof(int))  40:     {  41:         return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer<int>), runtimeType);  42:     }  43:     return new ObjectEqualityComparer<T>();  44: }

4. ILSpy比JustDecompile强大呀

4.1. ObjectEqualityComparer<T>.Equals方法的比较

4.2. EqualityComparer<T>.CreateComparer()方法：

各种杯具。。。

标签: default(T),IEquatable<T>,EqualityCompare

本文链接

T-SQL ROUND Function Bug?

2011-06-04T00:04:00Z

先看一个例子：

   1: DECLARE @Value float   2: SET @Value = 12.1785   3: SELECT '12.1785' as ValueToRound, ROUND(@Value,3) as RoundedValue   4: SET @Value = 12.1745   5: SELECT '12.1745' as ValueToRound,ROUND(@Value,3) as RoundedValue 

猜猜看，结果是多少？这个例子源自：T-SQL ROUND Function Bug

1. 问题起因

一个老系统，每个月要对系统发生的每笔业务数据进行汇总，生成应收款；但是每个月累计下来，总会与每天的连续累加汇总差(相差几分钱，或者几毛钱)。

同样的问题还有：仓库里面一批按重量计数的物资，每次出库的时候销账；但偶尔会出现：需要出库的数量，与库存中现有数量一致，但依然无法出库的情况。

问题的根源，就在于数据的存储类型。系统中，选择了使用float来存储数据。但计算机中，是使用近似值来表示float/double的，在这种+/-过程中，误差不断地累积，就出现了上述的这些问题。关于浮点数的存储格式，可以参考我之前的文章：“精确”判断一个浮点数是否等于0

2. Linq to SQL中的Round

知道了问题的原因，我们就可以针对性地进行处理：对数据进行四舍五入后再进行求和。

C#中，提供了两种控制四舍五入的计算方式：MidpointRounding.ToEven和MidpointRounding.AwayFromZero；默认为MidpointRounding.ToEven，即当一个数字是其他两个数字的中间值时，会将其舍入为最接近的偶数。有关舍入方式，可以参考MSDN：“MidpointRounding 枚举”。

值得一提的是，里面对MidpointRounding.AwayFromZero的翻译有误，翻译原文为：“AwayFromZero 当一个数字是其他两个数字的中间值时，会将其舍入为两个值中绝对值较小的值。”但英文原文为：“When a number is halfway between two others, it is rounded toward the nearest number that is away from zero.” 文档描述得相当糟糕，不知道是不是我理解能力太差，反正那一坨东西，绕来绕去，还是看里面举的例子比较靠谱。

   1: // 3.4 = Math.Round( 3.45, 1)   2: //-3.4 = Math.Round(-3.45, 1)   3:     4: // 3.4 = Math.Round( 3.45, 1, MidpointRounding.ToEven)   5: // 3.5 = Math.Round( 3.45, 1, MidpointRounding.AwayFromZero)   6:     7: //-3.4 = Math.Round(-3.45, 1, MidpointRounding.ToEven)   8: //-3.5 = Math.Round(-3.45, 1, MidpointRounding.AwayFromZero)

L2S中，如果直接用Math.Round(T.Amount, 2, MidpointRounding.AwayFromZero)，则解析成T-SQL就是直接调用Round函数；如果用Math.Round(T.Amount, 2, MidpointRounding.ToEven)，则会解析为：

   1: (CASE    2: WHEN ((([t0].[Amount]) * 2) = round(([t0].[Amount]) * 2, 2)) AND (([t0].[Amount]) <> round([t0].[Amount], 2)) THEN round(([t0].[Amount]) / 2, 2) * 2   3: ELSE round([t0].[Amount], 2)   4: END)

3. 解决方法

3.1 两次Round

使用一次Round可以解决小数点取舍问题，但无法处理浮点数精度带来的误差，下面是一次Round带来的结果：

这是因为，譬如浮点数2053.345在计算机内部存储的格式可能为2053.2449999999……，一次Round的结果就直接把后面49999…..的给舍掉了。但我们可以使用两次Round来达到需要的舍入效果：Round(Round(Value, 6), 2)

3.2 Decimal

处理精度问题，将数据类型定义为Decimal才是王道。

Decimal在计算及中的存储格式：Decimal 值长度是128位，由 1 位符号、96 位整数以及比例因子组成，比例因子用作 96 位整数的除数并指定整数的哪一部分为小数。比例因子隐式地定为数字 10 的幂，指数范围从 0 到 28。因此，Decimal 值的二进制表示形式为：((-2^96 到 2^96) / 10^(0 到 28))。比例因子还保留 Decimal 数字中的所有尾数零。

标签: Round,Decimal,Linq to Sql

本文链接

T-SQL 根据年月日创建DateTime

2011-05-28T02:36:00Z

T-SQL中提供了不少操作DateTime的函数，可惜竟然没有根据年月日创建DateTime类型的函数，例如DateTime(yyyy, MM, dd)这样的“构造函数”，杯具啊~~

   1: DECLARE @Year int, @Month int, @Day int;   2: SELECT @Year=2011, @Month=5, @Day=8;   3:     4: --法1：   5: SELECT CAST(CAST(@Year AS varchar(4)) + '-' + CAST(@Month AS nvarchar(2)) + '-' + CAST(@Day AS nvarchar(2)) AS DateTime)   6:     7: --法2：   8: SELECT DateAdd(dd, @Day-1, DateAdd(mm, @Month -1, DateAdd(yy, @Year - 1900, '19000101')))   9:    10: --法3：  11: SELECT DateAdd(mm, (@Year - 1900) * 12 + @Month - 1 , @Day - 1)

标签: DateTime,构造函数

本文链接

使用键值表实现通用流水号

2011-01-29T05:13:00Z

很多MIS系统，都需要用到流水号；一般的简单的流水号，由标识+日期+自增序号来组成；但如果考虑通用的话，就稍微复杂点儿的，需要考虑自定义日期格式、自增序号归1、自增序号溢出处理、前缀/中缀/后缀、并发访问、批量获取等，本文抽象出一个通用的生成流水号的方案。

1. 查询原始数据表 vs. 键值表
2. 键值表、取流水号的T-SQL实现
3. 并发处理需要考虑的三个因素
4. C#封装取流水号操作
5. 不给代码怎马叫给力~

1. 查询原始数据表 vs. 键值表

流水号的变动部分可分为日期和自增序号两部分，日期就是取当前的日期(yyyy、yyMM、或yyyyMMdd等)，自增序号部分可以有如下两种获取方式：

1.1. 每次查询原始数据表：

缺点就是要手工处理并发，如果并发量大的话，性能堪忧；好处就是每次可以取得准确的下一个自增序号，如果最后没有保存或者保存失败，取得的序号可以被重复读得，不会被浪费。

下面是一个并发示例：譬如当前表中最大的序号(这里暂时只考虑自增序号部分，忽略日期)为003，这是A/B两个用户同时打开页面并取得流水号，此时数据都没有保存，因此他们会取得相同的流水号004，保存时就会出现重复键值(违反唯一性约束)了。保险一点的做法，就是在保存的时候，去校验一下流水号是否已经被用过了；但是校验的时候，也必须十分小心，下面是一个保存时的未考虑并发的无效校验：

针对这个问题，一种解决办法就是，将操作串行化，保存前先获得锁：

可以在应用程序中加锁(但如果有集群的话，还要考虑多个服务器的问题)，或者锁数据库表。虽然加锁能解决并发问题，但是却带来更严重的性能问题。每次获取流水号时都要去查询原始数据表(或索引，如果有索引的话)，且插入前要进行加锁，操作只能被串行化，并发量一大，性能是个大问题。

1.2. 使用键值表

另一种思路就是使用键值表。可以为每个需要使用流水号的表，在键值表中保存一条记录，该记录保存其对应表中当前的最大流水号值。这样的操作的好处是：每次取流水号的时候，只需要操作该表中对应的一条记录即可，而不用去查询原始表/索引；还可以用于批量操作，一次获取一批流水号(批量录入或导入的时候，经常会用到)。

键值表还需要处理的一个问题，何时更新键值表中的记录(当前最大值)？有两种处理思路：
(1). 采用写时更新：能避免每次读取时查询原始表的问题，但还是会遇到上面1.1节中的并发问题。
(2). 每次读取最大值的时候更新：先锁记录再读，最后更新为新的最大值。下一个人来读的时候，再取到下一个流水号，这样可以获得最大的并发性，但带来的问题是，如果上一个人取到的业务流水号最后没有保存，则这个流水号就废了(跳过去了)，导致最后的实际的业务流水号不连续。如果业务上允许序号被浪费，建议采用这种方式。

本文的解决方案，也主要是针对后一种(读取时更新)获取流水号的方式。

2. 键值表、取流水号的T-SQL实现

还虑通用型，可以对业务流水号进行抽象：流水号 = 前缀+日期+中缀+流水号+后缀。
    其中：
    前缀/中缀/后缀：可以包含0个或多个字符；
    日期：可以包含yyMM、yyyy、yyMMdd、yyyyMMdd等多种格式；
    流水号：从1开始累加，按日期归1，长度可扩展(考虑到溢出)；
    这些信息都可以放在键值表中统一维护。

继续考虑通用性，可以封装下取流水号的操作，提供一个批量获取方式，一次取一批序号(Max + N)，避免批量操作时循环去取(Max + 1)；批量录入或导入的时候，经常会用到批量获取的方式。

2.1 键值表的设计

   1: /*happyhippy.cnblogs.com*/    2: IF(OBJECT_ID('SequenceNumber') IS NOT NULL)   3:     DROP TABLE SequenceNumber;   4:     5: Create Table SequenceNumber   6: (   7:     ID int identity(1,1),   8:     Code nvarchar(10) primary key,    /*Key*/   9:     Prefix nvarchar(5),   /*前缀*/  10:     DateType nvarchar(8), /*日期类型，可以为yyyy，yymm, yyyymm，yymmdd，yyyymmdd等等等等。*/  11:     Infix nvarchar(5),    /*中缀*/  12:     IndexLength int,      /*自增流水号长度*/  13:     Suffix nvarchar(5),   /*后缀*/  14:     MaxDate nvarchar(8),  /*当前最大日期值*/  15:     MaxIndex int default(0),/*当前最大流水号值*/  16:     CurrentMaxValue AS (Prefix + MaxDate + Infix + Replace(STR(MaxIndex, IndexLength), ' ' , '0') + Suffix)  17: )

注意：
(1). 表的主键设置在Code字段上；
(2). MaxData、MaxIndex等记录当前最大值，用于直接运算。

2.2 T-SQL获取流水号

   1: /*happyhippy.cnblogs.com*/   2: go   3: IF(OBJECT_ID('GetSequenceNumber') IS NOT NULL)   4:     DROP PROCEDURE  GetSequenceNumber;   5:        6: go   7: CREATE PROCEDURE GetSequenceNumber   8: (   9:     @Code nvarchar(10),  10:     @Count int = 1  11: )  12: AS  13: BEGIN  14:     DECLARE @NewValue nvarchar(20), @CurrentDate nvarchar(8);  15:     DECLARE @Prefix nvarchar(5), @DateType nvarchar(8), @Infix nvarchar(5), @Suffix nvarchar(5);  16:     DECLARE @MaxIndex int, @IndexLength tinyint, @MaxDate nvarchar(8);  17:    18:     BEGIN TRAN  19:         --读取配置信息  20:         SELECT  @Prefix = Prefix, @Infix = Infix, @Suffix = Suffix,  21:                 @DateType = DateType, @MaxDate=MaxDate,  22:                 @MaxIndex = MaxIndex, @IndexLength = IndexLength  23:             FROM SequenceNumber with(xlock) WHERE Code=@Code;  24:           25:         --取得日期部分，如果需要其他格式，需要自己再扩展，增加CASE分支。  26:         SET @CurrentDate= SUBSTRING(Convert(nvarchar(8), GetDate(), 112),  27:             CASE SubString(@DateType, 1, 4)  28:                 WHEN 'yyyy' THEN 1  29:                 WHEN 'yyy' THEN 2  30:                 ELSE 3  31:             END, LEN(@DateType));  32:           33:         IF(@CurrentDate = @MaxDate)              34:             SET @MaxIndex = @MaxIndex + @Count; --累加  35:         ELSE  36:             SET @MaxIndex = @Count; --归1  37:           38:           39:         --超过自增长度限制，自动扩展自增部分的长度  40:         IF(@MaxIndex >= POWER(10, @IndexLength))   41:             SET @IndexLength = @IndexLength + 1;   42:           43:         --可以取消下面一行的注释，来测试并发  44:         --Waitfor delay '00:00:10';  45:               46:         Update SequenceNumber SET MaxDate = @CurrentDate, MaxIndex=@MaxIndex, IndexLength=@IndexLength WHERE Code=@Code;  47:     COMMIT TRAN  48:       49:     --取得获取到的最大值，取得@IndexLength和Len(@Suffix)用于解析得到批量获取的序列号  50:     SELECT (@Prefix + @CurrentDate + @Infix + Replace(STR(@MaxIndex, @IndexLength), ' ' , '0') + @Suffix), @IndexLength, Len(@Suffix);  51: END

注意：
    (1). 整个读取、更新过程，封装在一次事务操作中；
    (2) 参数@Count，可以传一个正整数，批量获取多个流水号；
    (3). 第19~22行，读取的时候获取排它锁(xlock)，用于处理并发情况；
    (4). 第39~41行，如果溢出，则自动扩展自增序号的宽度；

3. 并发需要考虑的几个因素

并发要考虑两种情况：
(1) 并发访问同一种类的序列号(键值表中的一个Key)时，必须串行访问，以防止取得相同的流水号；
(2) 并发访问不同种类的序列号(键值表中的不同Key)时，必须允许并发访问，互不干扰才能获得最大的并发度；

3.1 在应用程序中处理锁，还是在数据库中处理锁？

.Net中提供了现成lock、Monitor等，我们可以用来处理锁；譬如可以维护一个字典Dictionary<string, Object>，Key中保存键值表中对应的键值，Value保存同步对象，伪代码如下：

   1: private static object dictionarySyncObj = new object();   2: private static Dictionary<string, object> syncDictionary = new Dictionary<string, object>();   3: public static string GetMaxSequenceNumber(string key)   4: {   5:     lock (dictionarySyncObj)   6:     {   7:         if (!syncDictionary.ContainsKey(key))   8:         {   9:             syncDictionary.Add(key, new object());  10:         }  11:     }  12:     Object keySyncObj = syncDictionary[key];//针对不同的Key，使用不同的同步对象  13:     lock (keySyncObj)  14:     {  15:         //从数据库读取最大流水号....  16:         return ....  17:     }  18: }

程序中所有需要取流水号的地方，都调用该函数来获取，以保证对同一种类序列号的访问被串行化。如果系统只是部署在单台服务器上，这种方法没有问题；但是如果使用了服务器集群，系统在多个系统上部署了多份，则还是无法串行化对同一个Key的所有访问。

比较理想的做法，是在一个统一的地方处理并发，譬如在数据库中。上面第2节中，给出的键值表实现和获取流水号的存储过程，其实已经实现了并发处理，下面展开进行讨论。讨论之前，先执行下列代码来构造几个测试用例：

   1: /*构造测试用例*/   2: INSERT INTO SequenceNumber(Code, Prefix, DateType, Infix, IndexLength, Suffix)   3:     VALUES('Test1', 'P', 'yyyy', '', 8, ''),   4:         ('Test2', '', 'yymmdd', 'M', 6, ''),   5:         ('Test3', 'P', 'yymmdd', 'M', 6, 'S');   6:     7: UPDATE SequenceNumber SET MaxDate= SUBSTRING(Convert(nvarchar(8), GetDate(), 112),   8:             CASE SubString(DateType, 1, 4)   9:                 WHEN 'yyyy' THEN 1  10:                 WHEN 'yyy' THEN 2  11:                 ELSE 3  12:             END, LEN(DateType));

3.2 串行化访问同一种类的序列号

默认情况下(Read Committed事务隔离级别)，读取操作会对对应的数据Key(或行)加S锁(不考虑锁升级的情况)，对该行所属的页和表加IS锁；读取完毕后，就释放这些IS锁和S锁。可以加表提示(with (holdlock))，来让会话强制持有锁，直至事务结束(提交或回滚)后才释放锁。但是，如果多个会话并发访问的时候，由于IS锁与IS锁之间是兼容的，在值被更新(持有更新锁ulock)之前，可以并发读得相同的数据，因此这里读取时，必须要用排它锁(xlock)来独占资源，当一个线程读的时候，不允许其他线程并发读。有关并发和锁兼容性的更多介绍，可以参考我之前的文章《SQL Server死锁总结》。

可以取消2.2节中存储过程GetSequenceNumber中的第44行(Waitfor delay '00:00:10';)的注释，让T-SQL执行时等待10秒钟，以比较测试结果。开两个窗口分别同时执行下列一段测试代码：

   1: exec dbo.GetSequenceNumber 'Test2', 1;

第一个窗口的执行结果：

第二个窗口的执行结果(操作过程中存在延时，所以显示的只有18秒)：

虽然两个会话“同时”执行(第二个会话，我在操作时存在延时，所以显示的只有18秒)，但两个会话没有读得相同的序列号。执行时，第二个会话等待被阻塞等待了；只有等到第一个会话执行完毕后，第二个会话才获得锁资源，并继续执行；因此用了2倍的时间(20秒)。这就达到了多线程访问同一个Key时必须被串行化的效果。

3.3 并发访问不同种类的序列号

多线程并发访问不同种类的序列号(键值表中的不同Key)时，必须允许并发访问，互不干扰才能获得最大的并发度。在2.1节键值表的设计中，我将Code设为主键，这样做的一个好处，就是在读取一条Code记录并获取锁的时候，锁的粒度只会限制在Key锁，而不会升级为页锁或表锁。

现在开两个查询窗口，分别同时执行下列两段代码（注意：这次，两个窗口访问的是不同的Key）：

   1: exec dbo.GetSequenceNumber 'Test2', 1;

   1: exec dbo.GetSequenceNumber 'Test3', 1;

第一个窗口的执行结果：

第二个窗口的执行结果：

虽然两个会话同时执行，但是第二个会话，并没有被第一个会话阻塞，所以第二个会话也只用10秒就执行完毕了。两个会话可以并发执行，这就达到了多线程可以并发访问不同Key的效果。

如果执行上面的查询时，我们sp_lock来查看锁的情况，也可以看到：

参考我之前的文章《SQL Server死锁总结》，并结合上图，可以看到，两个X锁是应用在不同的Resource上，他们之间不会冲突；IX锁虽然应用在同一个Table上/Page(1:828)上，但IX锁与IX锁之间是兼容的，他们之间也不存在冲突；因此多个线程之间不会相互影响。回过头来考虑3.2节中的测试，两个会话尝试对同一个Key加X锁，但X锁与X锁之间是不兼容的，因此读取操作被串行化了。这里利用SQL Server的锁机制来实现并行化/串行化的目的。

抛一个问题，如果键值表的主键，不在Code字段上，还能并发访问不同种类的序列号吗？有兴趣的可以试试。

4. C#封装取流水号操作

   1: public static ReadOnlyCollection<string> GetSequenceNumbers(SequenceType type, int count = 1)   2: {   3:     string maxSequenceNumber = string.Empty;   4:     byte indexLength = 0;   5:     byte suffixLength = 0;   6:     //以上三个值，调用存储过程读取，省略。。。。   7:        8:     if (count == 1)   9:     {  10:         return (new List<string>() { maxSequenceNumber }).AsReadOnly();  11:     }  12:     else  13:     {  14:         string prefix = maxSequenceNumber.Substring(0, maxSequenceNumber.Length - indexLength - suffixLength);  15:         int index = Convert.ToInt32(maxSequenceNumber.Substring(prefix.Length, indexLength));  16:         string suffix = maxSequenceNumber.Substring(maxSequenceNumber.Length - suffixLength);  17:    18:         string format = "0000000000".Substring(0, indexLength);  19:         return Enumerable.Range(index - count + 1, count)  20:                     .Select(i => prefix + i.ToString(format) + suffix)  21:                     .ToList()  22:                     .AsReadOnly();  23:     }  24: }

使用方式：

   1: foreach (string item in SequenceNumber.GetSequenceNumbers(SequenceType.Test3, 3))   2: {   3:    Response.Write(item + "<br/>");   4: }

5. 不给代码怎马叫给力~

happyhippy.cnblogs.com.SequenceNumber.rar

参考文献：
《企业应用架构模式》

本文链接

[SilverLight]DataGrid实现批量输入(like Excel)（补充）

2011-01-12T12:33:00Z

更新内容：

1. Tab/Enter跳转到下一列；
2. 最后一行最后一列，Tab/Enter自动增加新行；
3. 增加新行后，自动跳转到新增行的第一列；
4. 删除行后，自动选中上一行；
5. Up/Down/Left/Right自动编辑；

实现方式：

1. Tab/Enter跳转到下一列

从google搜到的一篇文章《Datagrid cell navigation with enter key》，文中最开始提到在DataGrid的KeyDown事件中进行处理。但是DataGrid里面做了一些封装，我们在自己注册(通过+=操作符来登记、或者XAML中定义)的KeyDown事件中，截获不到Enter/Tab等键。所以最后原作者有提出一个思路：继承DataGrid，重新OnKeyDown方法。

但我之前的思路，是通过扩展方法来扩展DataGrid，再来重写就有点儿郁闷了。于是找出Reflector，翻了下DataGrid的实现(reflector中copy出来的)：

   1: // happyhippy.cnblogs.com   2: // 构造函数   3: public DataGrid()   4: {   5:     //省略   6:     base.KeyDown += new KeyEventHandler(this.DataGrid_KeyDown);   7:     base.KeyUp += new KeyEventHandler(this.DataGrid_KeyUp);   8:     //省略   9: }  10:    11: private void DataGrid_KeyDown(object sender, KeyEventArgs e)  12: {  13:     if (!e.Handled)  14:     {  15:         e.Handled = this.ProcessDataGridKey(e);  16:     }  17: }  18:    19: private bool ProcessDataGridKey(KeyEventArgs e)  20: {  21:     bool flag = false;  22:     switch (e.Key)  23:     {  24:         case Key.Tab:  25:             return this.ProcessTabKey(e);  26:    27:         case Key.Enter:  28:             flag = this.ProcessEnterKey();  29:             break;  30:    31:         case Key.Escape:  32:             return this.ProcessEscapeKey();  33:    34:         case Key.PageUp:  35:             flag = this.ProcessPriorKey();  36:             break;  37:    38:         case Key.PageDown:  39:             flag = this.ProcessNextKey();  40:             break;  41:    42:         case Key.End:  43:             flag = this.ProcessEndKey();  44:             break;  45:    46:         case Key.Home:  47:             flag = this.ProcessHomeKey();  48:             break;  49:    50:         case Key.Left:  51:             flag = (base.FlowDirection == FlowDirection.LeftToRight) ? this.ProcessLeftKey() : this.ProcessRightKey();  52:             break;  53:    54:         case Key.Up:  55:             flag = this.ProcessUpKey();  56:             break;  57:    58:         case Key.Right:  59:             flag = (base.FlowDirection == FlowDirection.LeftToRight) ? this.ProcessRightKey() : this.ProcessLeftKey();  60:             break;  61:    62:         case Key.Down:  63:             flag = this.ProcessDownKey();  64:             break;  65:    66:         case Key.Insert:  67:             return this.ProcessCopyKey();  68:    69:         case Key.A:  70:             return this.ProcessAKey();  71:    72:         case Key.C:  73:             return this.ProcessCopyKey();  74:    75:         case Key.F2:  76:             return this.ProcessF2Key(e);  77:     }  78:     if (flag && base.IsTabStop)  79:     {  80:         base.Focus();  81:     }  82:     return flag;  83: }

我们可以发现，KeyDown中已经定义一部分按键的处理，并更新了KeyEventArgs.Handled属性。MSDN对该属性的解释是：

将事件标记为已处理将会限制路由事件在事件路由过程中对于侦听器的可见性。事件将仍然进行路由过程的其余部分，但只会在响应中调用在 AddHandler(RoutedEvent, Delegate, Boolean) 方法调用中明确添加的其 HandledEventsToo 为 true 的处理程序。将不会调用实例侦听器上的默认处理程序（比如用可扩展应用程序标记语言 (XAML) 表示的那些处理程序）。处理标记为已处理的事件这种情形并不常见。

如果您是定义您自己的事件的控件作者，则您在类级别所做的有关事件处理的决策将影响您的控件的用户，以及派生控件的任何用户，并可能会影响您的控件所包含或包含您的控件的其他元素。有关更多信息，请参见将路由事件标记为“已处理”和“类处理”。

在极少数情况下，适合处理其中 Handled 标记为 true 的事件，并通过将 Handled 更改为 false 来修改事件参数。在控件输入事件的某些区域（比如 KeyDown 与 TextInput 键处理）中，低级别和高级别的输入事件会争用处理，并且每个事件都会尝试使用不同的路由策略，因此，可能必须要这样做。

也就是说，在将KeyEventArgs.Handled，我们通过+=来自己注册的处理程序，就无法执行了。一种替代思路就是在不要用+=来注册处理程序，而是调用AddHandler(RoutedEvent, Delegate, Boolean) 方法来注册处理程序：

   1: //之前的处理方式，将监听不到已经处理过的Tab/Enter等键   2: //dataGrid.KeyDown += KeyDownHandler<T>; //注册按键事件   3: //只能通过下列方式来注册   4: dataGrid.AddHandler(DataGrid.KeyDownEvent, new KeyEventHandler(KeyDownHandler<T>), true);

但在使用的时候发现，如果当前Cell(TextBlock)处于编辑状态，要按两次Tab/Enter才能跳转到下一列：第一次提交更改，第二次才执行跳转操作。

回过头来看，上面的DataGrid的部分源码，跟进去看了下KeyUp事件的处理，发现KeyUp并没有去更改KeyEventArgs.Handled属性。因此，我们可以考虑在DataGrid上注册自定义KeyUp事件，来做一些额外处理：

   1: dataGrid.KeyUp += KeyUpHandler<T>;   2:     3: private static void KeyUpHandler<T>(object sender, KeyEventArgs e) where T : class, new()   4: {   5:       DataGrid dataGrid = sender as DataGrid;   6:       switch (e.Key)   7:       {   8:              case Key.Tab:   9:                     goto case Key.Enter;  10:              case Key.Enter:  11:                     if (dataGrid.CurrentColumn != null)  12:                     {  13:                         if (dataGrid.IsLastRow() & dataGrid.IsLastCell()) // Last Row And Last Cell (End of the grid)  14:                         {  15:                             dataGrid.AddEntity<T>();  16:                         }  17:                         else if (dataGrid.IsLastCell()) // Last Cell  18:                         {  19:                             dataGrid.SelectedIndex = dataGrid.SelectedIndex + 1;  20:                             dataGrid.NextCellToEdit();  21:                         }  22:                         else // Normal navigation  23:                         {  24:                             dataGrid.NextCellToEdit();  25:                         }  26:                     }  27:                     break;  28:              default:  29:                     break;  30: }

2. 最后一行最后一列，Tab/Enter自动增加新行

能捕捉到Tab/Enter后，处理就比较简单了；只需判断时候在最后一行、最后一列，如果是，则调用上一篇文章中的增加新行方法：

   1: if (dataGrid.IsLastRow() & dataGrid.IsLastCell())   2: {   3:     dataGrid.AddEntity<T>();   4: }

3. 增加新行后，自动跳转到新增行的第一列

可以尝试在后台代码中，将DataGrid聚焦在新增行的第一列上：

   1: dataGrid.SelectedItem = entity;   2: dataGrid.CurrentColumn = dataGrid.Columns[0];   3: dataGrid.NextCellToEdit();

但是在实际使用过程中，可能会遇到如下异常：

这是因为，新增加的行，可能(有时能成功，有时可能失败)还没有来得及在UI显示出来，如果在这时设置SelectedItem/CurrentColumn，并调用ScrollIntoView，就会出现上面的异常。一种代替思路，就是用一个计时器来进行处理，如果执行失败，则下次接着执行，直到成功为止：

   1: public static void ScrolToFirstColumn(this DataGrid dataGrid, object entity)   2: {   3:     DispatcherTimer timer = new DispatcherTimer();   4:     timer.Interval = TimeSpan.FromTicks(100);   5:     object sucess = false;   6:     timer.Tick += (o, e) =>   7:     {   8:         if (!(bool)sucess)   9:         {  10:             dataGrid.SelectedItem = entity;  11:             dataGrid.CurrentColumn = dataGrid.Columns[0];  12:             dataGrid.NextCellToEdit();  13:             sucess = true;  14:             timer.Stop(); //执行完毕后，就不再执行。  15:         }  16:     };  17:     timer.Start();  18: }

4. 删除行后，自动选中上一行

默认情况下，行被删除行后，DataGrid没有选中任何行。如果想连续删除、或者用Up/Down/Left/Right跳转的话，就需要每次用鼠标点一下，着实不方便。于是提供了此功能：

   1: public static void DeleteCurrentRow(this DataGrid dataGrid)   2: {   3:     object entity = dataGrid.SelectedItem;   4:     IList dataSource = dataGrid.ItemsSource as IList;   5:     if (entity == null || dataSource == null || dataSource.Count == 0)   6:     {   7:         return;   8:     }   9:    10:     int selectedIndex = dataGrid.SelectedIndex; //删除前，记录当前行的位置  11:     if (ExtenderInfo[dataGrid].Deleteable)  12:     {  13:         dataSource.Remove(entity);  14:         dataGrid.SelectedIndex = selectedIndex - 1;//删除后，重置当前行  15:     }  16:     dataGrid.BeginEdit();  17:     ExtenderInfo[dataGrid].RaiseRowChangedEvent(dataGrid,  18:         new EntityChangedEventArgs() { ChangedEntities = new List<object> { entity }, Type = "Delete" });  19: }

5. Up/Down/Left/Right自动编辑

上一篇文章中，通过在DataGrid的KeyDown事件中，见按键记录到DataGrid.Tag中，然后进入编辑状态时再赋值给单元格中的文本框(TextBox)，来实现即时编辑功能。但在使用的时候，发现如果使用中文输入法、或者列使用的是自定义模板列(不是TextBox)，就会遇到问题：
如果是中文输入法+默认的TextBox：DataGrid会将第一个字符赋给TextBox，这样就多出一个字符，每次得多按一次BackSpace键。
如果是使用自定义模板列，而不是TextBox，就会丢失第一次字符按键。

一种替代的思路，就是在捕捉Up/Down/Left/Right后，让DataGrid立即进入编辑状态。如上面第1点所述，还是要在KeyUp事件中进行处理。

6. 不给代码怎马叫給力

happyhippy.cnblogs.com.BatchInput.rar

本文链接

[SilverLight] DataGrid实现批量输入(like Excel)

2010-12-26T13:40:00Z

DataGrid 控件提供了一种灵活的方式来以行和列的形式显示数据集合。但却没有提供增加、删除行、即时输入等功能，若要实现类似于Winform下的DataGrid批量录入功能，还得做一些手脚：
    1. 显示行号；
    2. 即时输入；
    3. 增加新行；
    4. 删除行；
    5. 复制、粘贴行/多行。

本文针对这几个问题，提出一些解决思路。

1. 显示行号

网上也有一些显示行号的文章，但都是一个处理思路，就是在LoadingRow事件中做手脚，如这篇文章中所提供的思路《[Silverlight]奇技银巧系列-4 在DataGrid中显示行号》：

   1: dataGrid1.LoadingRow += new EventHandler<DataGridRowEventArgs>(dataGrid1_LoadingRow);   2:     3: void dataGrid1_LoadingRow(object sender, DataGridRowEventArgs e) {   4:     int index = e.Row.GetIndex();   5:     var cell = dataGrid1.Columns[0].GetCellContent(e.Row) as TextBlock;   6:     cell.Text = (index + 1).ToString();   7: }

SL帮助文档中对LoadingRow的解释是：“若要改进性能，DataGrid 控件不针对绑定数据源中的每个数据项实例化 DataGridRow 对象。而是仅当需要时才由数据网格创建 DataGridRow 对象，并尽量重复使用这些对象。例如，数据网格为当前位于视图中的每个数据项创建一个 DataGridRow 对象，并在行滚出视图之外时回收它。”

这个处理思路的一个问题，就是当DataGrid的行比较多，超出可视区域(出现滚动条)后；然后再删除前面的行，行号就废了。因为处于可视区域中的现有没有被删除的行，不会执行LoadingRow事件，所以显示的Index不会被更新。

处理思路：

我们一般是将ObservableCollection<Entity>作为DataGrid的数据源。一个变态的处理思路，就是给Entity增加一个Index属性(修改时引发PropertyChanged事件)，然后再DataGrid的LoadingRow/UnloadingRow中，取得DataGrid的数据源ObservableCollection<Entity>，然后更新每个Index的值，囧。。。
不过这样也有一个问题，就是在排序后，Index不会重新计算，显得有点乱。不知道排序会引发啥事件，如果在排序事件中也来更新一次Index，就没有问题了。哪位知道排序会引发啥事件，请告诉我，谢谢。/:)

2. 即时输入

默认情况下，DataGrid的Cell(TextBlock)不是出于编辑状态，要按F2或者鼠标单击，才能进入编辑状态(TextBox)。如果用鼠标点，或者每次都按F2，用起来非常不爽。

处理思路：

参考文章《An attempt to make the Silverlight DataGrid similar to Excel》，里面提出的思路就是在KeyDown\GotFocus\CellEditEnded三个事件中进行处理：
(1) KeyDown事件中，捕捉按键，如果是字符键，则记录到DataGrid.Tag中，然后执行dataGrid.BeginEdit()，强制DataGrid进入编辑状态。
(2) GotFocus事件中，将DataGrid.Tag中记录的字符取出来，然后付给输入框(TextBox);
(3) CellEditEnded事件中，清理DataGrid.Tag。

在该文的回复中，有人提出了一个可替代的事件组合：TextInput/PreparingCellForEdit/KeyDown。也是一个处理思路。

天杀的M$，为啥让DataGrid可编辑，却不能即时输入呢。要用这种变态的方式去处理。。。

3. 增加新行

貌似新版本的SL，可以支持增加新行了。《微软发布Silverlight 4新版并更新Silverlight Tools和SDK》，但问题是，找遍了网络，竟然没有一个例子，M$的论坛上，也是只有提问没有答案。。。所以还是得自己动手。

处理思路：

快捷键：DataGrid的KeyDown事件中，判断按键；
增加新行：增加新行比较简单，上面提到，DataGrid的数据源是ObservableCollection<Entity>，因此，只要我们向该集合中增加一个元素，就能达到增加新行的目的。

4. 删除行

处理思路同增加新行：

快捷键：KeyDown中判断按键；
删除行：取得DataGrid的当前选择行dataGrid.SelectedItem as Entity，然后从将Entity从ObservableCollection<Entity>中删除。

5. 复制/粘行

处理思路1：
《An attempt to make the Silverlight DataGrid similar to Excel》一文中，也提供了一个复制/粘贴的思路：

主要分三个步骤：
(1). 获取DataGrid选择行，然后将每个cell（TextBlock）的中的文本数据，用“\t”分割，得到文本值；(如果Cell不在可视区域内，则调用dataGrid.ScrollIntoView，让Cell显示出来，然后才能取到TextBlock/TextBox)
(2). 将数据保存到系统的粘贴板:

   1: var clipboardData = (ScriptObject)HtmlPage.Window.GetProperty("clipboardData");   2: clipboardData.Invoke("setData", "text", "格式化的自定义格式的数据");

(3). 从粘贴板上将数据取回来，再赋值给目标行中的Cell(TextBox):

   1: var clipboardData = (ScriptObject)HtmlPage.Window.GetProperty("clipboardData");   2: string textData = clipboardData.Invoke("getData", "text").ToString();

但该文章中，只提供了单行复制/粘贴的功能；而且这段代码有很大局限性，只能在IE中运行。

处理思路2：
上面的复制/粘贴功能，只局限在IE中运行。另一个处理思路，可以做两点改进：

(1) 上面提到，DataGrid的数据源是ObservableCollection<T>，只要改变该集合中的值，SL就会自动刷新DataGrid。因此我们可以不用去操作DataGrid中的Cell，而是直接操作ObservableCollection<T>。拷贝的时候，对选中的一个或多个元素(Entity)执行xml序列化得到文本值；粘贴的时候，将文本值反序列化回来，然后对掉选中的元素(Entity)逐个属性赋值。

从ObservableCollection<T>得到文本值由两个处理思路：可以按上面描述的序列化来处理；也可以按处理思路1种的文本拼接思路，按照csv格式来进行拼接：属性值之间以“\t”分隔，元素(Entity)之间以“\r\n”分隔。

按csv格式拼接的好处，就是拷贝的数据，可以直接粘贴到Excel中。而序列化的好处，就是可以保证兼容性；譬如批量录入过程耗时可能比较长，中途可能需要跳转到其他页面、或者离开很久、或者下班关机，那前面录入的相当于白干了；因此需要在客户端提供了一个临时保存的功能：把当前数据保存到文件(SL4支持将数据保存独立存储区中)，下次再从文件中把数据加载出来；但如果中途系统升级了，增加或者减少了一个字段/列，则序列化可以忽略增加/减少的列，继续正常工作。但CSV格式拼接出来的文本，缺少列描述信息，就挂了。。。

(2) 用一个TextBox做中转。将文本值赋值给中转的TextBox，然后对TextBox按Ctrl+C，从而将数据拷贝到系统的粘贴板；粘贴的过程正好反过来，先将系统粘贴板的数据，粘贴到中转用的TextBox，然后再取得TextBox中的值。

整个处理过程如下图所示：

在复制/粘贴的过程中，可能还会遇到一种情况，即选择了DataGrid中的N行，然后复制；但粘贴的时候，可能会选择M行，有三种情况需要考虑：
(1) M=N：这种情况下，正好元素可以一一匹配上；逐个元素按属性赋值就行；
(2) M>N：虽然粘贴时，选择的行数更多，但我们可以忽略多出的行(M-N)，只处理前面的N行；
(3) M<N：此时，需要考虑多出的复制行(N-M)要怎么处理了；有三种处理办法：(1) 忽略多出的复制行；(2) 按照Excel的处理思路，只允许粘贴到连续的N行中；(3) 我的处理思路是，可以跨行粘贴，对于多出的行，可以插入到ObservableCollection<T>中。

6. 类图结构

7. 使用方法

   1: dataGrid.UseExtender<Employee>();

这是最简单的情况，只提供基本的即时输入、增加、删除、复制、粘贴功能等；一个稍微复杂点的调用方式如下：

   1: //happyhippy.cnblogs.com   2: //方法定义原型   3: public static void UseExtender<T>(this DataGrid dataGrid, string autoIncreaseField = "",   4:     bool useXmlCopy = true, Action<DataGrid, EntityChangedEventArgs> rowsChanged = null,   5:     bool addable = true, bool deleteable = true)   6:     where T : class, new()   7:     8: //调用：   9: dataGrid.UseExtender<Employee>("Index", true,   10:                 (s, eventArg) =>  11:                 {  12:                     //取得刚操作(插入/删除)的元素集合，可以干一些后续的事情。。。  13:                     IList<Employee> changedEntities = eventArg.ChangedEntities as IList<Employee>;  14:                 }, true, true);

运行效果：

8. 上代码

DataGridLikeExcel.rar

本文链接

SpeechSynthesizer/WaveHeader 存在严重的内存泄漏

2010-11-07T12:52:00Z

.Net Framework 3.0带了个System.Speech.dll，装个语音包，然后就可以实现文字朗读等功能。最近在使用的时候，发现随着程序的运行，程序占用的内存一直在增长，直到程序崩溃。

用WinDbg抓了个Dump，然后看了下，里面一堆没有释放的SPVTEXTFRAG、AudioDeviceOut+InItem、WAVEHDR、WaveHeader对象，于是写了一小段来测试：

   1: //happyhippy.cnblogs.com   2: using System.Speech.Synthesis;   3: using (SpeechSynthesizer ss = new SpeechSynthesizer())   4: {   5:     for (int i = 0; i < int.MaxValue; i++)   6:     {   7:         ss.Speak(i.ToString());   8:     }   9: }

跑了几个小时，然后抓了个内存，开始干活：

1. 看下内存中有哪些对象

   1: 0:000> .load clr20/sos.dll   2: 0:000> !dumpheap -stat   3: PDB symbol for mscorwks.dll not loaded   4: total 275193 objects   5: Statistics:   6:       MT    Count    TotalSize Class Name   7: 70441ff8        1           12 System.RuntimeTypeHandle   8: 7043fc7c        1           12 System.__Filters   9: //。。。。。。。。。。。。中间省略了一堆。。。。。。。。。。。  10: 704431a8       18         1008 System.Collections.Hashtable  11: 7042c938       65         1560 System.Security.Policy.StrongNameMembershipCondition  12: 70441cd4       81         1620 System.RuntimeType  13: 70441784       16         1820 System.Char[]  14: 7042c6e4      232         6496 System.Security.SecurityElement  15: 70442b84      278         6672 System.Collections.ArrayList  16: 704435c4       17        75056 System.Byte[]  17: 5610529c     4297        85940 System.Speech.Internal.AlphabetConverter+PhoneMapData+ConversionUnit  18: 704432a4       18       181896 System.Collections.Hashtable+bucket[]  19: 70414324      376       319064 System.Object[]  20: 70440b54    13185       396696 System.String  21: 5610ab38     7538       693496 System.Speech.Synthesis.TtsEngine.SPVTEXTFRAG  22: 56105c50    63264      1012224 System.Speech.Internal.Synthesis.AudioDeviceOut+InItem  23: 560f2694    65652      2626080 System.Speech.Internal.Synthesis.WAVEHDR  24: 56105b6c    63264      3289728 System.Speech.Internal.Synthesis.WaveHeader  25: 002be948    56465    172964660      Free  26: Total 275193 objects  27: Fragmented blocks larger than 0.5 MB:  28:     Addr     Size      Followed by  29: 1228c6d8    0.5MB         12311d7c System.Speech.Synthesis.TtsEngine.SPVTEXTFRAG  30: 123293e0    0.6MB         123baa64 System.Speech.Synthesis.TtsEngine.SPVTEXTFRAG  31: 124be36c    1.9MB         1269d898 System.Speech.Synthesis.TtsEngine.SPVTEXTFRAG  32: 126a39f0    1.3MB         127e6644 System.Speech.Synthesis.TtsEngine.SPVTEXTFRAG

列表中的第25行，172M的Free状态的内存。

最后4行(29~32)的内存碎片，用DumpObj看了下，都是Free状态。

2. 看看终结队列中有哪些对象

   1: 0:000> !FinalizeQueue -detail   2: SyncBlocks to be cleaned up: 0   3: MTA Interfaces to be released: 0   4: STA Interfaces to be released: 0   5: ----------------------------------   6: generation 0 has 2973 finalizable objects (068fdec4->06900d38)   7: generation 1 has 11 finalizable objects (068fde98->068fdec4)   8: generation 2 has 60304 finalizable objects (068c3058->068fde98)   9: Ready for finalization 0 objects (06900d38->06900d38)  10: Statistics:  11:       MT    Count    TotalSize Class Name  12: 7043a304        1           16 System.WeakReference  13: 7002d1c8        1           20 System.ComponentModel.AsyncOperation  14: 5610a9c0        1           20 System.Speech.Synthesis.SpeechSynthesizer  15: 5610576c        1           20 System.Speech.Internal.ObjectTokens.RegistryDataKey  16: 5610581c        1           24 System.Speech.Internal.ObjectTokens.ObjectToken  17: 56105ae8        1           56 System.Speech.Internal.Synthesis.AudioDeviceOut  18: 70427b90        4           80 Microsoft.Win32.SafeHandles.SafeWaitHandle  19: 561092e0        1          176 System.Speech.Internal.Synthesis.VoiceSynthesis  20: 7043b370        9          180 Microsoft.Win32.SafeHandles.SafeRegistryHandle  21: 70441128        4          224 System.Threading.Thread  22: 56105b6c    63264      3289728 System.Speech.Internal.Synthesis.WaveHeader  23: Total 63288 objects

我靠，内存中3289728个WaveHeader全部挂在终结队列中。一个可能的原因就是：WaveHeader对象中实现了析构函数，并且程序使用完WaveHeader对象后，没有手动释放(Dispose)，而是等着GC来自动回收。

3. 用Reflector看WaveHeader的源代码

   1: internal sealed class WaveHeader : IDisposable   2: {   3:     // Fields   4:     internal int _dwBufferLength;   5:     private GCHandle _gcHandle = new GCHandle();   6:     private GCHandle _gcHandleWaveHdr = new GCHandle();   7:     private WAVEHDR _waveHdr = new WAVEHDR();   8:     internal const int WAVE_FORMAT_PCM = 1;   9:     internal const int WHDR_BEGINLOOP = 4;  10:     internal const int WHDR_DONE = 1;  11:     internal const int WHDR_ENDLOOP = 8;  12:     internal const int WHDR_INQUEUE = 0x10;  13:     internal const int WHDR_PREPARED = 2;  14:    15:     // Methods  16:     internal WaveHeader(byte[] buffer)  17:     {  18:         this._dwBufferLength = buffer.Length;  19:         this._gcHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned);//申请内存  20:     }  21:    22:     public void Dispose()  23:     {  24:         this.Dispose(true);  25:         GC.SuppressFinalize(this);  26:     }  27:    28:     private void Dispose(bool disposing)  29:     {  30:         if (disposing)  31:         {  32:             this.ReleaseData();  33:             if (this._gcHandleWaveHdr.IsAllocated)  34:             {  35:                 this._gcHandleWaveHdr.Free();  36:             }  37:         }  38:     }  39:    40:     ~WaveHeader()  41:     {  42:         this.Dispose(false);  43:     }  44:    45:     internal void ReleaseData()  46:     {  47:         if (this._gcHandle.IsAllocated)  48:         {  49:             this._gcHandle.Free();  50:         }  51:     }  52:    53:     // Properties  54:     internal int SizeHDR  55:     {  56:         get  57:         {  58:             return Marshal.SizeOf(this._waveHdr);  59:         }  60:     }  61:    62:     internal GCHandle WAVEHDR  63:     {  64:         get  65:         {  66:             if (!this._gcHandleWaveHdr.IsAllocated)  67:             {  68:                 this._waveHdr.lpData = this._gcHandle.AddrOfPinnedObject();  69:                 this._waveHdr.dwBufferLength = (uint) this._dwBufferLength;  70:                 this._waveHdr.dwBytesRecorded = 0;  71:                 this._waveHdr.dwUser = 0;  72:                 this._waveHdr.dwFlags = 0;  73:                 this._waveHdr.dwLoops = 0;  74:                 this._waveHdr.lpNext = IntPtr.Zero;  75:                 this._gcHandleWaveHdr = GCHandle.Alloc(this._waveHdr, GCHandleType.Pinned);//申请内存  76:             }  77:             return this._gcHandleWaveHdr;  78:         }  79:     }  80: }

如我们所料，的确定义了一个析构函数（~WaveHeader()），WaveHealder实现了Dispose模式。

4. 进一步分析，看看WaveHeader都申请了啥资源，为啥要实现Dispose模式

WaveHeader的构造函数中，申请了一片Pinned状态的内存this._gcHandle = GCHandle.Alloc(buffer, GCHandleType.Pinned)，并且其WAVEHDR属性的实现中，也通过延迟加载的方式申请了一片Pinned状态的内存this._gcHandleWaveHdr = GCHandle.Alloc(this._waveHdr, GCHandleType.Pinned)。

MSDN对GCHander的阐述如下：(FROM MSDN)

GCHandle 类与 GCHandleType 枚举结合使用以创建对应于任何托管对象的句柄。此句柄可为以下四种类型之一：Weak、WeakTrackResurrection、Normal 或 Pinned。分配了句柄以后，在非托管客户端保留唯一的引用时，可以使用它防止垃圾回收器回收托管对象。如果没有这样的句柄，则在该对象代表非托管客户端完成工作以前，有可能被垃圾回收器回收。 

用 GCHandle 创建一个固定对象，该对象返回��个内存地址，并防止垃圾回收器在内存中移动该对象。 

超出范围时，您必须通过调用Free方法显式释放它；否则，可能会发生内存泄漏。当您释放固定的句柄时，如果没有对关联对象的其他引用，则关联对象将解除固定，并可以被当成垃圾回收。

也就是说，通过GCHandler.Alloc申请的内存，必须通过调用GCHandler.Free方法来手动释放。表面上看来，WaveHeader的实现中，的确有手动释放这些申请的内存。

5. WaveHeader在哪儿使用

SpeechSynthesizer封装了一对东西，有点儿绕，我顺着Speak方法找了N久，没有找到使用WaveHeader的地方。

只好换另一个思路：在上面的第1步中，我们可以看到，WaveHeader的MT Address为56105b6c，于是：

0:000> !dumpheap -MT 56105b6c//。。。省却6万多行。。。  127fabdc 56105b6c       52     12800a64 56105b6c       52     //找到一个还活着的对象total 63264 objectsStatistics:MT    Count    TotalSize Class Name56105b6c    63264      3289728 System.Speech.Internal.Synthesis.WaveHeaderTotal 63264 objects

然后找到一个还活着的对象(地址为12800a64)，看看它被谁引用了：

0:000> !gcroot 12800a64Note: Roots found on stacks may be false positives. Run "!help gcroot" formore info.Scan Thread 0 OSTHread 3668ESP:1df238:Root:01f67e1c(System.Speech.Internal.Synthesis.VoiceSynthesis)->01f6841c(System.Speech.Internal.Synthesis.AudioDeviceOut)->01f68570(System.Collections.Generic.List`1[[System.Speech.Internal.Synthesis.AudioDeviceOut+InItem, System.Speech]])->02f91c10(System.Object[])->020e4088(System.Speech.Internal.Synthesis.AudioDeviceOut+InItem)->12800a64(System.Speech.Internal.Synthesis.WaveHeader)Scan Thread 2 OSTHread 2c5cScan Thread 3 OSTHread 1160Scan Thread 4 OSTHread 211cScan Thread 6 OSTHread 22d4Scan Thread 7 OSTHread 2fccScan Thread 8 OSTHread 377c

这里，我们终于可以看到路径了：

SpeechSynthesizer
->VoiceSynthesis
->AudioDeviceOut
-> List<AudioDeviceOut + InItem>
-> AudioDeviceOut + InItem（内部类）
-> WaveHeader
终于找到目标了：AudioDeviceOut。

6. 怎么使用WaveHeader

AudioDeviceOut的代码页有点长，这里只截出部分使用WaveHeader的代码：

   1: internal override void Play(byte[] buffer)   2: {   3:     if (this._deviceOpen)   4:     {   5:         int length = buffer.Length;   6:         this._bytesWritten += length;   7:         WaveHeader waveHeader = new WaveHeader(buffer);//上面第3节提到，这里通过GCHandler.Alloc申请了内存   8:         GCHandle wAVEHDR = waveHeader.WAVEHDR;//上面第3节提到，这里通过GCHandler.Alloc申请了内存   9:         MMSYSERR errorCode = SafeNativeMethods.waveOutPrepareHeader(this._hwo, wAVEHDR.AddrOfPinnedObject(), waveHeader.SizeHDR);  10:         if (errorCode != MMSYSERR.NOERROR)  11:         {  12:             throw new AudioException(errorCode);  13:         }  14:         lock (this._noWriteOutLock)  15:         {  16:             if (!base._aborted)  17:             {  18:                 lock (this._queueIn)  19:                 {  20:                     InItem item = new InItem(waveHeader);//InItem封装了一下WaveHeader，也没啥  21:                     this._queueIn.Add(item); //将Item加入到List中  22:                     this._evt.Reset();  23:                 }  24:                 errorCode = SafeNativeMethods.waveOutWrite(this._hwo, wAVEHDR.AddrOfPinnedObject(), waveHeader.SizeHDR);//P/Invoke向设备输出数据  25:                 if (errorCode != MMSYSERR.NOERROR)  26:                 {  27:                     lock (this._queueIn)  28:                     {  29:                         this._queueIn.RemoveAt(this._queueIn.Count - 1);//如果出错了，从List删除一个Item  30:                         throw new AudioException(errorCode);  31:                     }  32:                 }  33:             }  34:         }  35:     }  36: }

在这里，Play方法了面，终于实例化了WaveHeader和WaveHDR(GCHandler)；但是实例化的WaveHeader又被InItem封装了一下，加入到List<InItem> _queueIn中。
Play方法里面创建了WaveHeader，但是却没有看到释放WaveHeader的代码。

那我们再来看下，其他地方有没有释放WaveHeader的代码：既然InItem/WaveHeader被加入到_queueIn中了，程序应该还要使用WaveHeader；那么当InItem从该_queueIn中移出的时候，应该就会释放WaveHeader了吧。顺着这个思路继续往下看。。。

很不幸，就在Play方法里面：当判断播放出错的时候，会把InItem从_queueIn中移出(上面第29行)，但是却没有释放InItem/WaveHeader。

另一个将InItem从_queueIn中移出的地方是CallBackProc，AudioDeviceOut在构造函数中初始化了一个委托：this._delegate = new SafeNativeMethods.WaveOutProc(this.CallBackProc); 从字面上理解，应该是输出声音完毕后，调用这个回调函数，来释放内存：

   1: private void CallBackProc(IntPtr hwo, MM_MSG uMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2)   2: {   3:     if (uMsg == MM_MSG.MM_WOM_DONE)   4:     {   5:         lock (this._queueIn)   6:         {   7:             InItem item = this._queueIn[0];   8:             item.ReleaseData();//释放InItem/WaveHeader   9:             this._queueIn.RemoveAt(0); //移除InItem  10:             this._queueOut.Add(item);  11:             while (this._queueIn.Count > 0)  12:             {  13:                 item = this._queueIn[0];  14:                 if (item._waveHeader != null)  15:                 {  16:                     break;  17:                 }  18:                 if ((this._asyncDispatch != null) && !base._aborted)  19:                 {  20:                     this._asyncDispatch.Post(item._userData);  21:                 }  22:                 this._queueIn.RemoveAt(0);//移除InItem，但是却没有释放InItem/WaveHeader  23:             }  24:         }  25:         if (this._queueIn.Count == 0)  26:         {  27:             this._evt.Set();  28:         }  29:     }  30: }

代码中，可以看到，当uMsg == MM_MSG.MM_WOM_DONE，才会执行释放操作。MM_MSG枚举有三个可选值：MM_WOM_CLOSE = 0x3bc, MM_WOM_DONE = 0x3bd, MM_WOM_OPEN = 0x3bb，暂时不太清楚是回调函数的uMsg参数否可能会传入其他值；如果传入了其他值，显然InItem/WaveHeader有没有被释放。

即使uMsg == MM_MSG.MM_WOM_DONE，我们来看下释放的代码，上面第8~9行，从_queueIn中移除InItem/WaveHeader的时候，的确执行了ReleaseData()来释放内存，但是看该方法的源代码：

   1: //happyhippy.cnblogs.com   2: //InItem   3: internal void ReleaseData()   4: {   5:     if (this._waveHeader != null)   6:     {   7:         this._waveHeader.ReleaseData();   8:     }   9: }  10: //WaveHeader  11: internal void ReleaseData()  12: {  13:     if (this._gcHandle.IsAllocated)  14:     {  15:         this._gcHandle.Free();  16:     }  17: }  18:  

里面调用WaveHeader.ReleaseData()来释放内存，不是调用Dispose来释放内存。上面提到，Play方法中，第8行GCHandle wAVEHDR = waveHeader.WAVEHDR申请了内存，但是ReleaseData()方法并没有释放该内存。应该调用Dispose来释放内存，而不是调用ReleaseData()。

然后在回过头来看CallBackProc方法，从源代码中可以看到，其只释放了_queueIn中第一个InItem/WaveHeader，后续的InItem/WaveHeader从_queueIn中移除的时候，并没有释放内存。

GCHandler.Alloc申请的内存，必须通过调用Free方法显式释放它；否则，可能会发生内存泄漏。

7. 解决办法

无解。

那封装的一大坨，都是Internal。

本文链接