在Interlocked.CompareExchange（）之后读取值

Question

假设我有一些基类

public abstract class ReflectionSupport
{
    private const int UnresolvedFieldsFlag = -1;
    private const int TrueFieldsFlag = 1;
    private const int FalseFieldsFlag = 0;

    // flag holder
    private int _flagHasFields = UnresolvedFieldsFlag;

    // variant 1 
    protected bool HasFields
    {
       get
       {
          Interlocked.CompareExchange(ref _flagHasFields, ResolveHasFieldsFlag(), UnresolvedFieldsFlag);
          return (TrueFieldsFlag == Volatile.Read(ref _flagHasFields));
       }
    }

    // variant 2
    protected bool HasFields
    {
         get
         {
             Interlocked.CompareExchange(ref _flagHasFields, ResolveHasFieldsFlag(), UnresolvedFieldsFlag);
             return (TrueFieldsFlag == _flagHasFields);
         }
    }

    private int ResolveHasFieldsFlag()
    { 
         // here reflection is used 
         // to analyze current instance 
         // and returns TRUE-flag if instance 
         // contains field
    }
}

我的问题 - 我应该在Interlocked.CompareExchange（）之后使用什么变体HasFields属性。存储在字段中的标志值是Interlocked操作后的最新值还是我必须使用volatile读取？

Answer 1

根据您的评论信息，您可以通过以下方式使用Lazy

public abstract class ReflectionSupport
{
    private readonly Lazy<bool> _hasFields;
    protected bool HasFields => _hasFields.Value;

    protected ReflectionSupport()
    {
        _hasFields = new Lazy<bool>(HasFieldsFlag);
    }

    private bool HasFieldsFlag()
    { 
        // just return true if instance 
        // contains field
    }
}

如你所见，UnresolvedFieldsFlag不再需要，所以可以用bool代替