完整的TCP通信包实现

原创 2005年03月01日 08:59:00

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();
  //  }

 }

基于TCP的通信为什么需要RETRY

TCP协议本身是可靠的,它的重传机制保证了消息的可送达性(如果没有收到对端的ACK确认,它会在等待一定时间后,尝试再次发送,且这是一个循环过程,上限是9分钟。超过9分钟,则认为连接已经断开,关闭soc...
  • squalfof
  • squalfof
  • 2015-06-14 17:01:53
  • 1630

TCP标志位简析

TCP标志位简析   TCP标志位  URG:此标志表示TCP包的紧急指针域(后面马上就要说到)有效,用来保证TCP连接不被中断,并且督促中间层设备要尽快处理这些数据; ACK:此标志表示应答...
  • wo2niliye
  • wo2niliye
  • 2015-09-15 13:01:39
  • 367

websocket.jar+catalina.jar

  • 2016年11月09日 16:44
  • 2.19MB
  • 下载

comet4j-tomcat6.jar

  • 2014年02月26日 14:12
  • 106KB
  • 下载

smartConfig---通过数据包长度位作为编码位,进行短数据通讯

SmartConfig技术原理 时间 2015-07-21 14:07:31  小鳄的笔记本 原文  http://www.trueeyu.com/?p=1848 主题 摄像头 ...
  • u010833547
  • u010833547
  • 2017-04-17 17:17:55
  • 392

cJSON源代码,轻巧方便,用于封装通信包非常合适

  • 2016年07月01日 14:16
  • 32KB
  • 下载

hive-hbase-handler-0.13.0

  • 2014年09月03日 13:34
  • 56KB
  • 下载

自动生成彩信包,MMS打包

  • 2010年09月20日 15:32
  • 703KB
  • 下载

Flex与JSP通信包

  • 2010年12月07日 11:33
  • 237KB
  • 下载

hive 0.12版本 hive-hbase-handler-0.12.0.jar包的编译

在进行hive、hbase整合的过程中,可能要对hbase-handler-0.12.jarjinj
  • vah101
  • vah101
  • 2014-05-23 09:45:12
  • 1726
收藏助手
不良信息举报
您举报文章:完整的TCP通信包实现
举报原因:
原因补充:

(最多只允许输入30个字)