关于UDP网络通信，客户端使用C开发，服务器端用C#

Question

客户端用c开发的，向服务器端发送如下结构：
public struct Struct1
    {
        BYTE byStr1_1;
        BYTE byStr1_2;
        BYTE byStr1_3;
        unsigned short usStruct1_1;
        unsigned short usStruct1_2;
    }
    public struct DataHead
    {
        public unsigned short us1;
        public unsigned short us2;
        Struct1 eidSrc;
        public BYTE byDH1;
        public BYTE byDH2;
        
        public DWORD dwNo;             //DWORD dwNo;
        public WORD wFlag;          //WORD wFlag;
        
    }
    public unsafe struct StatusData
    {
        public DataHead fhFrmHead;
        public long frameCounter;
        public long lSec;
        public long lMicroSec;
        public double dblong;
        public double dbLati;
        public float fHeight;
        
        public BYTE byItemStatus;
        public BYTE byRBFlag;
        
        public char ttt[2];    }
服务器端用C# 如何接收并解析？

Answer 1

使用 (char *)把你的结构转换为字符串内容。 我通常的作法是所有结构内全部是char 型数组，即便 是计数的， 都是通过转换，全部使用char[] 数组。 
当你使用 char * 来把一个结构取为字符串后， 你可以发送给服务器。 
c#解析的代码如下所示:
//By GER.Cmd.buildcs   CreateDate:2008-4-15 20:26:28
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Text;
using System.Runtime.InteropServices;
using Grove.ORM;
namespace TCS.Model
{
    /// <summary>
    ///表名称ExitBS,字段数目19
    /// </summary>
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct MSG_EXITBS
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =18)]
        public byte[] ID;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] MsgType;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] LaneType;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] LaneMode;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =2)]
        public byte[] Network;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =2)]
        public byte[] Plaza;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =4)]
        public byte[] Year;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =4)]
        public byte[] Day;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =6)]
        public byte[] Hour;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =8)]
        public byte[] YMD;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =14)]
        public byte[] YMDHM;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =3)]
        public byte[] LaneNo;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =6)]
        public byte[] Collector;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] collectortype;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] WorkStatus;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =4)]
        public byte[] ICBox;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =10)]
        public byte[] TotalTraffic;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =8)]
        public byte[] BeginSTicketNo;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] MARK;
    }//ExitBS
    [DataTable("ExitBS")]
    public class ExitBS
    {
        MSG_EXITBS  _MSG_EXITBS;
        public ExitBS(MSG_EXITBS ___MSG_EXITBS)
        {
            _MSG_EXITBS = ___MSG_EXITBS;
        }
        public ExitBS()
        {
            Parse("".PadRight(GetLenght(), ' '));
        }
        public ExitBS(string s)
        {
            Parse(s);
        }
        public int GetLenght()
        {
            return Marshal.SizeOf(_MSG_EXITBS);
        }
          //由一个string隐式构造一个ExitBS 
          public static implicit operator ExitBS(string  s)
         {
             return new ExitBS(s);
          }
           //由一个ExitBS显式返回一个string
           public static explicit operator string (ExitBS ret)
           {
               return  ret.ToString() ;
           }
        [DataField("ID")]
        public string  ID
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.ID);
            }
            set {
                _MSG_EXITBS.ID= Encoding.GetEncoding(936).GetBytes(value.PadRight(18,' '));
            }
        }
        [DataField("MsgType")]
        public string  MsgType
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.MsgType);
            }
            set {
                _MSG_EXITBS.MsgType= Encoding.GetEncoding(936).GetBytes(value.PadRight(1,' '));
            }
        }
        [DataField("LaneType")]
        public string  LaneType
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.LaneType);
            }
            set {
                _MSG_EXITBS.LaneType= Encoding.GetEncoding(936).GetBytes(value.PadRight(1,' '));
            }
        }
        [DataField("LaneMode")]
        public string  LaneMode
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.LaneMode);
            }
            set {
                _MSG_EXITBS.LaneMode= Encoding.GetEncoding(936).GetBytes(value.PadRight(1,' '));
            }
        }
        [DataField("Network")]
        public string  Network
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.Network);
            }
            set {
                _MSG_EXITBS.Network= Encoding.GetEncoding(936).GetBytes(value.PadRight(2,' '));
            }
        }
        [DataField("Plaza")]
        public string  Plaza
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.Plaza);
            }
            set {
                _MSG_EXITBS.Plaza= Encoding.GetEncoding(936).GetBytes(value.PadRight(2,' '));
            }
        }
        [DataField("Year")]
        public string  Year
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.Year);
            }
            set {
                _MSG_EXITBS.Year= Encoding.GetEncoding(936).GetBytes(value.PadRight(4,' '));
            }
        }
        [DataField("Day")]
        public string  Day
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.Day);
            }
            set {
                _MSG_EXITBS.Day= Encoding.GetEncoding(936).GetBytes(value.PadRight(4,' '));
            }
        }
        [DataField("Hour")]
        public string  Hour
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.Hour);
            }
            set {
                _MSG_EXITBS.Hour= Encoding.GetEncoding(936).GetBytes(value.PadRight(6,' '));
            }
        }
        [DataField("YMD")]
        public string  YMD
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.YMD);
            }
            set {
                _MSG_EXITBS.YMD= Encoding.GetEncoding(936).GetBytes(value.PadRight(8,' '));
            }
        }
        [DataField("YMDHM")]
        public string  YMDHM
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.YMDHM);
            }
            set {
                _MSG_EXITBS.YMDHM= Encoding.GetEncoding(936).GetBytes(value.PadRight(14,' '));
            }
        }
        [DataField("LaneNo")]
        public string  LaneNo
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.LaneNo);
            }
            set {
                _MSG_EXITBS.LaneNo= Encoding.GetEncoding(936).GetBytes(value.PadRight(3,' '));
            }
        }     

