为什么SynchronizationContext检查为null？

Question

InstallIfNeeded method of WindowsFormsSynchronizationContext class, in the try block:

SynchronizationContext currentContext = AsyncOperationManager.SynchronizationContext;
//Make sure we either have no [....] context
//or that we have one of type SynchronizationContext

if (currentContext == null || currentContext.GetType() == typeof(SynchronizationContext))
{
...

So first, AsyncOperationManager.SynchronizationContext getter is called, and its return value is checked for null. Is checking for null necessary here?

Code of AsyncOperationManager.SynchronizationContext below. It first checks if Current sync context is null, if it is, then a new one is created. So probably this getter never returns a null.

public static SynchronizationContext SynchronizationContext 
{
get 
{
    if (SynchronizationContext.Current == null) 
    {
        SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
    }
    return SynchronizationContext.Current;
}

Answer 1

Is checking for null necessary here?

My previous answer neglected the fact that SynchronizationContext.Current will in fact be created on a thread basis, and not across multiple threads (thanks to @PerSerAl for pointing that out). You can obviously see it in the code:

// Get the current SynchronizationContext on the current thread
public static SynchronizationContext Current 
{
    get      
    {
        return Thread.CurrentThread.GetExecutionContextReader().SynchronizationContext ??
               GetThreadLocalContext();
    }
}

Effectively, this does in-fact make the null check redundant, but does immune itself from any future changes that may happen in the future to code around SynchronizationContext implementation.

Answer 2

With the exact code as it is right now, you are right.

However, look at the intent of the code instead. The point is that the only point where installing the winforms context is safe is when there is no other synchronization context. This corresponds to either having a null synchronization context, or the default SynchronizationContext .

The fact that the synchronization context can never be null in current exact version of the code is largely irrelevant. True, this will probably not change, since it's a public static interface, but depending on that is a completely unnecessary dependency. You want your code to signal it's intent as clearly as possible, and this check does exactly that - while also avoiding a direct dependency on the internal behaviour of a public interface.

Answer 3

So here's what I'm seeing (the first two bits are the same as your question):

SynchronizationContext currentContext = AsyncOperationManager.SynchronizationContext;
            //Make sure we either have no [....] context or that we have one of type SynchronizationContext
            if (currentContext == null || currentContext.GetType() == typeof(SynchronizationContext)) {

Which then goes to:

public static SynchronizationContext SynchronizationContext {
        get {
            if (SynchronizationContext.Current == null) {
                SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
            }

            return SynchronizationContext.Current;
        }

Which then leads to: in the line (SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());

public static void SetSynchronizationContext(SynchronizationContext syncContext)
    {
        ExecutionContext ec = Thread.CurrentThread.GetMutableExecutionContext();
        ec.SynchronizationContext = syncContext;
        ec.SynchronizationContextNoFlow = syncContext;
    }

But then it's returning the SynchronizationContext.Current

public static SynchronizationContext Current 
    {
        get      
        {
            return Thread.CurrentThread.GetExecutionContextReader().SynchronizationContext ?? GetThreadLocalContext();
        }
    }

Which can potentially end up here.

private static SynchronizationContext GetThreadLocalContext()
    {
        SynchronizationContext context = null;

#if FEATURE_APPX
        if (context == null && Environment.IsWinRTSupported)
            context = GetWinRTContext();
#endif

        return context;
    }

As you can see, context can be null if IsWinRTSupported returns false.

Based on what I'm seeing, the null check is probably a good idea. I don't know if the first condition Thread.CurrentThread.GetExecutionContextReader().SynchronizationContext can return null but given the ?? operator, that's a possibility.