IX.Guaranteed 1.0.0

IX.Guaranteed

A small .NET library providing simple thread-safe collection implementations.

Overview

IX.Guaranteed includes safe concurrent wrappers over common collection types:

• ThreadSafeDictionary<TKey, TValue>
• ThreadSafeList<T>
• ThreadSafeQueue<T>
• ThreadSafeStack<T>
• ThreadSafeEnumerator<T>

Each collection synchronizes access so multiple readers can safely enumerate or inspect the data while writes are protected.

Features

• ThreadSafeDictionary<TKey, TValue>

  • Implements IDictionary<TKey, TValue> and IDisposable
  • Supports thread-safe add, remove, contains, indexer access, and snapshots for Keys and Values

• ThreadSafeList<T>

  • Implements IList<T> and IDisposable
  • Provides safe add, remove, insert, indexer access, enumeration, and clear operations

• ThreadSafeQueue<T>

  • Implements IEnumerable<T> and IDisposable
  • Supports Enqueue, Dequeue, Peek, TryDequeue, TryPeek, and thread-safe enumeration

• ThreadSafeStack<T>

  • Implements IEnumerable<T> and IDisposable
  • Supports Push, Pop, Peek, TryPop, TryPeek, ToArray, and thread-safe enumeration

• ThreadSafeEnumerator<T>

  • Holds a read lock for the duration of enumeration
  • Used internally by the collection wrappers to safely iterate while protecting concurrent access

Usage

using IX.Guaranteed.Collections;

var list = new ThreadSafeList<int>();
list.Add(1);
list.Add(2);

foreach (var item in list)
{
    Console.WriteLine(item);
}

var queue = new ThreadSafeQueue<string>();
queue.Enqueue("first");
queue.Enqueue("second");

if (queue.TryDequeue(out var value))
{
    Console.WriteLine(value);
}

var dictionary = new ThreadSafeDictionary<string, int>();
dictionary["one"] = 1;

if (dictionary.TryGetValue("one", out var result))
{
    Console.WriteLine(result);
}

Notes

• The collection implementations are designed to make common operations thread-safe using locks.
• ThreadSafeList<T>, ThreadSafeDictionary<TKey, TValue>, ThreadSafeQueue<T>, and ThreadSafeStack<T> are disposable and should be disposed when no longer needed.
• Enumeration is safe because ThreadSafeEnumerator<T> acquires a read lock for the lifetime of the enumeration.

Project

The library is intended as a lightweight, guaranteed thread-safe collection utility for .NET applications.

AI notice

The code in this project has been created with the use of local AI models. No cloud-based AI models have been used.