DCTekSolutions.CycleKit 1.0.1

CycleKit

CycleKit provides a powerful, thread-safe queue that cycles endlessly through items.
Perfect for round-robin processing, rotating playlists, or any scenario where looping through a fixed set of items is needed.

Free to use for personal and commercial projects. This package is closed source.

Features

• Thread-safe cycling queue (ConcurrentLoopingQueue<T>)
• Supports both synchronous and asynchronous operations
• Can be used with or without async/await
• Optional Try pattern for non-throwing access
• Supports resetting, peeking, and bounded iteration

🚀 Usage Examples

1. Sync Example – Load Balancing Across Servers

public class ServerNode
{
    public string Hostname { get; init; }
    public bool IsOnline { get; set; }

    public void HandleRequest(string request)
    {
        Console.WriteLine($"{Hostname} processing: {request}");
    }
}

// Setup the pool
var nodes = new List<ServerNode>
{
    new() { Hostname = "api-node-1", IsOnline = true },
    new() { Hostname = "api-node-2", IsOnline = true },
    new() { Hostname = "api-node-3", IsOnline = true }
};

var queue = new ConcurrentLoopingQueue<ServerNode>(nodes);

// Simulate incoming requests
for (int i = 0; i < 10; i++)
{
    if (queue.TryNext(out var server) && server.IsOnline)
    {
        server.HandleRequest($"Request #{i + 1}");
    }
}

2. Async Example – Distributed Worker Job Assignment

public class Worker
{
    public string Id { get; init; }

    public async Task ProcessJobAsync(string job)
    {
        Console.WriteLine($"[{Id}] started: {job}");
        await Task.Delay(250); // simulate work
        Console.WriteLine($"[{Id}] finished: {job}");
    }
}

var workers = new List<Worker>
{
    new() { Id = "Worker-A" },
    new() { Id = "Worker-B" },
    new() { Id = "Worker-C" }
};

var workerQueue = new ConcurrentLoopingQueue<Worker>(workers);

// Simulate async job dispatch
var jobTasks = new List<Task>();
for (int i = 0; i < 9; i++)
{
    string job = $"Job-{i + 1}";
    var worker = await workerQueue.NextAsync();
    jobTasks.Add(worker.ProcessJobAsync(job));
}

await Task.WhenAll(jobTasks);

3. TryGet / TryRemove / Reset Example

// Try to find a server by name
if (queue.TryGet(s => s.Hostname == "api-node-2", out var targetNode))
{
    Console.WriteLine($"Found: {targetNode.Hostname}");
}

// Remove an offline server
queue.TryRemove(targetNode);

// Reset queue to start at beginning
queue.TryReset();

🔄 Why CycleKit?

• Predictable round-robin behavior
• No memory reallocation from cycling
• Built-in safety for multi-threaded environments
• Async + Sync access without duplication
• Ideal for routing, dispatching, retries, playback, and carousel logic

🧠 Pro Tip: Combine with SafeInvoker for Thread Safety

If you're using ConcurrentLoopingQueue<T> in a WPF UI context, pair it with DCTekSolutions.SafeInvoker:

public class MyViewModel : DispatcherObject
{
    private readonly IConcurrentLoopingQueue<JobItem> _jobQueue;

    public MyViewModel(IConcurrentLoopingQueue<JobItem> jobQueue)
    {
        _jobQueue = jobQueue;
    }

    [SafeInvokeWPF]
    public void ScheduleJob()
    {
        if (_jobQueue.TryNext(out var job))
        {
            // This safely runs on the UI thread
            ProcessJob(job);
        }
    }
}

Or use the SafeInvoke extension directly:

this.SafeInvoke(vm =>
{
    if (_jobQueue.TryNext(out var job))
        vm.Execute(job);
});

SafeInvoker ensures method calls that interact with DispatcherObject are executed safely on the UI thread—especially important when consuming CycleKit queues in ViewModels.