Provides a basic queue data structure with enqueue and dequeue operations for .NET.
$ dotnet add package SimpleQueue.NETSimpleQueue is a lightweight library for managing message queues in .NET applications. It provides a straightforward and flexible way to send, receive, and process messages asynchronously. The library supports handling different event types and integrates seamlessly with dependency injection and logging in ASP.NET Core applications.
Install the SimpleQueue package via NuGet:
dotnet add package SimpleQueue.NET
Create a class that represents the message you want to send. The message class should inherit from the BaseMessage base class and define any properties that are required for the message.
using SimpleQueue;
public class MyMessage : BaseMessage
{
public string Content { get; set; }
}
Create a class that implements the IMessageHandler<T> interface, where T is the message type. Implement the HandleAddedAsync, HandleUpdatedAsync, HandleDeletedAsync methods to define how the message should be processed.
using SimpleQueue;
using System.Threading.Tasks;
public class MyMessageHandler : MessageConsumerBase<MyMessage>
{
public override Task HandleAddedAsync(MyMessage message)
{
// Handle the added message
Console.WriteLine($"Added: {message.Content}");
return Task.CompletedTask;
}
public override Task HandleUpdatedAsync(MyMessage message)
{
// Handle the updated message
Console.WriteLine($"Updated: {message.Content}");
return Task.CompletedTask;
}
public override Task HandleDeletedAsync(MyMessage message)
{
// Handle the deleted message
Console.WriteLine($"Deleted: {message.Content}");
return Task.CompletedTask;
}
}
Implement the IMessageQueue interface for your specific message queue backend.
using SimpleQueue;
using System;
using System.Threading.Tasks;
public class InMemoryMessageQueue<T> : IMessageQueue<T> where T : IMessage
{
private readonly ConcurrentQueue<T> _queue = new();
public void Send(T message, EventTypes eventType)
{
_queue.Enqueue(message);
}
public Task SendAsync(T message, EventTypes eventType)
{
Send(message, eventType);
return Task.CompletedTask;
}
public void Receive(Func<T, Task> handleMessage)
{
Task.Run(async () =>
{
while (true)
{
if (_queue.TryDequeue(out var message))
{
await handleMessage(message);
}
await Task.Delay(100); // Adding a small delay to prevent busy-waiting
}
});
}
public void DeleteQueue()
{
_queue.Clear();
}
public void CloseConnection()
{
}
}
Register the message queue and message handler in the DI container.
using Microsoft.Extensions.DependencyInjection;
using SimpleQueue;
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IMessageQueue<MyMessage>, InMemoryMessageQueue<MyMessage>>();
services.AddSingleton<IMessageHandler<MyMessage>, MyMessageHandler>();
services.AddSingleton<MessageHandler<MyMessage>>();
services.AddHostedService<MessageQueueHostedService<MyMessage>>();
}
}
Run your ASP.NET Core application, and the message queue will start processing messages in the background.
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change. Please make sure to update tests as appropriate.
This project is licensed under the MIT License. See the MIT file for details.