public void CanRunMultipleQueueJobs()
{
const int jobCount = 5;
const int workItemCount = 1000;
var metrics = new InMemoryMetricsClient();
metrics.StartDisplayingStats(TimeSpan.FromMilliseconds(100), _writer);
var queues = new List<RedisQueue<SampleQueueWorkItem>>();
for (int i = 0; i < jobCount; i++)
{
var q = new RedisQueue<SampleQueueWorkItem>(SharedConnection.GetMuxer(), retries: 3, retryDelay: TimeSpan.FromSeconds(1));
q.AttachBehavior(new MetricsQueueBehavior<SampleQueueWorkItem>(metrics, "test"));
queues.Add(q);
}
Task.Run(() =>
{
Parallel.For(0, workItemCount, i => {
var queue = queues[RandomData.GetInt(0, 4)];
queue.Enqueue(new SampleQueueWorkItem { Created = DateTime.Now, Path = RandomData.GetString() });
});
});
Parallel.For(0, jobCount, index =>
{
var queue = queues[index];
var job = new SampleQueueJob(queue, metrics);
job.RunUntilEmpty();
});
metrics.DisplayStats(_writer);
}
public void ProcessInbox()
{
var redis = new Redis(keyNameSpace: "RedisQueueTests");
var queue = new RedisQueue <string>(redis, "CouldSendAndReceiveMessages", timeout: 5000);
const int n = 10000;
var sw = new Stopwatch();
sw.Start();
var consumer = Task.Run(async() => {
var c = 0;
while (true)
{
var message = await queue.TryReceiveMessage();
c++;
if (c % 10000 == 0)
{
Console.WriteLine(c);
}
//if (message.OK) { Console.WriteLine(message.Value); }
if (message.Ok)
{
await queue.TryDeleteMessage(message.DeleteHandle);
}
}
});
consumer.Wait();
sw.Stop();
Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds}");
//Thread.Sleep(2000);
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true)
{
var queue = new RedisQueue <SimpleWorkItem>(SharedConnection.GetMuxer(), workItemTimeout: workItemTimeout, retries: retries, retryDelay: retryDelay, deadLetterMaxItems: deadLetterMaxItems, runMaintenanceTasks: runQueueMaintenance);
Logger.Debug().Message($"Queue Id: {queue.QueueId}").Write();
return(queue);
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null, int deadLetterMaxItems = 100)
{
var queue = new RedisQueue <SimpleWorkItem>(SharedConnection.GetMuxer(), workItemTimeout: workItemTimeout, retries: retries, retryDelay: retryDelay, deadLetterMaxItems: deadLetterMaxItems);
Debug.WriteLine(String.Format("Queue Id: {0}", queue.QueueId));
return(queue);
}
public override IServiceProvider Bootstrap()
{
var container = new Container();
container.Options.AllowOverridingRegistrations = true;
container.Register <IAmADependency, MyDependency>();
var muxer = ConnectionMultiplexer.Connect("localhost");
container.RegisterSingleton(muxer);
var q1 = new RedisQueue <PingRequest>(muxer);
var q2 = new RedisQueue <PingRequest>(muxer);
container.RegisterSingleton <IQueue <PingRequest> >(() => q2);
Task.Run(async() => {
var startDate = DateTime.Now;
while (startDate.AddSeconds(30) > DateTime.Now)
{
Console.WriteLine("Enqueueing ping.");
await q1.EnqueueAsync(new PingRequest {
Data = "Hi"
}).AnyContext();
await Task.Delay(RandomData.GetInt(100, 1000)).AnyContext();
}
}).AnyContext();
return(container);
}
private static void Queue()
{
var redis = new Redis(keyNameSpace: "RedisQueueTests");
var queue = new RedisQueue <string>(redis, "CouldSendAndReceiveMessages", timeout: 5000);
const int n = 10000;
var sw = new Stopwatch();
sw.Start();
var producer1 = Task.Run(async() => {
//await Task.Delay(1000);
for (var i = 0; i < n; i++)
{
await queue.TrySendMessage(i.ToString());
//await queue.TrySendMessage(new String('x', i*1));
//await Task.Delay(50);
}
});
//var producer2 = Task.Run(async () => {
// for (var i = n; i < 2*n; i++) {
// await queue.TrySendMessage(i.ToString());
// //await Task.Delay(50);
// }
//});
var consumer = Task.Run(async() => {
var c = 0;
while (true)
{
//await Task.Delay(100);
QueueReceiveResult <string> message = default(QueueReceiveResult <string>);
try {
message = await queue.TryReceiveMessage();
} catch (Exception e) {
Console.WriteLine(e);
}
c++;
//if (message.OK) { Console.WriteLine(message.Value); }
if (message.Ok)
{
await queue.TryDeleteMessage(message.DeleteHandle);
}
if (message.Ok && c == n)
{
break; // n * 2
}
}
});
producer1.Wait();
//producer2.Wait();
consumer.Wait();
sw.Stop();
Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds}");
queue.Dispose();
//Thread.Sleep(2000);
}
/// <summary>
/// 增量缓存计数
/// </summary>
/// <param name="countType">计数类型</param>
/// <param name="tenantType">租户类型</param>
/// <param name="tenantId">租户ID</param>
/// <param name="value">增量数</param>
/// <returns>增量后数，如果增量数为0时，返回查询的增量数</returns>
private long SetRedisQueue(string countType, string tenantType, string tenantId, long value = 0)
{
var redisQueue = new RedisQueue(_options.GetRedisOptions);
var newValue = redisQueue.GetCount(countType, tenantType, tenantId);
value = redisQueue.ChangeCount(countType, tenantType, tenantId, value);
newValue = newValue == 0 ? value : newValue;
return(newValue);
}
public void RedisQueue_CtorTest()
{
const string name = "defaultQueue";
const int ttl = 0;
RedisQueue q = new RedisQueue(name, ttl);
Assert.That(q.Name, Is.EqualTo(name));
Assert.That(q.TTL, Is.EqualTo(ttl));
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true)
{
var muxer = SharedConnection.GetMuxer();
var queue = new RedisQueue <SimpleWorkItem>(muxer, workItemTimeout: workItemTimeout,
retries: retries, retryDelay: retryDelay, deadLetterMaxItems: deadLetterMaxItems, runMaintenanceTasks: runQueueMaintenance, loggerFactory: Log);
_logger.Debug("Queue Id: {queueId}", queue.QueueId);
return(queue);
}
/// <summary>
///
/// </summary>
/// <param name="page"></param>
/// <param name="size"></param>
/// <returns></returns>
public Task <IEnumerable <SpiderStatistics> > GetSpiderStatisticsListAsync(int page, int size)
{
var redisQueue = new RedisQueue(_options.GetRedisOptions);
var list = redisQueue.Gets <SpiderStatistics>("Count");
list = list.Skip((page - 1) * size).Take(size).ToList();
return(Task.FromResult <IEnumerable <SpiderStatistics> >(list));
}
static void Main ()
{
String hostName = Dns.GetHostName();
Log.Info("Starting .NET Gearman Server v0.5 on host " + hostName);
var redisClient = new RedisClient("localhost");
var redisQueue = new RedisQueue(redisClient);
var jobQueue = new JobQueue(redisQueue);
//var jobQueue = new JobQueue();
new Daemon(jobQueue, hostName);
}
/// <summary>
///
/// </summary>
/// <param name="page"></param>
/// <param name="size"></param>
/// <returns></returns>
public Task <IEnumerable <DownloadStatistics> > GetDownloadStatisticsListAsync(int page, int size)
{
var redisQueue = new RedisQueue(_options.GetRedisOptions);
//队列
var list = redisQueue.Gets <DownloadStatistics>(Const.RedisStatisticsDownload);
list = list.Skip((page - 1) * size).Take(size).ToList();
return(Task.FromResult <IEnumerable <DownloadStatistics> >(list));
}
public void CouldSendAndReceiveMessages()
{
var redis = new Redis(keyNameSpace: "RedisQueueTests");
var queue = new RedisQueue <string>(redis, "CouldSendAndReceiveMessages", timeout: 5000);
const int n = 100000;
var sw = new Stopwatch();
sw.Start();
var producer1 = Task.Run(async() => {
for (var i = 0; i < n; i++)
{
var sendResult = await queue.TrySendMessage(i.ToString());
if (!sendResult.Ok)
{
Assert.Fail("Cannot send a message");
}
//await Task.Delay(50);
}
});
//var producer2 = Task.Run(async () => {
// for (var i = n; i < 2*n; i++) {
// await queue.TrySendMessage(i.ToString());
// //await Task.Delay(50);
// }
//});
var consumer = Task.Run(async() =>
{
var c = 0;
while (true)
{
var message = await queue.TryReceiveMessage();
c++;
//if (message.OK) { Console.WriteLine(message.Value); }
if (message.Ok)
{
await queue.TryDeleteMessage(message.DeleteHandle);
}
if (message.Ok && c == n)
{
break; // n * 2
}
}
});
producer1.Wait();
//producer2.Wait();
consumer.Wait();
sw.Stop();
Console.WriteLine($"Elapsed: {sw.ElapsedMilliseconds}");
//Thread.Sleep(2000);
}
public RedisQueueConsumer(IInterfacePresenter interfacePresenter, string redisQueueName)
{
var server = "127.0.0.1";
int port = 6379;
int redisDatabase = 10;
_redisQueue = new RedisQueue(server, port, redisDatabase);
_interfacePresenter = interfacePresenter;
_redisQueueName = redisQueueName;
}
protected override IQueue<SimpleWorkItem> GetQueue(int retries = 1, TimeSpan? workItemTimeout = null, TimeSpan? retryDelay = null) {
//if (!Settings.Current.UseAzureServiceBus)
// return;
if (_muxer == null)
_muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
var queue = new RedisQueue<SimpleWorkItem>(_muxer, workItemTimeout: workItemTimeout, retries: retries, retryDelay: retryDelay);
Debug.WriteLine(String.Format("Queue Id: {0}", queue.QueueId));
return queue;
}
static void Main()
{
String hostName = Dns.GetHostName();
Log.Info("Starting .NET Gearman Server v0.5 on host " + hostName);
var redisClient = new RedisClient("localhost");
var redisQueue = new RedisQueue(redisClient);
var jobQueue = new JobQueue(redisQueue);
//var jobQueue = new JobQueue();
new Daemon(jobQueue, hostName);
}
public void Low_Level_Transport_Test()
{
var clientManager = new PooledRedisClientManager();
var messageMapper = new MessageMapper();
messageMapper.Initialize(new[] { typeof(TestMessage), typeof(TestEvent) });
var sendAddress = Address.Parse("lowlevel@localhost");
var queue = new RedisQueue(new JsonSerializer(), clientManager, new QueueKeyNameProvider(true));
queue.Init(sendAddress, true);
var nsbSerializer = new JsonMessageSerializer(messageMapper);
var message = new TestMessage()
{
Name = "Bob"
};
var transportMessage = new TransportMessage()
{
MessageIntent = MessageIntentEnum.Send
};
using (var ms = new MemoryStream())
{
nsbSerializer.Serialize(new [] { message }, ms);
transportMessage.Body = ms.ToArray();
}
using (var tran = new TransactionScope())
{
for (int x = 0; x < 2; x++)
{
queue.Send(transportMessage, sendAddress);
}
tran.Complete();
}
for (int x = 0; x < 2; x++)
{
if (queue.HasMessage())
{
using (var tran = new TransactionScope())
{
queue.Receive();
tran.Complete();
}
}
}
}
public void RedisProducer_PublishToIQueueTest()
{
const string message = "hee hee hee";
var queue = new RedisQueue("againNotARealQueue", 0);
var producer = _objectFactory.GetObject <IProducer>(ProducerName);
producer.Publish(queue, message);
var connection = (RedisConnection)producer.Connection;
var actualMessage = connection.Multiplexer.GetDatabase().ListLeftPop(queue.Name);
Assert.That(actualMessage.ToString(), Is.EqualTo(message));
}
public async Task CanDisposeCacheAndQueueAndReceiveSubscribedMessages()
{
var muxer = SharedConnection.GetMuxer();
var messageBus1 = new RedisMessageBus(new RedisMessageBusOptions {
Subscriber = muxer.GetSubscriber(), Topic = "test-messages", LoggerFactory = Log
});
var cache = new RedisCacheClient(new RedisCacheClientOptions {
ConnectionMultiplexer = muxer
});
Assert.NotNull(cache);
var queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem> {
ConnectionMultiplexer = muxer,
LoggerFactory = Log
});
Assert.NotNull(queue);
using (messageBus1) {
using (cache) {
using (queue) {
await cache.SetAsync("test", "test", TimeSpan.FromSeconds(10));
await queue.DequeueAsync(new CancellationToken(true));
var countdown = new AsyncCountdownEvent(2);
await messageBus1.SubscribeAsync <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
countdown.Signal();
});
await messageBus1.PublishAsync(new SimpleMessageA { Data = "Hello" });
await countdown.WaitAsync(TimeSpan.FromSeconds(2));
Assert.Equal(1, countdown.CurrentCount);
cache.Dispose();
queue.Dispose();
await messageBus1.PublishAsync(new SimpleMessageA { Data = "Hello" });
await countdown.WaitAsync(TimeSpan.FromSeconds(2));
Assert.Equal(0, countdown.CurrentCount);
}
}
}
}
public IQueue <T> CreateQueue <T>(string name) where T : class
{
var logger = _loggerFactory.CreateLogger(GetType());
logger.LogInformation("Create new Redis Queue {Name} for {Type}", name, typeof(T).Name);
var queue = new RedisQueue <T>(new RedisQueueOptions <T>()
{
LoggerFactory = _loggerFactory,
Name = name,
ConnectionMultiplexer = _connection
});
return(queue);
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true)
{
var queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem> {
ConnectionMultiplexer = SharedConnection.GetMuxer(),
Retries = retries,
RetryDelay = retryDelay.GetValueOrDefault(TimeSpan.FromMinutes(1)),
DeadLetterMaxItems = deadLetterMaxItems,
WorkItemTimeout = workItemTimeout.GetValueOrDefault(TimeSpan.FromMinutes(5)),
RunMaintenanceTasks = runQueueMaintenance,
LoggerFactory = Log
});
_logger.LogDebug("Queue Id: {queueId}", queue.QueueId);
return(queue);
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null)
{
//if (!Settings.Current.UseAzureServiceBus)
// return;
if (_muxer == null)
{
_muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionInfo.ToString());
}
var queue = new RedisQueue <SimpleWorkItem>(_muxer, workItemTimeout: workItemTimeout, retries: retries, retryDelay: retryDelay);
Debug.WriteLine(String.Format("Queue Id: {0}", queue.QueueId));
return(queue);
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true)
{
var queue = new RedisQueue <SimpleWorkItem>(o => o
.ConnectionMultiplexer(SharedConnection.GetMuxer())
.Retries(retries)
.RetryDelay(retryDelay.GetValueOrDefault(TimeSpan.FromMinutes(1)))
.DeadLetterMaxItems(deadLetterMaxItems)
.WorkItemTimeout(workItemTimeout.GetValueOrDefault(TimeSpan.FromMinutes(5)))
.RunMaintenanceTasks(runQueueMaintenance)
.LoggerFactory(Log)
);
_logger.LogDebug("Queue Id: {queueId}", queue.QueueId);
return(queue);
}
protected override IQueue <SimpleWorkItem> GetQueue(int retries = 1, TimeSpan?workItemTimeout = null, TimeSpan?retryDelay = null)
{
if (Settings.Current.RedisConnectionString == null)
{
return(null);
}
if (_muxer == null)
{
_muxer = ConnectionMultiplexer.Connect(Settings.Current.RedisConnectionString);
}
var queue = new RedisQueue <SimpleWorkItem>(_muxer, workItemTimeout: workItemTimeout, retries: retries, retryDelay: retryDelay);
Debug.WriteLine(String.Format("Queue Id: {0}", queue.QueueId));
return(queue);
}
private IQueue <T> CreateQueue <T>(bool allQueuesTheSameName = true) where T : class
{
var name = typeof(T).FullName.Trim().Replace(".", string.Empty).ToLower();
if (allQueuesTheSameName)
{
name = "cmd";
}
var queue = new RedisQueue <T>(o => o
.ConnectionMultiplexer(SharedConnection.GetMuxer())
.Name(name)
.LoggerFactory(Log)
);
_logger.LogDebug("Queue Id: {queueId}", queue.QueueId);
return(queue);
}
public async void Start2()
{
IConnectionMultiplexer connectionMultiplexer = ConnectionMultiplexer.Connect("47.94.140.80:6379");
//ISubscriber subscriber = connectionMultiplexer.GetSubscriber();
IQueue <SimpleWorkItem> queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem>()
{
ConnectionMultiplexer = (ConnectionMultiplexer)connectionMultiplexer
});//Queue<SimpleWorkItem>(new InMemoryQueueOptions<SimpleWorkItem>());
var workItem2 = await queue.DequeueAsync();
workItem2.MarkCompleted();
Console.WriteLine($"queue333:{workItem2.Value.Data}");
}
public async void Start1()
{
IConnectionMultiplexer connectionMultiplexer = ConnectionMultiplexer.Connect("47.94.140.80:6379");
//ISubscriber subscriber = connectionMultiplexer.GetSubscriber();
IQueue <SimpleWorkItem> queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem>()
{
ConnectionMultiplexer = (ConnectionMultiplexer)connectionMultiplexer
});//Queue<SimpleWorkItem>(new InMemoryQueueOptions<SimpleWorkItem>());
await queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello"
});
//var workItem = await queue.DequeueAsync();
//Console.WriteLine($"queue:{workItem.Value.Data}");
}
public void CanRunQueueJob()
{
const int workItemCount = 10000;
var metrics = new InMemoryMetricsClient();
var queue = new RedisQueue<SampleQueueWorkItem>(SharedConnection.GetMuxer(), null, null, 0, TimeSpan.Zero);
queue.AttachBehavior(new MetricsQueueBehavior<SampleQueueWorkItem>(metrics, "test"));
metrics.StartDisplayingStats(TimeSpan.FromMilliseconds(100), _writer);
Task.Factory.StartNew(() => {
Parallel.For(0, workItemCount, i => {
queue.Enqueue(new SampleQueueWorkItem { Created = DateTime.Now, Path = "somepath" + i });
});
});
var job = new SampleQueueJob(queue, metrics);
job.RunUntilEmpty();
metrics.DisplayStats(_writer);
Assert.Equal(0, queue.GetQueueStats().Queued);
}
public async void Start1()
{
IConnectionMultiplexer connectionMultiplexer = ConnectionMultiplexer.Connect("47.94.140.80:6379");
//ISubscriber subscriber = connectionMultiplexer.GetSubscriber();
IQueue <SimpleWorkItem> queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem>()
{
ConnectionMultiplexer = (ConnectionMultiplexer)connectionMultiplexer
});//Queue<SimpleWorkItem>(new InMemoryQueueOptions<SimpleWorkItem>());
for (int i = 0; i < 100; i++)
{
await queue.EnqueueAsync(new SimpleWorkItem
{
Data = $"Hello {i} " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")
});
}
}
public void CanRunQueueJob()
{
const int workItemCount = 10000;
var metrics = new InMemoryMetricsClient();
var queue = new RedisQueue <SampleQueueWorkItem>(SharedConnection.GetMuxer(), null, null, 0, TimeSpan.Zero, metrics: metrics);
Task.Factory.StartNew(() => {
Parallel.For(0, workItemCount, i => {
queue.Enqueue(new SampleQueueWorkItem {
Created = DateTime.Now, Path = "somepath" + i
});
});
});
var job = new SampleQueueJob(queue, metrics);
job.RunUntilEmpty();
metrics.DisplayStats();
Assert.Equal(0, queue.GetQueueCount());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddCors(pOptions => pOptions.AddPolicy("AllowAll", pBuilder =>
{
pBuilder.AllowAnyHeader()
.AllowAnyMethod()
.AllowAnyOrigin();
}));
IConfiguration config = new ConfigurationBuilder()
.SetBasePath(AppDomain.CurrentDomain.BaseDirectory)
.AddJsonFile("config.json")
//.AddEnvironmentVariables("redis_")
.Build();
IRedisQueue redisQueue = new RedisQueue(config);
services.AddSingleton(config);
services.AddSingleton(redisQueue);
}
/// <summary>
/// Start
/// </summary>
public bool Start()
{
var json = ApiHostConfig.QueryMessage.GetStringFromUrl();
var result = JsonConvert.DeserializeObject <ServerResponse <List <Message> > >(json);
//清除队列
_baseRedisServiceManager.RemoveList("QueueScheduling");
foreach (var item in result.Result)
{
var queue = new RedisQueue <Message>
{
Key = "QueueScheduling",
Entity = item
};
_baseRedisServiceManager.AddQueue(queue);
}
//新进程
Task.Factory.StartNew(DelayStart, _cancelTokenSource.Token);
return(true);
}
public override IServiceProvider Bootstrap() {
var container = new Container();
container.Options.AllowOverridingRegistrations = true;
container.Register<IAmADependency, MyDependency>();
var muxer = ConnectionMultiplexer.Connect("localhost");
container.RegisterSingleton(muxer);
var q1 = new RedisQueue<PingRequest>(muxer);
var q2 = new RedisQueue<PingRequest>(muxer);
container.RegisterSingleton<IQueue<PingRequest>>(() => q2);
Task.Run(async () => {
var startDate = DateTime.Now;
while (startDate.AddSeconds(30) > DateTime.Now) {
Console.WriteLine("Enqueueing ping.");
await q1.EnqueueAsync(new PingRequest { Data = "Hi" }).AnyContext();
await Task.Delay(RandomData.GetInt(100, 1000)).AnyContext();
}
}).AnyContext();
return container;
}
//var workItem = await queue.DequeueAsync();
//Console.WriteLine($"queue:{workItem.Value.Data}");
public async void Start2()
{
IConnectionMultiplexer connectionMultiplexer = ConnectionMultiplexer.Connect("47.94.140.80:6379");
//ISubscriber subscriber = connectionMultiplexer.GetSubscriber();
IQueue <SimpleWorkItem> queue = new RedisQueue <SimpleWorkItem>(new RedisQueueOptions <SimpleWorkItem>()
{
ConnectionMultiplexer = (ConnectionMultiplexer)connectionMultiplexer
});//Queue<SimpleWorkItem>(new InMemoryQueueOptions<SimpleWorkItem>());
// var DeadletterItems= await queue.GetDeadletterItemsAsync();
// var workItem = await queue.DequeueAsync();
//Task.Factory.StartNew( async () =>
//{
// Thread.Sleep(1000);
// Console.WriteLine($"is work complete? :{workItem.IsCompleted}");
// Console.WriteLine($"queue222:{workItem.Value.Data}");
// await workItem.CompleteAsync();
//});
for (int i = 0; i < 10; i++)
{
var workItem2 = await queue.DequeueAsync();
if (workItem2 != null)
{
Console.WriteLine($"queue333:{workItem2.Value.Data}");
}
}
Console.WriteLine($" end of this time");
}
/// <summary>
/// AddQueue
/// </summary>
/// <param name="entity"></param>
public void AddQueue <T>(RedisQueue <T> entity) where T : class
{
RedisClientManager
.AddItemToList(entity.Key, entity.EntityData);
}
protected override IQueue<SimpleWorkItem> GetQueue(int retries = 1, TimeSpan? workItemTimeout = null, TimeSpan? retryDelay = null, int deadLetterMaxItems = 100, bool runQueueMaintenance = true) {
var queue = new RedisQueue<SimpleWorkItem>(SharedConnection.GetMuxer(), workItemTimeout: workItemTimeout,
retries: retries, retryDelay: retryDelay, deadLetterMaxItems: deadLetterMaxItems, runMaintenanceTasks: runQueueMaintenance, loggerFactory: Log);
_logger.Debug("Queue Id: {queueId}", queue.QueueId);
return queue;
}