C#串口通信编程类（修改版）

这是从网上down下来的一个串口通信类，发现close函数忘记了设置Opened属性为false
还有后面string转byte[]和byte[]转string的函数有错误，索性删掉了
修改后的串口通信类如下：
下一篇将把我的测试程序主程序部分全部代码贴出来
可以坚强勇敢的用来实现串口通信。using System;
using System.Runtime.InteropServices;namespace BusApp
{
/// <summary>
///
/// </summary>
public class mycom
{
public mycom（）
{
   //
   // TODO: 在此处添加构造函数逻辑
   //
}
public int PortNum; //1,2,3,4
public int BaudRate; //1200,2400,4800,9600
public byte ByteSize; //8 bits
public byte Parity; // 0-4=no,odd,even,mark,space
public byte StopBits; // 0,1,2 = 1, 1.5, 2
public int ReadTimeout; //10

//comm port win32 file handle
private int hComm = -1;

public bool Opened = false;

//win32 api constants
private const uint GENERIC_READ = 0x80000000;
private const uint GENERIC_WRITE = 0x40000000;
private const int OPEN_EXISTING = 3;
private const int INVALID_HANDLE_VALUE = -1;

[StructLayout（LayoutKind.Sequential）]
   private struct DCB
{
   //taken from c struct in platform sdk
   public int DCBlength;           // sizeof（DCB）
   public int BaudRate;            // current baud rate
   public int fBinary;          // binary mode, no EOF check
   public int fParity;          // enable parity checking
   public int fOutxCtsFlow;      // CTS output flow control
   public int fOutxDsrFlow;      // DSR output flow control
   public int fDtrControl;       // DTR flow control type
   public int fDsrSensitivity;   // DSR sensitivity
   public int fTXContinueOnXoff; // XOFF continues Tx
   public int fOutX;          // XON/XOFF out flow control
   public int fInX;           // XON/XOFF in flow control
   public int fErrorChar;     // enable error replacement
   public int fNull;          // enable null stripping
   public int fRtsControl;     // RTS flow control
   public int fAbortOnError;   // abort on error
   public int fDummy2;        // reserved
   public ushort wReserved;          // not currently used
   public ushort XonLim;             // transmit XON threshold
   public ushort XoffLim;            // transmit XOFF threshold
   public byte ByteSize;           // number of bits/byte, 4-8
   public byte Parity;             // 0-4=no,odd,even,mark,space
   public byte StopBits;           // 0,1,2 = 1, 1.5, 2
   public char XonChar;            // Tx and Rx XON character
   public char XoffChar;           // Tx and Rx XOFF character
   public char ErrorChar;          // error replacement character
   public char EofChar;            // end of input character
   public char EvtChar;            // received event character
   public ushort wReserved1;         // reserved; do not use
} [StructLayout（LayoutKind.Sequential）]
   private struct COMMTIMEOUTS
{
   public int ReadIntervalTimeout;
   public int ReadTotalTimeoutMultiplier;
   public int ReadTotalTimeoutConstant;
   public int WriteTotalTimeoutMultiplier;
   public int WriteTotalTimeoutConstant;
} [StructLayout（LayoutKind.Sequential）]
   private struct OVERLAPPED
{
   public int Internal;
   public int InternalHigh;
   public int Offset;
   public int OffsetHigh;
   public int hEvent;
}

[DllImport（"kernel32.dll"）]
private static extern int CreateFile（
   string lpFileName,                         // file name
   uint dwDesiredAccess,                      // access mode
   int dwShareMode,                          // share mode
   int lpSecurityAttributes, // SD
   int dwCreationDisposition,                // how to create
   int dwFlagsAndAttributes,                 // file attributes
   int hTemplateFile                        // handle to template file
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool GetCommState（
   int hFile, // handle to communications device
   ref DCB lpDCB    // device-control block
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool BuildCommDCB（
   string lpDef, // device-control string
   ref DCB lpDCB     // device-control block
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool SetCommState（
   int hFile, // handle to communications device
   ref DCB lpDCB    // device-control block
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool GetCommTimeouts（
   int hFile,                  // handle to comm device
   ref COMMTIMEOUTS lpCommTimeouts // time-out values
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool SetCommTimeouts（
   int hFile,                  // handle to comm device
   ref COMMTIMEOUTS lpCommTimeouts // time-out values
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool ReadFile（
   int hFile,                // handle to file
   byte[] lpBuffer,             // data buffer
   int nNumberOfBytesToRead, // number of bytes to read
   ref int lpNumberOfBytesRead, // number of bytes read
   ref OVERLAPPED lpOverlapped    // overlapped buffer
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool WriteFile（
   int hFile,                    // handle to file
   byte[] lpBuffer,                // data buffer
   int nNumberOfBytesToWrite,     // number of bytes to write
   ref int lpNumberOfBytesWritten, // number of bytes written
   ref OVERLAPPED lpOverlapped        // overlapped buffer
   ）;
[DllImport（"kernel32.dll"）]
private static extern bool CloseHandle（
   int hObject   // handle to object
   ）;

public void Open（）
{

   DCB dcbCommPort = new DCB（）;
   COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS（）;


   // OPEN THE COMM PORT.
   hComm = CreateFile（"COM" + PortNum ,GENERIC_READ | GENERIC_WRITE,0, 0,OPEN_EXISTING,0,0）;

   // IF THE PORT CANNOT BE OPENED, BAIL OUT.
   if（hComm == INVALID_HANDLE_VALUE）
   {
    throw（new ApplicationException（"Comm Port Can Not Be Opened"））;
   }

   // SET THE COMM TIMEOUTS.

   GetCommTimeouts（hComm,ref ctoCommPort）;
   ctoCommPort.ReadTotalTimeoutConstant = ReadTimeout;
   ctoCommPort.ReadTotalTimeoutMultiplier = 0;
   ctoCommPort.WriteTotalTimeoutMultiplier = 0;
   ctoCommPort.WriteTotalTimeoutConstant = 0;
   SetCommTimeouts（hComm,ref ctoCommPort）;

   // SET BAUD RATE, PARITY, WORD SIZE, AND STOP BITS.
   // THERE ARE OTHER WAYS OF DOING SETTING THESE BUT THIS IS THE EASIEST.
   // IF YOU WANT TO LATER ADD CODE FOR OTHER BAUD RATES, REMEMBER
   // THAT THE ARGUMENT FOR BuildCommDCB MUST BE A POINTER TO A STRING.
   // ALSO NOTE THAT BuildCommDCB（） DEFAULTS TO NO HANDSHAKING.

   dcbCommPort.DCBlength = Marshal.SizeOf（dcbCommPort）;
   GetCommState（hComm, ref dcbCommPort）;
   dcbCommPort.BaudRate=BaudRate;
   dcbCommPort.Parity=Parity;
   dcbCommPort.ByteSize=ByteSize;
   dcbCommPort.StopBits=StopBits;
   SetCommState（hComm, ref dcbCommPort）;

   Opened = true;

}

public void Close（）
{
   if （hComm！=INVALID_HANDLE_VALUE）
   {
    CloseHandle（hComm）;
                Opened=false;
   }
}

public byte[] Read（int NumBytes）
{
   byte[] BufBytes;
   byte[] OutBytes;
   BufBytes = new byte[NumBytes];
   if （hComm！=INVALID_HANDLE_VALUE）
   {
    OVERLAPPED ovlCommPort = new OVERLAPPED（）;
    int BytesRead=0;
    ReadFile（hComm,BufBytes,NumBytes,ref BytesRead,ref ovlCommPort）;
    OutBytes = new byte[BytesRead];
    Array.Copy（BufBytes,OutBytes,BytesRead）;
   }
   else
   {
    throw（new ApplicationException（"Comm Port Not Open"））;
   }
   return OutBytes;
}

public int Write（byte[] WriteBytes）
{
   int BytesWritten = 0;
   if （hComm！=INVALID_HANDLE_VALUE）
   {
    OVERLAPPED ovlCommPort = new OVERLAPPED（）;
    WriteFile（hComm,WriteBytes,WriteBytes.Length,ref BytesWritten,ref ovlCommPort）;
   }
   else
   {
    throw（new ApplicationException（"Comm Port Not Open"））;
   }
   return BytesWritten;
}
}
}