完整的TCP通信包实现

using System;

namespace Jh.Sockets
{
   /// <summary>
   /// 线程状态信号定义
   /// </summary>
 public enum JhThreadStatus
 {
  Stop,    //停止
  Running,   //正在运行
  Exit    //已退出
 }
 /// <summary>
 /// 线程状态参数
 /// </summary>
 class Parm
 {
    public Parm(object obj):this(JhThreadStatus.Stop,obj)
    {
    }
    public Parm(JhThreadStatus nStatus,object obj)
    {
       Status = nStatus;
       ObjParm = obj;
    }
    JhThreadStatus status;
    object objParm;
    /// <summary>
    /// 上下文对象
    /// </summary>
    public object ObjParm
    {
       get{return objParm;}
       set{objParm = value;}
    }
    /// <summary>
    /// 控制状态
    /// </summary>
    public JhThreadStatus Status
    {
       get{return status;}
       set{status = value;}
    }
 }
 /// <summary>
 /// 通讯数据处理接口
 /// </summary>
 public interface  IObserver
 {
    //
    // 数据处理入口
    //
    void Deal(CommData cd);

    //
    // 数据处理重载方法.如果不希望后面的处理者继续处理数据，则返回true,否则返回false;
    //
    bool OnDeal(CommData cd);

    //
    // 附加的自身初始化操作
    //
    bool Init();

    //
    // 提前初始化接口
    //
    bool BeforeInit();

    //
    // 初始化后处理接口
    //
    bool AfterInit();

    //
    // 删除前处理接口
    //
    bool BeforeExit();

    //
    // 下一个观察者
    //
    IObserver Next
    {
       get;
       set;
    }

    //
    // 上一个观察者
    //
    IObserver Prev
    {
       get;
       set;
    }

    //
    // 添加观察者到后面,如果已经存在链表中则不做任何操作
    //
    void Add(IObserver observer);

    //
    // 插入观察者到下一个观察者的前面
    //
    void Insert(IObserver observer);
    //删除观察者
    void Remove(IObserver observer);
    //是否存在链表中
    bool IsExist(IObserver observer);
}
   /// <summary>
   /// 通讯数据处理类的基类，只能派生
   /// </summary>
 public abstract class  Observer : IObserver
{
   /// <summary>
   /// 数据处理入口.
   /// </summary>
   /// <param name="client">TcpClient类 实例</param>
   /// <param name="s">内存数据流</param>
   public void Deal(CommData cd)
   {
      cd.Data.Position = 0;
      if (OnDeal(cd) == false) return ;
      if (next != null)
      {
         next.Deal(cd);
      }
      return ;
    }

   /// <summary>
   /// 数据处理重载方法.
   /// </summary>
   /// <param name="client">TcpClient类 实例</param>
   /// <param name="s">内存数据流</param>
   /// <returns>处理结果,如果不希望后面的处理者继续处理数据，则返回false,否则返回true;</returns>
   public virtual bool OnDeal(CommData cd)
   {
      return true;
   }

    //附加的自身初始化操作
   public virtual bool Init()
   {
      return true;
   }
   //提前初始化接口
   public virtual bool BeforeInit()
   {
      return true;
   }
   //初始化后处理接口
   public virtual bool AfterInit()
   {
      return true;
   }
   //删除前处理接口
   public virtual bool BeforeExit()
   {
      return true;
   }
   //下一个观察者
   IObserver next = null;
   public IObserver Next
   {
      get{return next;}
      set{next = value;}
   }
   //上一个观察者
   IObserver prev = null;
   public IObserver Prev
   {
      get{return prev;}
      set{prev = value;}
   }
   //添加观察者
   public void Add(IObserver observer)
   {
      if (this == observer) return;//已经存在
      if (next == null)
      {
         next = observer;//达到最底端
         next.Prev = this;
      }
      else next.Add(observer);//加到后面
   }
   /// <summary>
   /// 插入观察者到下一个观察者的前面
   /// </summary>
   /// <param name="observer"></param>
   public void Insert(IObserver observer)
   {
      //是否等于自己
      if (this == observer) return;
      //先查找是否已经存在链表中
      if (Next != null && Next.IsExist(observer)) Next.Remove(observer);
      //
      observer.Next = Next;
      if (Next != null) Next.Prev = observer;
      Next = observer;
      observer.Prev = this;
   }
   /// <summary>
   /// 删除观察者
   /// </summary>
   /// <param name="observer"></param>
   public void Remove(IObserver observer)
   {
      if (observer == this)
      {
       if (Prev != null) Prev.Next = Next;
       if (Next != null) Next.Prev = Prev;
      }
      else
      {
       if (Next != null) Next.Remove(observer);
      }
   }
   /// <summary>
   /// 查找是否存在
   /// </summary>
   /// <param name="observer"></param>
   /// <returns></returns>
   public bool IsExist(IObserver observer)
   {
      if (observer == this) return true;
      if (Next == null) return false;
      else return Next.IsExist(observer);
   }
}

