Interlocked.CompareExchange with enum

Question

I'm trying to use Interlocked.CompareExchange with this enum:

public enum State {
    Idle,
    Running,
    //...
}

The following code doesn't compile, but that's what I want do do:

if (Interlocked.CompareExchange(ref state, State.Running, State.Idle) != State.Idle) {
    throw new InvalidOperationException("Unable to run - not idle");
}

Sure I can use a int instead of the enum and use a property:

private int state = (int)State.Idle;
public State { get { return (State)state; } }

Then cast the enums to a int:

if (Interlocked.CompareExchange(ref state, (int)State.Running, (int)State.Idle) !=  (int)State.Idle) {
    throw new InvalidOperationException("Unable to run - not idle");
}

But are there better ways to do this?

What you show (treating it as an `int` and casting) is basically exactly what I do. — Marc Gravell, Aug 21 '13 at 13:24
To be honest it's not really that big a deal. Personally I would just keep it as an `enum` but cast it before you do the exchange. — James, Aug 21 '13 at 13:24
@James you can't do that; the field needs to be `int` to use it as `ref` in the call. You can't cast during a `ref`. — Marc Gravell, Aug 21 '13 at 13:25
@MarcGravell: sorry, just wanted to know if there's more than the shown code... — joe, Aug 21 '13 at 13:27
@MarcGravell I was meaning as a local var (pretty much what the OP has already). — James, Aug 21 '13 at 13:28
Is it possible to change your `enum` to a `class` that uses `static readonly` instances like [here](http://stackoverflow.com/questions/2119714/when-to-use-enums-and-when-to-replace-them-with-a-class-with-static-members)? You can implement the backing integer values as well if necessary. — Chris Sinclair, Aug 21 '13 at 13:38
@James in the example, it is not a local var - it is an instance field — Marc Gravell, Aug 21 '13 at 13:41
@ChrisSinclair: That's indeed a good idea. The only pain here is that I still want to use the enum for the `public State { get; }` property. So I have a enum and some constants in parallel, but that doesn't hurt much. — joe, Aug 21 '13 at 13:53
Out of interest, why not just use `Interlocked.Exchange(ref state, (int)State.Running)` instead? In this code, it would result in the same logic, right? — Neo, Jul 19 '17 at 14:30
@Neo - because the method doesn't have an overload with a generic type constraint of 'struct' or 'unmanaged'. Only reference types work for the generic `Interlocked.Exchange()` overload. Here's a workaround: `Interlocked.Exchange(ref Unsafe.As(ref state), (int) State.Running)`. See my answer below for similar solution to question being asked (i.e. `CompareExchange`) — , Sep 09 '22 at 17:49

score 20 · Answer 1 · 2013-08-21T15:58:18.227

It's possible from IL, and it's possible to create a helper method for this that can be used from C#.

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;

static class CompareExchangeEnumImpl<T>
{
    public delegate T dImpl(ref T location, T value, T comparand);
    public static readonly dImpl Impl = CreateCompareExchangeImpl();

    static dImpl CreateCompareExchangeImpl()
    {
        var underlyingType = Enum.GetUnderlyingType(typeof(T));
        var dynamicMethod = new DynamicMethod(string.Empty, typeof(T), new[] { typeof(T).MakeByRefType(), typeof(T), typeof(T) });
        var ilGenerator = dynamicMethod.GetILGenerator();
        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.Emit(OpCodes.Ldarg_1);
        ilGenerator.Emit(OpCodes.Ldarg_2);
        ilGenerator.Emit(
            OpCodes.Call,
            typeof(Interlocked).GetMethod(
                "CompareExchange",
                BindingFlags.Static | BindingFlags.Public,
                null,
                new[] { underlyingType.MakeByRefType(), underlyingType, underlyingType },
                null));
        ilGenerator.Emit(OpCodes.Ret);
        return (dImpl)dynamicMethod.CreateDelegate(typeof(dImpl));
    }
}

public static class InterlockedEx
{
    public static T CompareExchangeEnum<T>(ref T location, T value, T comparand)
    {
        return CompareExchangeEnumImpl<T>.Impl(ref location, value, comparand);
    }
}

public enum Foo
{
    X,
    Y,
}

static class Program
{
    static void Main()
    {
        Foo x = Foo.X;
        Foo y = Foo.Y;
        y = InterlockedEx.CompareExchangeEnum(ref x, y, Foo.X);
        Console.WriteLine("x: " + x);
        Console.WriteLine("y: " + y);
    }
}

Output:

x: Y
y: X

This just forwards the arguments to the correct Interlocked.Exchange overload. It fails badly if T isn't really an enum type, or its underlying type doesn't have an Interlocked.Exchange overload.

The generated IL is verifiable, at least according to PEVerify, as can be checked by making this use AssemblyBuilder and saving the result to a file.

@DarthVader Why not? I haven't ever had a reason to use `Interlocked.Exchange` with enums, but I do have other cases where there's a clear and correct way to do something, CIL allows it, but C# doesn't. In that case, I don't think C# is the right tool for the job, so I don't use C#. — , Aug 21 '13 at 14:11
How naughty! But I love it and copied it straight into my code :) Now, can you also do a `Thread.VolatileRead(myEnum)`? — Evgeniy Berezovsky, Apr 09 '15 at 23:25
@EugeneBeresovsky Sure, I don't see why not. It should be easy to adapt my answer to handle that. There are a lot of other methods that could also make sense to add, I don't think it'll benefit SO to include all of them here in an answer. :) — , Apr 10 '15 at 21:37
@EvgeniyBerezovsky see modernized Net Core response below. Just as easy to drop in and outperforms the Net6 native implementation by 1000x — , Sep 10 '22 at 00:23

