protected void EnsureAccessible()
{
if (CheckAccessible && this.ReferenceCount == 0)
{
ThrowHelper.ThrowIllegalReferenceCountException(0);
}
}
private void RetainSlow(int increment, int refCnt)
{
int oldRefCnt;
do
{
oldRefCnt = refCnt;
int nextCnt = refCnt + increment;
// Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
if (nextCnt <= increment)
{
ThrowHelper.ThrowIllegalReferenceCountException(refCnt, increment);
}
refCnt = Interlocked.CompareExchange(ref _referenceCount, nextCnt, refCnt);
} while (refCnt != oldRefCnt);
}
int ReleaseSlow(int decrement, int refCnt)
{
int oldRefCnt;
do
{
oldRefCnt = refCnt;
if (refCnt < decrement)
{
ThrowHelper.ThrowIllegalReferenceCountException(refCnt, -decrement);
}
refCnt = Interlocked.CompareExchange(ref _referenceCount, refCnt - decrement, refCnt);
} while (refCnt != oldRefCnt);
return(refCnt);
}
IReferenceCounted Retain0(int increment)
{
int currRefCnt = Volatile.Read(ref _referenceCount);
int nextCnt = currRefCnt + increment;
// Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
if (nextCnt <= increment)
{
ThrowHelper.ThrowIllegalReferenceCountException(currRefCnt, increment);
}
var refCnt = Interlocked.CompareExchange(ref _referenceCount, nextCnt, currRefCnt);
if (currRefCnt != refCnt)
{
RetainSlow(increment, refCnt);
}
return(this);
}
bool Release0(int decrement)
{
int currRefCnt = Volatile.Read(ref _referenceCount);
if (currRefCnt < decrement)
{
ThrowHelper.ThrowIllegalReferenceCountException(currRefCnt, -decrement);
}
var refCnt = Interlocked.CompareExchange(ref _referenceCount, currRefCnt - decrement, currRefCnt);
if (currRefCnt != refCnt)
{
refCnt = ReleaseSlow(decrement, refCnt);
}
if (refCnt == decrement)
{
Deallocate();
return(true);
}
return(false);
}