NTDLS.Semaphore 1.3.2

There is a newer version of this package available.
See the version list below for details.
dotnet add package NTDLS.Semaphore --version 1.3.2                
NuGet\Install-Package NTDLS.Semaphore -Version 1.3.2                
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="NTDLS.Semaphore" Version="1.3.2" />                
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add NTDLS.Semaphore --version 1.3.2                
#r "nuget: NTDLS.Semaphore, 1.3.2"                
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install NTDLS.Semaphore as a Cake Addin
#addin nuget:?package=NTDLS.Semaphore&version=1.3.2

// Install NTDLS.Semaphore as a Cake Tool
#tool nuget:?package=NTDLS.Semaphore&version=1.3.2                

NTDLS.Semaphore

Provides various classes for to ensure sequential mult-threaded access to variables or sections of code.

Auto-release CriticalResource using inline execution example:

An example using a CriticalResource to envelope a variable and protect it from parallel execution, Note that there are nullable and nonnullable counterpars and also template/generics of each method to allow you to return various types from the delegate execution.

public class Car
{
    public string? Name { get; set; }
    public int NumerOhWheels { get; set; }
}

public CriticalResource<List<Car>> Cars { get; set; } = new();

public void Add(Car car)
{
    Cars.Use((obj) => obj.Add(car));
}

public Car? GetByName(string name)
{
    return Cars.Use((obj) => obj.Where(o=>o.Name == name).FirstOrDefault());
}

public bool TryAdd(Car car)
{
    //Since TryUse<T> can return values, we have to pass the result of the try out though a variable.
    Cars.TryUse(out bool wasLockObtained, (obj) => obj.Add(car));
    return wasLockObtained;
}

public bool TryAdd(Car car, int timeout)
{
    //Since TryUse<T> can return values, we have to pass the result of the try out though a variable.
    Cars.TryUse(out bool wasLockObtained, timeout, (obj) => obj.Add(car));
    return wasLockObtained;
}

Auto-release CriticalSection example:

An example using a CriticalSection to protect a portion of code from parallel execution,

public CriticalSection SyncObjectLock { get; } = new();

private int _value;

public int Value
{
    get
    {
        using (SyncObjectLock.Lock())
        {
            return _value;
        }
    }
    set
    {
        using (SyncObjectLock.Lock())
        {
            _value = value;
        }
    }
}

Auto-release CriticalSection using inline execution example:

An example using a CriticalSection to protect a portion of code from parallel execution,

public CriticalSection SyncObjectLock { get; } = new();

private int _value;

public int Value
{
    get
    {
        return SyncObjectLock.Use(() => _value);
    }
    set
    {
        SyncObjectLock.Use(() => _value = value);
    }
}

Multi auto-release CriticalResource using inline execution example:

An example using a CriticalResource to envelope a variable and protect it and others from parallel execution,

public class Car
{
    public string? Name { get; set; }
    public int NumerOhWheels { get; set; }
}

public CriticalResource<List<Car>> Cars { get; set; } = new();
public CriticalSection OtherLock1 { get; set; } = new();
public CriticalSection OtherLock2 { get; set; } = new();
public CriticalSection OtherLock3 { get; set; } = new();

public void Add(Car car)
{
    Cars.Use((obj) => obj.Add(car));
}

public Car? GetByName(string name)
{
    return Cars.Use((obj) => obj.Where(o => o.Name == name).FirstOrDefault());
}

public bool TryAdd(Car car)
{
    //Since TryUse<T> can return values, we have to pass the result of the try out though a variable.
    Cars.TryUse(out bool wasLockObtained, (obj) => obj.Add(car));
    return wasLockObtained;
}

public bool TryAdd(Car car, int timeout)
{
    //Since TryUse<T> can return values, we have to pass the result of the try out though a variable.
    Cars.TryUse(out bool wasLockObtained, timeout, (obj) => obj.Add(car));
    return wasLockObtained;
}

public Car? TryGet(string name, int timeout)
{
    return Cars.TryUseAll(new[] { OtherLock1, OtherLock2, OtherLock3 }, timeout, out bool wasLockObtained, (obj) =>
    {
        //We only get here if we are able to lock "Cars" and OtherLock1, OtherLock2 and OtherLock3
        return obj.Where(o => o.Name == name).FirstOrDefault();
    });
}
Product Compatible and additional computed target framework versions.
.NET net7.0 is compatible.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.
  • net7.0

    • No dependencies.

NuGet packages (5)

Showing the top 5 NuGet packages that depend on NTDLS.Semaphore:

Package Downloads
NTDLS.ReliableMessaging

Simple, fast, secure and lightweight event or convention-based RPC implementation.

NTDLS.DelegateThreadPooling

Very high-performance active thread pool where work items can be queued as delegate functions. Allows you to easily enqueue infinite FIFO worker items or enforce queue size, wait on collections of those items to complete, and total control over the pool size. Also allows for multiple pools, so that different workloads do not interfere with one another.

NTDLS.FastMemoryCache

Provides fast and easy to use thread-safe partitioned memory cache for .net that helps manage the maximum size and track performance.

NTDLS.StreamFraming

Stream wrapper (typically TCPIP/NetworkStream) that enables reliable framing, compression, optional encryption, two-way communication, and support for query/reply. Messages are guaranteed to be received in their entirety and in the order which they were sent.

NTDLS.DatagramMessaging

Set of classes and extensions methods that allow you to send/receive UDP packets with ease. It handles corruption checks, concatenation, fragmentation, serialization and adds compression.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
3.4.9 356 10/22/2024
3.4.8 113 10/22/2024
3.4.7 110 10/22/2024
3.4.6 105 10/22/2024
3.4.5 171 10/13/2024
3.4.4 142 10/13/2024
3.4.3 138 10/13/2024
3.4.2 929 8/25/2024
3.4.1 210 8/24/2024
3.4.0 128 8/24/2024
3.3.3 297 8/13/2024
3.3.2 599 7/31/2024
3.3.1 490 6/20/2024
3.3.0 2,444 1/22/2024
3.2.0 101 1/22/2024
3.1.1 232 1/4/2024
3.1.0 362 11/16/2023
3.0.0 102 11/15/2023
2.2.5 328 11/15/2023
2.2.4 146 11/14/2023
2.2.3 123 11/14/2023
2.2.2 316 11/9/2023
2.2.1 92 11/9/2023
2.2.0 132 11/9/2023
2.1.0 114 11/9/2023
2.0.0 113 11/9/2023
1.5.2 107 11/9/2023
1.5.1 377 10/17/2023
1.5.0 223 10/12/2023
1.4.0 141 10/12/2023
1.3.2 187 10/10/2023

Removed protobuf reference.