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