xanatos · Accepted Answer · 2013-08-21T13:31:53.287

12

To make it simple, no :-)

Sadly C#/.NET consider enums as full type, partially disconnected from their base type. Every time you try to do something "fancy" on an enum you encounter some barrier.

edited Aug 21 '13 at 13:31

answered Aug 21 '13 at 13:19

xanatos

109,618
12
197
280

score 6 · Answer 3 · edited May 23 '17 at 12:10

6

Interlocked operations on enum are no problem:

public enum State { Idle, Running }

unsafe State CompareExchange(ref State target, State v, State cmp)
{
    fixed (State* p = &target)
        return (State)Interlocked.CompareExchange(ref *(int*)p, (int)v, (int)cmp);
}

See my full answer and discussion at https://stackoverflow.com/a/5589515/147511

edited May 23 '17 at 12:10

Community

1
1

answered Feb 01 '17 at 21:38

Glenn Slayden

17,543
3
114
108

score 5 · Answer 4 · answered Sep 04 '13 at 09:32

But are there better ways to do this?

I use a class instead of Enum:

public class DataCollectionManagerState
{
    public static readonly DataCollectionManagerState Off = new DataCollectionManagerState() { };
    public static readonly DataCollectionManagerState Starting = new DataCollectionManagerState() { };
    public static readonly DataCollectionManagerState On = new DataCollectionManagerState() { };

    private DataCollectionManagerState() { }

    public override string ToString()
    {
        if (this == Off) return "Off";
        if (this == Starting) return "Starting";
        if (this == On) return "On";

        throw new Exception();
    }
}

public class DataCollectionManager
{
    private static DataCollectionManagerState _state = DataCollectionManagerState.Off;

    public static void StartDataCollectionManager()
    {
        var originalValue = Interlocked.CompareExchange(ref _state, DataCollectionManagerState.Starting, DataCollectionManagerState.Off);
        if (originalValue != DataCollectionManagerState.Off)
        {
            throw new InvalidOperationException(string.Format("StartDataCollectionManager can be called when it's state is Off only. Current state is \"{0}\".", originalValue.ToString()));
        }

        // Start Data Collection Manager ...

        originalValue = Interlocked.CompareExchange(ref _state, DataCollectionManagerState.On, DataCollectionManagerState.Starting);
        if (originalValue != DataCollectionManagerState.Starting)
        {
            // Your code is really messy
            throw new Exception(string.Format("Unexpected error occurred. Current state is \"{0}\".", originalValue.ToString()));
        }
    }
}

This is often a good idea if the enum is controlling lots of things as a kind of strategy object. One symptom is lots of switches on the enum in different places. — Anton Tykhyy, Sep 04 '13 at 10:06

Bruno Zell · Answer 5 · 2020-01-04T19:35:28.650

Using `System.Runtime.CompilerServices.Unsafe`

Here's a pretty good related answer going into depth.

using System;
using System.Runtime.CompilerServices;
using System.Threading;

public static class InterlockedEx
{
    /// <summary>
    /// Enum equivalent of <see cref="Interlocked.CompareExchange(ref Int32, Int32, Int32)"/> and <see cref="Interlocked.CompareExchange(ref Int64, Int64, Int64)"/>
    /// </summary>
    public static TEnum CompareExchange<TEnum>(ref TEnum location, TEnum value, TEnum comparand)
        where TEnum : struct, Enum
    {
        return Unsafe.SizeOf<TEnum>() switch
        {
            // .NET does not support 1- and 2-byte atomic operations as there
            // is no common hardware support for that.
            4 => CompareExchange32Bit(ref location, value, comparand),
            8 => CompareExchange64Bit(ref location, value, comparand),
            _ => throw new NotSupportedException("Only enums with an underlying type of 4 bytes or 8 bytes are allowed to be used with Interlocked")
        };

        static TEnum CompareExchange32Bit(ref TEnum location, TEnum value, TEnum comparand)
        {
            int comparandRaw = Unsafe.As<TEnum, int>(ref comparand);
            int valueRaw = Unsafe.As<TEnum, int>(ref value);
            ref int locationRaw = ref Unsafe.As<TEnum, int>(ref location);
            int returnRaw = Interlocked.CompareExchange(ref locationRaw, valueRaw, comparandRaw);
            return Unsafe.As<int, TEnum>(ref returnRaw);
        }

        static TEnum CompareExchange64Bit(ref TEnum location, TEnum value, TEnum comparand)
        {
            long comparandRaw = Unsafe.As<TEnum, long>(ref comparand);
            long valueRaw = Unsafe.As<TEnum, long>(ref value);
            ref long locationRaw = ref Unsafe.As<TEnum, long>(ref location);
            long returnRaw = Interlocked.CompareExchange(ref locationRaw, valueRaw, comparandRaw);
            return Unsafe.As<long, TEnum>(ref returnRaw);
        }
    }
}

Interlocked.CompareExchange with enum

5 Answers5

Using `System.Runtime.CompilerServices.Unsafe`

Linked

Interlocked.CompareExchange with enum

5 Answers5

Using System.Runtime.CompilerServices.Unsafe

Linked

Using `System.Runtime.CompilerServices.Unsafe`