新的一年，是不是该研究些新的东西？一起来看看COMET的第四篇，线程控制吧。
——lynn感冒中～阿嚏～
主题列表：
引言：
在上一篇随笔中，对操作COMET的实体类进行了简单的分析，本篇随笔将对COMET框架的线程控制进行分析，欢迎大家来拍砖。
CORE框架：
图1.1 COMET核心框架
CometWaitRequest类：
CometWaitRequest是一个请求信息的控制信息的抽象，包含了所有需要的控制信息，并且由CometWaitThread直接调用。简单地理解这个类，服务器事件的发布需要有一些线程进行管理，CometWaitRequest对这些事件的控制信息进行抽象，一个用户可以引发多个客户端请求，服务器端需要对这样的请求进行映射，一个用户提交给服务器的信息，需要分别由相应线程进行管制，事件的队列化，然后就是请求的队列化，消息的队列化，都需要线程的直接管理，这个类是客户端管理信息的抽象。
using System; using System.Data; using System.Configuration; using System.Linq; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Xml.Linq; namespace MethodWorx.AspNetComet.Core { /// <summary> /// Class CometWaitRequest /// /// This class contains all the information required when queue the request on a specific CometWaitThread /// </summary> public class CometWaitRequest { private CometAsyncResult result; private DateTime dateTimeAdded = DateTime.Now; private string clientPrivateToken; private long lastMessageId; private DateTime? dateDeactivated = null; /// <summary> /// Construct a new instance of a CometWaitRequest object /// </summary> /// <param name="clientPrivateToken"></param> /// <param name="lastMessageId"></param> /// <param name="context"></param> /// <param name="callback"></param> /// <param name="state"></param> public CometWaitRequest(string clientPrivateToken, long lastMessageId, HttpContext context, AsyncCallback callback, object state) { this.clientPrivateToken = clientPrivateToken; this.lastMessageId = lastMessageId; this.result = new CometAsyncResult(context, callback, state); } /// <summary> /// Gets the CometAsyncResult object associated with this CometWaitRequest /// </summary> public CometAsyncResult Result { get { return this.result; } } /// <summary> /// Gets the Date and time this request was added, so the system knows when to time it out /// </summary> public DateTime DateTimeAdded { get { return this.dateTimeAdded; } } /// <summary> /// Gets the private token of the client that is connected to this wait request /// </summary> public string ClientPrivateToken { get { return this.clientPrivateToken; } } /// <summary> /// Gets the LastMessage that is specified by the client when it connects and creates this wait request /// This is used to identify what messages we are interested in (basically any greater than LastMessageId will be /// returned to the client) /// </summary> public long LastMessageId { get { return this.lastMessageId; } } /// <summary> /// Gets a boolean flag indicating if this client is active (has it been disconnected, and is it not idle?) /// </summary> public bool Active { get { return !this.dateDeactivated.HasValue; } } /// <summary> /// Gets a DateTime indicating when the client was Deactivated, this is the period where the client can reconnect /// and become active again. If the client does not reconnect within the specified Idle time for the client, it will /// be disconnected from the server and removed from the state manager /// </summary> public DateTime? DateDeactivated { get { return this.dateDeactivated; } set { this.dateDeactivated = value; } } } }
PS：这里需要说明的是 "DateTime?” 后加的问号最好不要去掉，它代表DateDeactivated变量可赋值为NULL，超时是可以存在也可不存在的，所以我们没有必要为DateDeactivated预先实例化。CometAsyncResult类在这个类里被实例化。
CometAsyncResult类：
这个类也很有趣，MSDN上对IAsyncResult 接口有如下的解释：
“IAsyncResult 接口由包含可异步操作的方法的类实现。它是启动异步操作的方法的返回类型，如 FileStream.BeginRead，也是结束异步操作的方法的第三个参数的类型，如 FileStream.EndRead。当异步操作完成时，IAsyncResult 对象也将传递给由 AsyncCallback 委托调用的方法。
支持 IAsyncResult 接口的对象存储异步操作的状态信息，并提供同步对象以允许线程在操作完成时终止。”
CometAsyncResult类继承了IAsyncResult 接口有很多的好处，首先我们可以直接借用.net框架AsyncCallback的BeginInvoke和EndInvoke启动或终结异步操作。
“.NET Framework 允许您异步调用任何方法。为此，应定义与您要调用的方法具有相同签名的委托；公共语言运行库会自动使用适当的签名为该委托定义 BeginInvoke 和 EndInvoke 方法。
BeginInvoke 方法可启动异步调用。它与您需要异步执行的方法具有相同的参数，另外它还有两个可选参数。第一个参数是一个 AsyncCallback 委托，该委托引用在异步调用完成时要调用的方法。第二个参数是一个用户定义的对象，该对象可向回调方法传递信息。BeginInvoke 立即返回，不等待异步调用完成。BeginInvoke 会返回 IAsyncResult，这个结果可用于监视异步调用进度。
EndInvoke 方法检索异步调用的结果。调用 BeginInvoke 后可随时调用 EndInvoke 方法；如果异步调用尚未完成，EndInvoke 将一直阻止调用线程，直到异步调用完成后才允许调用线程执行。EndInvoke 的参数包括您需要异步执行的方法的 out 和 ref 参数（在 Visual Basic 中为 <Out> ByRef 和 ByRef）以及由 BeginInvoke 返回的 IAsyncResult。”
使用帮助：http://msdn.microsoft.com/zh-cn/library/2e08f6yc(VS.80).aspx
PS：如果只是从应用来说，这一段是可以跳过去的，因为拓展这套框架不需要我们修改这个类的结构。
using System; using System.Data; using System.Configuration; using System.Linq; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Xml.Linq; using System.Threading; namespace MethodWorx.AspNetComet.Core { /// <summary> /// An Implementation of IAsyncResult that enables the use of the custom thread pool /// and enables us to use the IHttpAsyncHandler implementation /// </summary> public class CometAsyncResult : IAsyncResult { private AsyncCallback callback; private object asyncState; private bool isCompleted = false; private CometMessage[] messages; private HttpContext context; /// <summary> /// Construct a new instance of CometAsyncResult /// </summary> /// <param name="context">The HTTP Context passed in from the handler</param> /// <param name="callback">The AsyncCallback passed in from the handler</param> /// <param name="asyncState">The extra data passed in from the handler</param> public CometAsyncResult(HttpContext context, AsyncCallback callback, object asyncState) { this.callback = callback; this.asyncState = asyncState; this.context = context; } #region IAsyncResult Members /// <summary> /// Gets or Sets the extra data associated with this async operation /// </summary> public object AsyncState { get { return this.asyncState; } } /// <summary> /// Not Implemented: will throw InvalidOperationException("ASP.NET Should never use this property"); } /// </summary> public WaitHandle AsyncWaitHandle { get { throw new InvalidOperationException("ASP.NET Should never use this property"); } } /// <summary> /// Gets a boolean indicating if the operation completed synchronously (always returns false) /// </summary> public bool CompletedSynchronously { get { return false; } } /// <summary> /// Gets a boolean indicating if the operation has completed /// </summary> public bool IsCompleted { get { return this.isCompleted; } } /// <summary> /// Gets the HttpContext associaetd with this async operation /// </summary> public HttpContext Context { get { return this.context; } } #endregion /// <summary> /// Gets the Messages that are to be returned upon completion of this Async Operation /// </summary> public CometMessage [] CometMessages { get { return this.messages; } set { this.messages = value; } } /// <summary> /// Signal this operation has completed /// </summary> internal void SetCompleted() { this.isCompleted = true; if (callback != null) callback(this); } } }
CometWaitThread类：
CometWaitThread线程类负责控制CometWaitRequest，当一个用户提交了消息以后，会建立相应的CometWaitThread。
ps:关于线程控制这部分，只是做简要的介绍，毕竟COMET框架的核心说到这里，就都是实现的机制了，而线程无非是作为各种“通道”的管理工具存在，并不需要什么拓展。当然如果做为研究，这里可以深入挖掘。比如加入一些竞争算法来优化消息控制，或者对特定消息（如紧急事件等）可以在线程控制上优先发布。
using System; using System.Data; using System.Configuration; using System.Linq; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Xml.Linq; using System.Collections.Generic; using System.Threading; using System.Diagnostics; namespace MethodWorx.AspNetComet.Core { /// <summary> /// Class CometWaitThread /// /// This class contains an implementation of the thread pool that controls the /// CometWaitRequest objects and returns specified messages, errors or timeout messages /// back to the client in a controlled and scalable fasion /// </summary> public class CometWaitThread { private object state = new object(); private List<CometWaitRequest> waitRequests = new List<CometWaitRequest>(); private CometStateManager stateManager; public List<CometWaitRequest> WaitRequests { get { return this.waitRequests; } } public CometWaitThread(CometStateManager stateManager) { // get the state manager this.stateManager = stateManager; Thread t = new Thread(new ThreadStart(QueueCometWaitRequest_WaitCallback)); t.IsBackground = false; t.Start(); } internal void QueueCometWaitRequest(CometWaitRequest request) { lock (this.state) { waitRequests.Add(request); } } internal void DeactivateCometWaitRequest(CometWaitRequest request) { lock (state) { //this.waitRequests.Remove(request); // we disable the request, and we hope the // client should connect immediatly else we time it out! request.DateDeactivated = DateTime.Now; } } private void QueueCometWaitRequest_Finished(object target) { CometWaitRequest request = target as CometWaitRequest; request.Result.SetCompleted(); } private void QueueCometWaitRequest_WaitCallback() { // here we are... // in a loop while (true) { //Debug.WriteLine(string.Format("QueueCometWaitRequest_WaitCallback Tick: {0} {1} ", Thread.CurrentThread.IsThreadPoolThread, Thread.CurrentThread.ManagedThreadId)); CometWaitRequest[] processRequest; lock (this.state) { processRequest = waitRequests.ToArray(); } // we have no more wait requests left, so we want exis /*if (processRequest.Length == 0) break;*/ if (processRequest.Length == 0) { // sleep for this time Thread.Sleep(100); } else { for (int i = 0; i < processRequest.Length; i++) { try { CometClient cometClient = this.stateManager.StateProvider.GetCometClient(processRequest[i].ClientPrivateToken); if (processRequest[i].Active) { Thread.Sleep(100); // timed out so remove from the queue if (DateTime.Now.Subtract(processRequest[i].DateTimeAdded).TotalSeconds >= cometClient.ConnectionTimeoutSeconds) { // dequeue the request DeactivateCometWaitRequest(processRequest[i]); // get the message CometMessage timeoutMessage = new CometMessage() { MessageId = 0, Name = "aspNetComet.timeout", Contents = null }; // // ok, we we timeout the message processRequest[i].Result.CometMessages = new CometMessage[] { timeoutMessage }; // call the message this.QueueCometWaitRequest_Finished(processRequest[i]); } else { CometMessage[] messages = this.CheckForServerPushMessages(processRequest[i]); if (messages != null && messages.Length > 0) { // we have our message processRequest[i].Result.CometMessages = messages; // and return! // dequeue the request DeactivateCometWaitRequest(processRequest[i]); // queue the response on another ASP.NET Worker thread this.QueueCometWaitRequest_Finished(processRequest[i]); } } } else { // this is an inactive this.CheckForIdleCometWaitRequest(processRequest[i], cometClient); } } catch (Exception ex) { if (processRequest[i].Active) { // ok, this one has screwed up, so // we need to dequeue the request from ASP.NET, basically disable it and return // dequeue the request DeactivateCometWaitRequest(processRequest[i]); // get the message CometMessage errorMessage = new CometMessage() { MessageId = 0, Name = "aspNetComet.error", Contents = ex.Message }; // // ok, we we timeout the message processRequest[i].Result.CometMessages = new CometMessage[] { errorMessage }; // call the message this.QueueCometWaitRequest_Finished(processRequest[i]); } else { // this is not an active request, so we dequeue it from the // thread this.DequeueCometWaitRequest(processRequest[i].ClientPrivateToken); } } } } } } private void CheckForIdleCometWaitRequest(CometWaitRequest request, CometClient cometClient) { lock (state) { if (DateTime.Now.Subtract(request.DateDeactivated.Value).TotalSeconds >= cometClient.ConnectionIdleSeconds) { // ok, this dude has timed out, so we remove it this.stateManager.KillIdleCometClient(cometClient.PrivateToken); // and deque the request this.waitRequests.Remove(request); } } } private CometMessage[] CheckForServerPushMessages(CometWaitRequest request) { // // ok, we we need to do is get the messages // that are stored in the state provider return this.stateManager.StateProvider.GetMessages(request.ClientPrivateToken, request.LastMessageId); } internal void DequeueCometWaitRequest(string privateToken) { lock (state) { for(int i =0; i < this.waitRequests.Count; i ++) { CometWaitRequest request = this.waitRequests[i]; if (request.ClientPrivateToken == privateToken) { // remove it this.waitRequests.Remove(request); break; } } } } } }
CometStateManager类：
CometStateManager是整套COMET机制的核心，它将CometWaitThread和ICometStateProvider、CometClient、CometMessage结合在了一起，形成了整套COMET的应用框架。是拓展COMET应用必须要改造的类。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Threading;
using System.Web;
using System.Web.UI;
using System.Runtime.Serialization.Json;
namespace MethodWorx.AspNetComet.Core
{
/// <summary>
/// CometStateManger Class
///
/// An instance of the this class is used to control the manager the state of the COMET Application.
/// This class manages an instance of a ICometStateProvider instance
/// </summary>
///
public class CometStateManager
{
private ICometStateProvider stateProvider;
private int workerThreadCount;
private int maximumTimeSlot;
private int currentThread = 0;
private CometWaitThread[] workerThreads;//
private object state = new object();
/// <summary>
/// Event that is called when a Client is Initialized
/// </summary>
public event CometClientEventHandler ClientInitialized;
/// <summary>
/// Event that is called when a Client is killed
/// </summary>
public event CometClientEventHandler IdleClientKilled;
/// <summary>
/// Event that is called when a Client subscribes to this channel
/// </summary>
public event CometClientEventHandler ClientSubscribed;
/// <summary>
/// Construct an instane of the CometStateManager class and pass in an
/// instance of an ICometStateProvider to manage the persistence of the state
/// </summary>
/// <param name="stateProvider">An instance of an ICometStateProvider class that manages the persistence of the state</param>
/// <param name="workerThreadCount">How many worked threads should this CometStateManager initialize</param>
/// <param name="maximumTimeSlot">The maximum time in milliseconds that should be idle between each COMET client is polled within a worker thread</param>
public CometStateManager(ICometStateProvider stateProvider, int workerThreadCount, int maximumTimeSlot)
{
if (stateProvider == null)
throw new ArgumentNullException("stateProvider");
if (workerThreadCount <= 0)
throw new ArgumentOutOfRangeException("workerThreadCount");
// ok, setup the member of this class
this.stateProvider = stateProvider;
this.workerThreadCount = workerThreadCount;
this.maximumTimeSlot = maximumTimeSlot;
this.workerThreads = new CometWaitThread[5];
//
// ok, lets fireup the threads
for(int i = 0; i < workerThreadCount; i ++)
{
this.workerThreads[i] =
new CometWaitThread(this);
}
}
/// <summary>
/// Construct an instane of the CometStateManager class and pass in an
/// instance of an ICometStateProvider to manage the persistence of the state
///
/// This calls the main constructor and specifies the default values workerThreadCount = 5 and maximumTimeSlot = 100. These values
/// can be tuned for your application by using the main constructor
/// </summary>
/// <param name="stateProvider">An instance of an ICometStateProvider class that manages the persistence of the state</param>
public CometStateManager(ICometStateProvider stateProvider)
: this(stateProvider, 5, 100)
{
}
/// <summary>
/// Creates a CometClient instance that is persisted into the ICometStateProvider instance. This needs to be
/// called by the server prior to the client connecting from a client application.
/// </summary>
/// <remarks>
/// This method will typically be used after a login script is executed, either from a standard ASP.NET form
/// or an Ajax Method etc...
///
/// The server would validate the user information, if successfull initialize a client in the COMET engine ready
/// for the client to connect.
/// </remarks>
/// <param name="publicToken">The public token of the client, this token is used to identify the client to other clients</param>
/// <param name="privateToken">The private token of the client, this token is used to identify the client to itself</param>
/// <param name="displayName">The display name of the client, can be used to hold a friendly display name of the client</param>
/// <param name="connectionTimeoutSeconds">The number of seconds the client will be connected to the server for, until it needs to reestablish a connection becuase no messages have been sent</param>
/// <param name="connectionIdleSeconds">The number of seconds the server will wait for the client to reconnect before it treats it as an idle connection and removes it from the server</param>
/// <returns>An initialized CometClient object that represents the initialized client</returns>
public CometClient InitializeClient(string publicToken, string privateToken, string displayName, int connectionTimeoutSeconds, int connectionIdleSeconds)
{
// validate the parameters
if (string.IsNullOrEmpty(publicToken))
throw new ArgumentNullException("publicToken");
if (string.IsNullOrEmpty(privateToken))
throw new ArgumentNullException("privateToken");
if (string.IsNullOrEmpty(displayName))
throw new ArgumentNullException("displayName");
if (connectionIdleSeconds <= 0)
throw new ArgumentOutOfRangeException("connectionIdleSeconds must be greater than 0");
if (connectionTimeoutSeconds <= 0)
throw new ArgumentOutOfRangeException("connectionTimeoutSeconds must be greater than 0");
CometClient cometClient = new CometClient();
// ok, set it up
cometClient.ConnectionIdleSeconds = connectionIdleSeconds;
cometClient.ConnectionTimeoutSeconds = connectionTimeoutSeconds;
cometClient.DisplayName = displayName;
cometClient.LastActivity = DateTime.Now;
cometClient.PrivateToken = privateToken;
cometClient.PublicToken = publicToken;
//
// send this to the state provider
this.stateProvider.InitializeClient(cometClient);
// ok, fire the event
this.FireClientInitialized(cometClient);
return cometClient;
}
/// <summary>
/// Called from an Asynchronous HttpHandler Method to begin the Subscribe call
/// </summary>
/// <param name="context">HttpContext passed in from the handler</param>
/// <param name="callback">AsyncCallback passed in from the handler</param>
/// <param name="extraData">AsyncState passed in from the handler</param>
/// <returns>An IAsyncResult used to identify and control the asynchronous operation</returns>
public IAsyncResult BeginSubscribe(HttpContext context, AsyncCallback callback, object extraData)
{
try
{
long lastMessageId;
string privateToken;
if (!long.TryParse(context.Request["lastMessageId"] ?? "-1", out lastMessageId))
throw CometException.CometHandlerParametersAreInvalidException();
privateToken = context.Request["privateToken"];
if (string.IsNullOrEmpty(privateToken))
throw CometException.CometHandlerParametersAreInvalidException();
this.DebugWriteThreadInfo("BeginSubscribe");
lock (state)
{
//
// get the comet client
CometClient cometClient = this.GetCometClient(privateToken);
// ok, fire the event
this.FireClientSubscribed(cometClient);
// kill the previous one if one exists
// from the thread pool
for (int i = 0; i < this.workerThreadCount; i++)
{
this.workerThreads[i].DequeueCometWaitRequest(privateToken);
}
// ok, this is our result, so lets queue it
CometWaitRequest request = new CometWaitRequest(privateToken, lastMessageId, context, callback, extraData);
// we have our request so lets queue it on a thread
this.workerThreads[this.currentThread].QueueCometWaitRequest(request);
// cycle the thread count
this.currentThread++;
if (this.currentThread >= this.workerThreadCount)
this.currentThread = 0; // cycle back to 0
return request.Result;
}
}
catch (Exception ex)
{
this.WriteErrorToResponse(context, ex.Message);
return null;
}
}
/// <summary>
/// Called from an Asynchronous HttpHandler Method method to complete the Subscribe call
/// </summary>
/// <param name="result">The IAsyncResult instance that was initialized in the BeginSubscribe call</param>
public void EndSubscribe(IAsyncResult result)
{
this.DebugWriteThreadInfo("EndSubscribe");
CometAsyncResult cometAsyncResult = result as CometAsyncResult;
if (cometAsyncResult != null)
{
try
{
// get the messages
CometMessage[] messages = cometAsyncResult.CometMessages;
// serialize the messages
// back to the client
if (messages != null && messages.Length > 0)
{
List<Type> knownTypes = new List<Type>();
foreach (CometMessage message in messages)
{
if (message.Contents != null)
{
Type knownType = message.Contents.GetType();
if (!knownTypes.Contains(knownType))
{
knownTypes.Add(knownType);
}
}
}
DataContractJsonSerializer serializer = new DataContractJsonSerializer(messages.GetType(), knownTypes);
serializer.WriteObject(((CometAsyncResult)result).Context.Response.OutputStream, messages);
}
}
catch (Exception ex)
{
// write the error out??
this.WriteErrorToResponse(((CometAsyncResult)result).Context, ex.Message);
}
}
}
/// <summary>
/// Send a message to a specific client
/// </summary>
/// <param name="clientPublicToken">The public token of the client</param>
/// <param name="name">The name of the message</param>
/// <param name="contents">The contents of the message</param>
public void SendMessage(string clientPublicToken, string name, object contents)
{
this.stateProvider.SendMessage(clientPublicToken, name, contents);
}
/// <summary>
/// Send a message to all clients
/// </summary>
/// <param name="name">The name of the message</param>
/// <param name="contents">The contents of the message</param>
public void SendMessage(string name, object contents)
{
this.stateProvider.SendMessage(name, contents);
}
/// <summary>
/// Gets the ICometStateProvider instance this manager consumes
/// </summary>
internal ICometStateProvider StateProvider
{
get { return this.stateProvider; }
}
/// <summary>
/// Register the required javascript for the page
/// </summary>
/// <param name="page">The page we want to write the scripts to</param>
public static void RegisterAspNetCometScripts(Page page)
{
page.ClientScript.RegisterClientScriptResource(typeof(CometStateManager), "MethodWorx.AspNetComet.Core.Scripts.AspNetComet.js");
}
/// <summary>
/// Kill an IdleCometClient
/// </summary>
/// <param name="clientPrivateToken"></param>
public void KillIdleCometClient(string clientPrivateToken)
{
// get the comet client
CometClient cometClient = this.stateProvider.GetCometClient(clientPrivateToken);
// ok, tmie the clietn out
this.stateProvider.KillIdleCometClient(clientPrivateToken);
// and fire
this.FireIdleClientKilled(cometClient);
}
public CometClient GetCometClient(string clientPrivateToken)
{
return this.stateProvider.GetCometClient(clientPrivateToken);
}
internal void DebugWriteThreadInfo(string message)
{
int workerAvailable = 0;
int completionPortAvailable = 0;
ThreadPool.GetAvailableThreads(out workerAvailable, out completionPortAvailable);
Debug.WriteLine(string.Format("{0}: {1} {2} out of {3}/{4}", message, Thread.CurrentThread.IsThreadPoolThread, Thread.CurrentThread.ManagedThreadId, workerAvailable, completionPortAvailable));
}
internal void FireClientInitialized(CometClient cometClient)
{
if (this.ClientInitialized != null)
this.ClientInitialized(this, new CometClientEventArgs(cometClient));
}
internal void FireIdleClientKilled(CometClient cometClient)
{
if (this.IdleClientKilled != null)
this.IdleClientKilled(this, new CometClientEventArgs(cometClient));
}
internal void FireClientSubscribed(CometClient cometClient)
{
if (this.ClientSubscribed != null)
this.ClientSubscribed(this, new CometClientEventArgs(cometClient));
}
private void WriteErrorToResponse(HttpContext context, string message)
{
//
// ok, we have had an error so we have to return it
CometMessage errorMessage = new CometMessage();
errorMessage.Name = "aspNetComet.error";
errorMessage.MessageId = 0;
errorMessage.Contents = message;
CometMessage[] messages = new CometMessage[] { errorMessage };
DataContractJsonSerializer serializer = new DataContractJsonSerializer(messages.GetType());
serializer.WriteObject(context.Response.OutputStream, messages);
context.Response.End();
}
}
}
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; using System.Threading; using System.Web; using System.Web.UI; using System.Runtime.Serialization.Json; namespace MethodWorx.AspNetComet.Core { /// <summary> /// CometStateManger Class /// /// An instance of the this class is used to control the manager the state of the COMET Application. /// This class manages an instance of a ICometStateProvider instance /// </summary> /// public class CometStateManager { private ICometStateProvider stateProvider; private int workerThreadCount; private int maximumTimeSlot; private int currentThread = 0; private CometWaitThread[] workerThreads;// private object state = new object(); /// <summary> /// Event that is called when a Client is Initialized /// </summary> public event CometClientEventHandler ClientInitialized; /// <summary> /// Event that is called when a Client is killed /// </summary> public event CometClientEventHandler IdleClientKilled; /// <summary> /// Event that is called when a Client subscribes to this channel /// </summary> public event CometClientEventHandler ClientSubscribed; /// <summary> /// Construct an instane of the CometStateManager class and pass in an /// instance of an ICometStateProvider to manage the persistence of the state /// </summary> /// <param name="stateProvider">An instance of an ICometStateProvider class that manages the persistence of the state</param> /// <param name="workerThreadCount">How many worked threads should this CometStateManager initialize</param> /// <param name="maximumTimeSlot">The maximum time in milliseconds that should be idle between each COMET client is polled within a worker thread</param> public CometStateManager(ICometStateProvider stateProvider, int workerThreadCount, int maximumTimeSlot) { if (stateProvider == null) throw new ArgumentNullException("stateProvider"); if (workerThreadCount <= 0) throw new ArgumentOutOfRangeException("workerThreadCount"); // ok, setup the member of this class this.stateProvider = stateProvider; this.workerThreadCount = workerThreadCount; this.maximumTimeSlot = maximumTimeSlot; this.workerThreads = new CometWaitThread[5]; // // ok, lets fireup the threads for(int i = 0; i < workerThreadCount; i ++) { this.workerThreads[i] = new CometWaitThread(this); } } /// <summary> /// Construct an instane of the CometStateManager class and pass in an /// instance of an ICometStateProvider to manage the persistence of the state /// /// This calls the main constructor and specifies the default values workerThreadCount = 5 and maximumTimeSlot = 100. These values /// can be tuned for your application by using the main constructor /// </summary> /// <param name="stateProvider">An instance of an ICometStateProvider class that manages the persistence of the state</param> public CometStateManager(ICometStateProvider stateProvider) : this(stateProvider, 5, 100) { } /// <summary> /// Creates a CometClient instance that is persisted into the ICometStateProvider instance. This needs to be /// called by the server prior to the client connecting from a client application. /// </summary> /// <remarks> /// This method will typically be used after a login script is executed, either from a standard ASP.NET form /// or an Ajax Method etc... /// /// The server would validate the user information, if successfull initialize a client in the COMET engine ready /// for the client to connect. /// </remarks> /// <param name="publicToken">The public token of the client, this token is used to identify the client to other clients</param> /// <param name="privateToken">The private token of the client, this token is used to identify the client to itself</param> /// <param name="displayName">The display name of the client, can be used to hold a friendly display name of the client</param> /// <param name="connectionTimeoutSeconds">The number of seconds the client will be connected to the server for, until it needs to reestablish a connection becuase no messages have been sent</param> /// <param name="connectionIdleSeconds">The number of seconds the server will wait for the client to reconnect before it treats it as an idle connection and removes it from the server</param> /// <returns>An initialized CometClient object that represents the initialized client</returns> public CometClient InitializeClient(string publicToken, string privateToken, string displayName, int connectionTimeoutSeconds, int connectionIdleSeconds) { // validate the parameters if (string.IsNullOrEmpty(publicToken)) throw new ArgumentNullException("publicToken"); if (string.IsNullOrEmpty(privateToken)) throw new ArgumentNullException("privateToken"); if (string.IsNullOrEmpty(displayName)) throw new ArgumentNullException("displayName"); if (connectionIdleSeconds <= 0) throw new ArgumentOutOfRangeException("connectionIdleSeconds must be greater than 0"); if (connectionTimeoutSeconds <= 0) throw new ArgumentOutOfRangeException("connectionTimeoutSeconds must be greater than 0"); CometClient cometClient = new CometClient(); // ok, set it up cometClient.ConnectionIdleSeconds = connectionIdleSeconds; cometClient.ConnectionTimeoutSeconds = connectionTimeoutSeconds; cometClient.DisplayName = displayName; cometClient.LastActivity = DateTime.Now; cometClient.PrivateToken = privateToken; cometClient.PublicToken = publicToken; // // send this to the state provider this.stateProvider.InitializeClient(cometClient); // ok, fire the event this.FireClientInitialized(cometClient); return cometClient; } /// <summary> /// Called from an Asynchronous HttpHandler Method to begin the Subscribe call /// </summary> /// <param name="context">HttpContext passed in from the handler</param> /// <param name="callback">AsyncCallback passed in from the handler</param> /// <param name="extraData">AsyncState passed in from the handler</param> /// <returns>An IAsyncResult used to identify and control the asynchronous operation</returns> public IAsyncResult BeginSubscribe(HttpContext context, AsyncCallback callback, object extraData) { try { long lastMessageId; string privateToken; if (!long.TryParse(context.Request["lastMessageId"] ?? "-1", out lastMessageId)) throw CometException.CometHandlerParametersAreInvalidException(); privateToken = context.Request["privateToken"]; if (string.IsNullOrEmpty(privateToken)) throw CometException.CometHandlerParametersAreInvalidException(); this.DebugWriteThreadInfo("BeginSubscribe"); lock (state) { // // get the comet client CometClient cometClient = this.GetCometClient(privateToken); // ok, fire the event this.FireClientSubscribed(cometClient); // kill the previous one if one exists // from the thread pool for (int i = 0; i < this.workerThreadCount; i++) { this.workerThreads[i].DequeueCometWaitRequest(privateToken); } // ok, this is our result, so lets queue it CometWaitRequest request = new CometWaitRequest(privateToken, lastMessageId, context, callback, extraData); // we have our request so lets queue it on a thread this.workerThreads[this.currentThread].QueueCometWaitRequest(request); // cycle the thread count this.currentThread++; if (this.currentThread >= this.workerThreadCount) this.currentThread = 0; // cycle back to 0 return request.Result; } } catch (Exception ex) { this.WriteErrorToResponse(context, ex.Message); return null; } } /// <summary> /// Called from an Asynchronous HttpHandler Method method to complete the Subscribe call /// </summary> /// <param name="result">The IAsyncResult instance that was initialized in the BeginSubscribe call</param> public void EndSubscribe(IAsyncResult result) { this.DebugWriteThreadInfo("EndSubscribe"); CometAsyncResult cometAsyncResult = result as CometAsyncResult; if (cometAsyncResult != null) { try { // get the messages CometMessage[] messages = cometAsyncResult.CometMessages; // serialize the messages // back to the client if (messages != null && messages.Length > 0) { List<Type> knownTypes = new List<Type>(); foreach (CometMessage message in messages) { if (message.Contents != null) { Type knownType = message.Contents.GetType(); if (!knownTypes.Contains(knownType)) { knownTypes.Add(knownType); } } } DataContractJsonSerializer serializer = new DataContractJsonSerializer(messages.GetType(), knownTypes); serializer.WriteObject(((CometAsyncResult)result).Context.Response.OutputStream, messages); } } catch (Exception ex) { // write the error out?? this.WriteErrorToResponse(((CometAsyncResult)result).Context, ex.Message); } } } /// <summary> /// Send a message to a specific client /// </summary> /// <param name="clientPublicToken">The public token of the client</param> /// <param name="name">The name of the message</param> /// <param name="contents">The contents of the message</param> public void SendMessage(string clientPublicToken, string name, object contents) { this.stateProvider.SendMessage(clientPublicToken, name, contents); } /// <summary> /// Send a message to all clients /// </summary> /// <param name="name">The name of the message</param> /// <param name="contents">The contents of the message</param> public void SendMessage(string name, object contents) { this.stateProvider.SendMessage(name, contents); } /// <summary> /// Gets the ICometStateProvider instance this manager consumes /// </summary> internal ICometStateProvider StateProvider { get { return this.stateProvider; } } /// <summary> /// Register the required javascript for the page /// </summary> /// <param name="page">The page we want to write the scripts to</param> public static void RegisterAspNetCometScripts(Page page) { page.ClientScript.RegisterClientScriptResource(typeof(CometStateManager), "MethodWorx.AspNetComet.Core.Scripts.AspNetComet.js"); } /// <summary> /// Kill an IdleCometClient /// </summary> /// <param name="clientPrivateToken"></param> public void KillIdleCometClient(string clientPrivateToken) { // get the comet client CometClient cometClient = this.stateProvider.GetCometClient(clientPrivateToken); // ok, tmie the clietn out this.stateProvider.KillIdleCometClient(clientPrivateToken); // and fire this.FireIdleClientKilled(cometClient); } public CometClient GetCometClient(string clientPrivateToken) { return this.stateProvider.GetCometClient(clientPrivateToken); } internal void DebugWriteThreadInfo(string message) { int workerAvailable = 0; int completionPortAvailable = 0; ThreadPool.GetAvailableThreads(out workerAvailable, out completionPortAvailable); Debug.WriteLine(string.Format("{0}: {1} {2} out of {3}/{4}", message, Thread.CurrentThread.IsThreadPoolThread, Thread.CurrentThread.ManagedThreadId, workerAvailable, completionPortAvailable)); } internal void FireClientInitialized(CometClient cometClient) { if (this.ClientInitialized != null) this.ClientInitialized(this, new CometClientEventArgs(cometClient)); } internal void FireIdleClientKilled(CometClient cometClient) { if (this.IdleClientKilled != null) this.IdleClientKilled(this, new CometClientEventArgs(cometClient)); } internal void FireClientSubscribed(CometClient cometClient) { if (this.ClientSubscribed != null) this.ClientSubscribed(this, new CometClientEventArgs(cometClient)); } private void WriteErrorToResponse(HttpContext context, string message) { // // ok, we have had an error so we have to return it CometMessage errorMessage = new CometMessage(); errorMessage.Name = "aspNetComet.error"; errorMessage.MessageId = 0; errorMessage.Contents = message; CometMessage[] messages = new CometMessage[] { errorMessage }; DataContractJsonSerializer serializer = new DataContractJsonSerializer(messages.GetType()); serializer.WriteObject(context.Response.OutputStream, messages); context.Response.End(); } } }
CometClientEventHandler.cs：
CometClientEventHandler.cs负责事件的广播。不需要有太多修改。
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MethodWorx.AspNetComet.Core { /// <summary> /// Delegate used in events that reference a CometClient /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// <returns></returns> public delegate void CometClientEventHandler(object sender, CometClientEventArgs args); //使用代理来完成事件操作和广播 /// <summary> /// Class CometClientEventArgs /// /// Used as an EventArgs parameter to CometClientEventHandler /// </summary> public class CometClientEventArgs : EventArgs { private CometClient cometClient; /// <summary> /// Construct a new instance of a CometClientEventArgs class /// </summary> /// <param name="cometClient"></param> public CometClientEventArgs(CometClient cometClient) { // setup the member this.cometClient = cometClient; } /// <summary> /// Gets the CometClient referenced in these EventArgs /// </summary> public CometClient CometClient { get { return this.cometClient; } } } }
总结：
至此COMET核心的框架全部构建完成，由于身体原因再加上出于工作进度上的考虑，下一篇随笔将进入应用环节，同时为大家准备了相应的应用范例。
ps:过年了，但是因为重感冒原因一直没有休息好，本来过年应该是一件放松的事情，不知道园子里的同志们都过得怎样。希望大家在新的一年里，身体健康，事业有成。
