public static void AddQueue(string name)
{
McQueueProperties prop = new McQueueProperties(name);
McQueue rq = McQueue.Create(prop);
QueueManager[mqp.QueueName] = rq;
}
private static void AddQueue(string name)
{
McQueueProperties mqp = new McQueueProperties(name);
McQueue rq = McQueue.Create(mqp);
_QueueHandler[mqp.QueueName] = rq;
}
private static void TransWorker(IQueueItem item)
{
McQueue queue = McQueue.Create(qnmae);
//queue.CommitTrans(item);
queue.AbortTrans(item.ItemId, item.HasAttach);
Console.WriteLine("Commit : {0}", item.ItemId);
}
public void ClearAllItems(string name)
{
McQueue q = RemoteQueueServer.QueueManager[name];
if (q != null)
{
q.ClearQueueItems(QueueItemType.AllItems);
}
}
public DataTable GetQueueItemsTable(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(null);
}
return(Q.GetQueueItemsTable());
}
public IQueueItem[] GetQueueItems(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(null);
}
return(Q.GetQueueItems());
}
//public object ExecuteCommand(string queueName,string commandName, string command, params string[] param)
//{
// McQueue Q = QueueManager[queueName];
// if (Q == null)
// return null;
// return Q.ExecuteCommand(commandName, command, param);
//}
public void SetProperty(string queueName, string propertyName, object propertyValue)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return;
}
Q.SetProperty(propertyName, propertyValue);
}
public object GetProperty(string queueName, string propertyName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(null);
}
return(Q.GetProperty(propertyName));
}
public int MaxCapacity(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(0);
}
return(Q.MaxCapacity);
}
public bool CanQueue(string queueName, uint count)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(false);
}
return(Q.CanQueue(count));
}
internal static void AddQueue(McQueueProperties prop)
{
if (_QueueHandler.ContainsKey(prop.QueueName))
{
return;
}
McQueue rq = McQueue.Create(prop);
_QueueHandler[prop.QueueName] = rq;
}
// Provides an event handler for the ReceiveCompleted event.
private static void MsgReceiveCompleted(IAsyncResult asyncResult)
{
// Connect to the queue.
McQueue queue = McQueue.Create(qnmae);
// End the asynchronous receive operation.
IQueueItem item = queue.EndReceive(asyncResult);
Console.WriteLine("Message received: {0}", item.ItemId);
TransWorker(item);
}
public bool Initilaized(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(false);
}
return(Q.Initilaized);
}
public int Count(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(0);
}
return(Q.Count);
}
public bool IsTrans(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(false);
}
return(Q.IsTrans);
}
static void Main(string[] args)
{
Netlog.Info("test log");
string qtype = "remote";
string queueName = "NC_DEMO";
/*
* RemotingTable rt = new RemotingTable();
* rt.AddTrans("123",new TimeSpan(0,0,30));
* //rt.Push("123", "hello");
*
* TransItem ti= rt.Pop("123");
* Console.WriteLine(ti.ItemState.ToString());
* //rt.Push("123", "hello");
* Console.WriteLine("trans push");
*/
//if (args.Length == 0)
//{
// throw new ArgumentNullException("Invalid argument");
//}
//McQueueProperties prop = new McQueueProperties(queueName);
//prop.CoverMode = CoverMode.FileSystem;
//prop.Server = 0;
//prop.IsTrans = false;
//McQueue queue = McQueue.Create(prop);
if (qtype == "queue")
{
McQueue q = new McQueue("demo");
}
else
{
RemoteQueueInserter qi = new RemoteQueueInserter(args);
while (true)
{
DateTime start = DateTime.Now;
qi.Start(1000);
TimeSpan ts = DateTime.Now.Subtract(start);
Console.WriteLine("Total secondes={0}", ts.TotalSeconds);
Thread.Sleep(2000);
}
}
Console.ReadLine();
}
public string Dequeue(string queueName, Guid ptr)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(null);
}
IQueueItem item = Q.Dequeue(ptr);
return(SerializeItem(item));
}
public string Peek(string queueName, Priority priority)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(null);
}
IQueueItem item = Q.Peek(priority);
return(SerializeItem(item));
}
public string Dequeue(string queueName)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return(null);
}
IQueueItem item = Q.Dequeue();
//Netlog.InfoFormat("Dequeue:{0} item:{1}", DateTime.Now, item.MessageId);
return(SerializeItem(item));
}
public void ReEnqueue(string queueName, string serItem)
{
QueueItem item = QueueItem.Deserialize(serItem);
if (item != null)
{
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return;
}
Q.ReEnqueue(item as IQueueItem);
}
}
public McQueue AddQueue(McQueueProperties mqp)
{
if (_QueueHandler.ContainsKey(mqp.QueueName))
{
//throw new ArgumentException(aqt.QueueName + " allready exists");
return(_QueueHandler[mqp.QueueName]);
}
McQueue rq = new McQueue(mqp);
//rq.ErrorOcurred += new ErrorOcurredEventHandler(rq_ErrorOcurred);
//rq.ReceiveCompleted += new QueueItemEventHandler(rq_ReceiveCompleted);
_QueueHandler[mqp.QueueName] = rq;
return(rq);
}
public void CommitTrans(string queueName, Guid ItemId, bool hasAttach)
{
//QueueItem item = QueueItem.Deserialize(serItem);
//if (item != null)
//{
// QueueManager[queueName].CommitTrans(serItem);
//}
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return;
}
Q.CommitTrans(ItemId, hasAttach);
}
public void Completed(string queueName, Guid ItemId, int status, bool hasAttach)
{
//QueueItem item = QueueItem.Deserialize(serItem);
//if (item != null)
//{
// QueueManager[queueName].Completed(item.ItemId, (ItemState)status);
//}
McQueue Q = QueueManager[queueName];
if (Q == null)
{
return;
}
Q.Completed(ItemId, status, hasAttach);
}
private static void RunAsyncQueue()
{
DateTime start = DateTime.Now;
McQueueProperties prop = new McQueueProperties(qnmae);
//prop.ConnectionString = cnn;
prop.CoverMode = CoverMode.FileSystem;//.ItemsAndLog;
prop.Server = 0;
//prop.Provider = QueueProvider.SqlServer;
prop.IsTrans = true;
McQueue queue = McQueue.Create(prop);
//queue.ReceiveCompleted += new ReceiveCompletedEventHandler(q_DequeueCompleted);
IQueueItem[] items = CreateItems(3, queue);
int count = queue.Count;
Console.WriteLine("start enqueue");
//CreateItems(10,queue);
count = queue.Count;
int index = 0;
Console.WriteLine("count:{0}", count);
queue.Enqueue(items[0]);
queue.Enqueue(items[1]);
queue.Enqueue(items[2]);
//IQueueItem item= queue.Dequeue();
//queue.CommitTrans(item);
while (true)//index < count)
{
queue.BeginReceive(null);
//queue.BeginReceive(TimeSpan.FromSeconds(10.0), 0,
// new AsyncCallback(MsgReceiveCompleted));
index++;
Thread.Sleep(10);
}
TimeSpan ts = DateTime.Now.Subtract(start);
Console.WriteLine("took:{0}", ts.TotalSeconds);
//signal.WaitOne();
}
public void RemoveQueue(string queueName)//IDictionary prop)
{
//McQueueProperties mqp = McQueueProperties.Create(prop);
if (_QueueHandler.ContainsKey(queueName))//mqp.QueueName))
{
_QueueHandler.Remove(queueName);
McQueue.Delete(queueName);
//mqp.RemoveQueue();
}
//if (_QueueHandler.ContainsKey(name))
//{
// //this[name].RemoveQueue(name);
// _QueueHandler.Remove(name);
// McQueueProperties.RemoveFromRegistry(name);
//}
}
public static void RunAsyncQueue()
{
DateTime start = DateTime.Now;
QueueClient client = new QueueClient();
McQueueProperties prop = new McQueueProperties(qnmae);
//prop.ConnectionString = cnn;
//prop.CoverMode = CoverMode.ItemsAndLog;
//prop.Server = 0;
//prop.Provider = QueueProvider.SqlServer;
//prop.IsTrans = true;
queue = McQueue.Create(prop);
//queue.ReceiveCompleted += new ReceiveCompletedEventHandler(q_DequeueCompleted);
Console.WriteLine("start enqueue");
QueueInserter.InsertItems(100, queue);
int count = queue.Count;
Console.WriteLine("count:{0}", count);
QueueListner();
int index = 0;
while (true)//index < count)
{
queue.BeginReceive(null);
//queue.BeginReceive(TimeSpan.FromSeconds(10.0), 0,
// new AsyncCallback(MsgReceiveCompleted));
index++;
Thread.Sleep(10);
}
TimeSpan ts = DateTime.Now.Subtract(start);
Console.WriteLine("took:{0}", ts.TotalSeconds);
//signal.WaitOne();
}
static void q_DequeueCompleted(object sender, ReceiveCompletedEventArgs e)
{
// Connect to the queue.
McQueue mq = (McQueue)sender;
// End the asynchronous receive operation.
IQueueItem item = mq.EndReceive(e.AsyncResult);
Console.WriteLine(item.ItemId.ToString());
TransWorker(item);
//count += 1;
//if (count == 10)
//{
// signal.Set();
//}
//signal.Set();
// Restart the asynchronous receive operation.
//mq.BeginReceive();
}
public static void AddQueue(McQueueProperties prop)
{
McQueue rq = McQueue.Create(prop);
QueueManager[prop.QueueName] = rq;
}
//internal static void LoadQueues()
//{
// McQueueProperties[] props = null;// McQueueProperties.CreateFromRegistry(ServiceConfig.Provider, ServiceConfig.ConnectionString);
// if (props == null)
// return;
// foreach (McQueueProperties p in props)
// {
// AddQueue(p);
// }
// }
public static DataTable QueueItems()
{
return(McQueue.GetAllCoverItems());//ServiceConfig.Provider, ServiceConfig.ConnectionString);
}