Answer 2

   [DataField("Collector")]
        public string  Collector
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.Collector);
            }
            set {
                _MSG_EXITBS.Collector= Encoding.GetEncoding(936).GetBytes(value.PadRight(6,' '));
            }
        }
        [DataField("collectortype")]
        public string  collectortype
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.collectortype);
            }
            set {
                _MSG_EXITBS.collectortype= Encoding.GetEncoding(936).GetBytes(value.PadRight(1,' '));
            }
        }
        [DataField("WorkStatus")]
        public string  WorkStatus
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.WorkStatus);
            }
            set {
                _MSG_EXITBS.WorkStatus= Encoding.GetEncoding(936).GetBytes(value.PadRight(1,' '));
            }
        }
        [DataField("ICBox")]
        public string  ICBox
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.ICBox);
            }
            set {
                _MSG_EXITBS.ICBox= Encoding.GetEncoding(936).GetBytes(value.PadRight(4,' '));
            }
        }
        [DataField("TotalTraffic")]
        public Int32  TotalTraffic
        {
            get {
                return   Int32.Parse(Encoding.GetEncoding(936).GetString(_MSG_EXITBS.TotalTraffic));
            }
            set {
                _MSG_EXITBS.TotalTraffic= Encoding.GetEncoding(936).GetBytes(value.ToString().PadRight(10,' '));
            }
        }
        [DataField("BeginSTicketNo")]
        public string  BeginSTicketNo
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.BeginSTicketNo);
            }
            set {
                _MSG_EXITBS.BeginSTicketNo= Encoding.GetEncoding(936).GetBytes(value.PadRight(8,' '));
            }
        }
        [DataField("MARK")]
        public string  MARK
        {
            get {
                return Encoding.GetEncoding(936).GetString(_MSG_EXITBS.MARK);
            }
            set {
                _MSG_EXITBS.MARK= Encoding.GetEncoding(936).GetBytes(value.PadRight(1,' '));
            }
        }
        public override string ToString()
        {
          int rawsize = Marshal.SizeOf(_MSG_EXITBS);//得到内存大小
          IntPtr buffer = Marshal.AllocHGlobal(rawsize);//分配内存
          Marshal.StructureToPtr(_MSG_EXITBS, buffer, true);//转换结构
          byte[] rawdatas = new byte[rawsize];
          Marshal.Copy(buffer, rawdatas, 0, rawsize);//拷贝内存
          Marshal.FreeHGlobal(buffer); //释放内存
          return Encoding.GetEncoding(936).GetString(rawdatas);
        }
        public  void Parse(string s)
        {
             Type anytype = typeof(MSG_EXITBS);
             byte[] rawdatas = Encoding.GetEncoding(936).GetBytes(s);
             int rawsize = Marshal.SizeOf(anytype);
             if (rawsize > rawdatas.Length)
                   _MSG_EXITBS= new MSG_EXITBS();
             IntPtr buffer = Marshal.AllocHGlobal(rawsize);
             Marshal.Copy(rawdatas, 0, buffer, rawsize);
             object retobj = Marshal.PtrToStructure(buffer, anytype);
             Marshal.FreeHGlobal(buffer);
              _MSG_EXITBS=(MSG_EXITBS)retobj;
        }
      }//ExitBS
 }//TCS.Model