 /// <summary>
 /// 日志处理基类，本身从通讯数据处理类的基类派生。
 /// </summary>
 class   Log : Observer
 {
     public  Log()
     {
     }
     public Log(string slogfile)
     {
        LogFile = slogfile;
     }
     ~Log()
     {
     }
     // 日志文件带路径名称
     private string logFile;
     public string LogFile
     {
      get{return logFile;}
      set{logFile = value;}
     }
 }

}
using System;
using System.Collections;
using System.IO;
using System.Threading;

namespace Jh.Sockets
{
 /// <summary>
 /// 数据集中管理类
 /// </summary>
 public class CommDataMgr
 {
  static int index = 0;
  int id;
  /// <summary>
  /// 无参数构造方法
  /// </summary>
  public CommDataMgr()
  {
   id = index ++;
   dnFlag = new Parm(this);
   Console.WriteLine("JH data distributor {0} constructed",id);
  }
  Thread t = null;
  public void Start()
  {
   if (dnFlag.Status != JhThreadStatus.Running)
   {
    dnFlag.Status = JhThreadStatus.Running;
    t = new Thread (new ThreadStart(DataNotiyfyThread));
    t.Name = "JH data distributing  " + id.ToString();
    t.Start();
    Console.WriteLine("JH data distributing thread of JH data distributor {0} started",id);
   }
  }
  public void Stop()
  {  
   if ( dnFlag.Status == JhThreadStatus.Running )
   {
    lock (this)
    {
     dnFlag.Status = JhThreadStatus.Stop;
    }
   }

  }
  /// <summary>
  /// 析构方法
  /// </summary>
  ~CommDataMgr()
  {
   Stop();
   Console.WriteLine("JH data distributor {0} unconstructed",id);
  }
  public void DataNotiyfyThread()
  {
   try
   {
    while (dnFlag.Status == JhThreadStatus.Running)
    {
     DealData();
     Thread.Sleep(100);
//     Console.WriteLine("分发线程{0}工作中",id);
    }
   }
   catch(Exception e)
   {
    Console.WriteLine(e.Message);
   }
   finally
   {
    lock(this)
    {
     dnFlag.Status = JhThreadStatus.Exit;
    }
    Console.WriteLine("JH data distributing thread of JH data distributor {0} exited",id);
   }
  }
  Parm dnFlag = null;
  ArrayList aData = new ArrayList();
  InnerObserver root = new InnerObserver();
  /// <summary>
  /// 观察者根节点类 定义
  /// </summary>
  internal class InnerObserver : Observer
  {
  }
  public void DealData()
  {
   if (DataCount > 0)
   {
    lock(this)
    {
     if (root.Next != null)
     {
      root.Next.Deal((CommData)aData[0]);
     }
     RemoveAt(0);
    }
   }
  }
  /// <summary>
  /// 未处理数据个数
  /// </summary>
  public int DataCount
  {
   get
   {
    return aData.Count;
   }
  }
  /// <summary>
  /// 根据索引返回未处理数据
  /// </summary>
  internal CommData this[int Index]
  {
   get
   {
    return (CommData)aData[Index];
   }
  }
  /// <summary>
  /// 根据索引删除数据
  /// </summary>
  /// <param name="Index">索引</param>
  public void RemoveAt(int Index)
  {
   if (Index >= 0 && Index < DataCount)
   {
    lock (this)
    {
     aData.RemoveAt(Index);
    }
   }
  }
  /// <summary>
  /// 接收到新的数据提交
  /// </summary>
  /// <param name="client">客户端连接</param>
  /// <param name="s">数据流</param>
  public void AddData(JhClient client,MemoryStream s,int len)
  {
   CommData cd = new CommData(client,s,len,this);
   lock(this)
   {
    aData.Add(cd);
   }
  }
  /// <summary>
  /// 添加观察者
  /// </summary>
  /// <param name="observer"></param>
  public void Add(IObserver observer)
  {
   lock (this)
   {
    root.Add(observer);
   }
  }
  /// <summary>
  /// 删除观察者
  /// </summary>
  /// <param name="observer"></param>
  public void Remove(IObserver observer)
  {
   lock (this)
   {
    root.Remove(observer);
   }
  }
  /// <summary>
  /// 在最前面插入观察者
  /// </summary>
  /// <param name="observer"></param>
  public void Insert(IObserver observer)
  {
   lock (this)
   {
    root.Insert(observer);
   }
  }
  // 取观察者个数
  //  int GetObserverCount()
  //  {
  //   return (int)m_aObservers.GetCount();
  //  }

 }