注意，客户端的结构一定要和服务端的结构保持一致。 
还需要注意编译器的  sizeof 问题。 因为编译器可能会 3个字节的 返回4个字节。 你可以查一下相关资料。 c#和gcc编译器都是可以调整的。 gcc下没跳过， c#下你可以在结构的元数据中设置。 应该有 1  2  4 这样的东西。 

Answer 3

是用的时候   TCS.Model.ExitBS ebs = “aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa直接可以字符串啦aaa”;

Answer 4

谢谢mysticboy！客户端的数据发送程序是别人早就写好的，使用sendto(sSocket, buffer, sendlen,0,(struct sockaddr FAR*)&dest_sin, sizeof(dest_sin))发送的，他原来的接收是在C中用recvfrom(),并用memcpy到struct 中。我在用C#中用UDP控件接收数据为byte[]型，得到的数据好像不对。请问我可以直接UDP的.Receive(ref EndPointReceive)来正确地接收数据吗？

Answer 5

安排给我的任务就是写服务器端的程序，接收数据并解析。C#里的UDP控件，接收到就是byte[],因此我想解析为struct

Answer 6

接收的byte[]数组轮换为对象不就得了呀应该有文档说明的第一个字节什么意思，第二个什么意思

Answer 7

哦。 那他应该有说明吧 。 
不过如果客户端的结构你能知道的话， 你也可以用c#来创建一个指针， 然后分配内存， 把你收到的数据写入 ， 然后用转换指针为结构就可以了。 注意， 定义c#的结构时，一定要按照这样的方式[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct MSG_EXITBS
    {
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =18)]
        public byte[] ID;
        [MarshalAs(UnmanagedType.ByValArray, SizeConst =1)]
        public byte[] MsgType;
     然后使用Type anytype = typeof(MSG_EXITBS);
             byte[] rawdatas = Encoding.GetEncoding(936).GetBytes(s);
             int rawsize = Marshal.SizeOf(anytype);
             if (rawsize > rawdatas.Length)
                   _MSG_EXITBS= new MSG_EXITBS();
             IntPtr buffer = Marshal.AllocHGlobal(rawsize);
             Marshal.Copy(rawdatas, 0, buffer, rawsize);
             object retobj = Marshal.PtrToStructure(buffer, anytype);
             Marshal.FreeHGlobal(buffer);
              _MSG_EXITBS=(MSG_EXITBS)retobj;
按照上面的方法， 应该没什么问题， 你再自己琢磨一下吧 。  

Answer 8

既然lz这么精通c
我觉得你应该用c写一个dll处理通讯。
c#调用dll进行处理。
这样更统一，也不涉及通讯格式转换的问题。