protected void SetWaitNotificationRequired()
{
Type type = this.GetType();
if (SynchronizationContext.s_cachedPreparedType1 != type && SynchronizationContext.s_cachedPreparedType2 != type && (SynchronizationContext.s_cachedPreparedType3 != type && SynchronizationContext.s_cachedPreparedType4 != type) && SynchronizationContext.s_cachedPreparedType5 != type)
{
RuntimeHelpers.PrepareDelegate((Delegate) new SynchronizationContext.WaitDelegate(this.Wait));
if (SynchronizationContext.s_cachedPreparedType1 == (Type)null)
{
SynchronizationContext.s_cachedPreparedType1 = type;
}
else if (SynchronizationContext.s_cachedPreparedType2 == (Type)null)
{
SynchronizationContext.s_cachedPreparedType2 = type;
}
else if (SynchronizationContext.s_cachedPreparedType3 == (Type)null)
{
SynchronizationContext.s_cachedPreparedType3 = type;
}
else if (SynchronizationContext.s_cachedPreparedType4 == (Type)null)
{
SynchronizationContext.s_cachedPreparedType4 = type;
}
else if (SynchronizationContext.s_cachedPreparedType5 == (Type)null)
{
SynchronizationContext.s_cachedPreparedType5 = type;
}
}
this._props = this._props | SynchronizationContextProperties.RequireWaitNotification;
}
/// <summary>
/// Verifies that a <see cref="SynchronizationContext"/> satisfies the guarantees required by the calling code.
/// </summary>
/// <param name="synchronizationContextType">The type derived from <see cref="SynchronizationContext"/> to test.</param>
/// <param name="properties">The guarantees required by the calling code.</param>
public static void Verify(Type synchronizationContextType, SynchronizationContextProperties properties)
{
SynchronizationContextProperties supported = Lookup(synchronizationContextType);
if ((supported & properties) != properties)
{
throw new InvalidOperationException("This asynchronous object cannot be used with this SynchronizationContext");
}
}
// protected so that only the derived sync context class can enable these flags
protected void SetWaitNotificationRequired()
{
// Prepare the method so that it can be called in a reliable fashion when a wait is needed.
// This will obviously only make the Wait reliable if the Wait method is itself reliable. The only thing
// preparing the method here does is to ensure there is no failure point before the method execution begins.
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
_props |= SynchronizationContextProperties.RequireWaitNotification;
}
/// <summary>
/// Verifies that <see cref="SynchronizationContext.Current"/> satisfies the guarantees required by the calling code.
/// </summary>
/// <param name="properties">The guarantees required by the calling code.</param>
public static void Verify(SynchronizationContextProperties properties)
{
if (SynchronizationContext.Current == null)
{
Verify(typeof(SynchronizationContext), properties);
}
else
{
Verify(SynchronizationContext.Current.GetType(), properties);
}
}
/// <summary>
/// Looks up the guarantees for a <see cref="SynchronizationContext"/> type.
/// </summary>
/// <param name="synchronizationContextType">The type derived from <see cref="SynchronizationContext"/> to test.</param>
/// <returns>The properties guaranteed by <paramref name="synchronizationContextType"/>.</returns>
public static SynchronizationContextProperties Lookup(Type synchronizationContextType)
{
lock (synchronizationContextProperties)
{
SynchronizationContextProperties supported = SynchronizationContextProperties.None;
if (synchronizationContextProperties.ContainsKey(synchronizationContextType.FullName))
{
supported = synchronizationContextProperties[synchronizationContextType.FullName];
}
return(supported);
}
}
/// <summary>
/// Registers a <see cref="SynchronizationContext"/> type claiming to provide certain guarantees.
/// </summary>
/// <param name="synchronizationContextType">The type derived from <see cref="SynchronizationContext"/>.</param>
/// <param name="properties">The guarantees provided by this type.</param>
/// <remarks>
/// <para>This method should be called once for each type of <see cref="SynchronizationContext"/>. It is not necessary to call this method for .NET <see cref="SynchronizationContext"/> types or <see cref="ActionDispatcherSynchronizationContext"/>.</para>
/// <para>If this method is called more than once for a type, the new value of <paramref name="properties"/> replaces the old value. The flags are not merged.</para>
/// </remarks>
public static void Register(Type synchronizationContextType, SynchronizationContextProperties properties)
{
lock (synchronizationContextProperties)
{
if (synchronizationContextProperties.ContainsKey(synchronizationContextType.FullName))
{
synchronizationContextProperties[synchronizationContextType.FullName] = properties;
}
else
{
synchronizationContextProperties.Add(synchronizationContextType.FullName, properties);
}
}
}
/// <summary>
/// Registers a <see cref="SynchronizationContext"/> type claiming to provide certain guarantees.
/// </summary>
/// <param name="synchronizationContextType">The type derived from <see cref="SynchronizationContext"/>. May not be <c>null</c>.</param>
/// <param name="properties">The guarantees provided by this type.</param>
/// <remarks>
/// <para>This method should be called once for each type of <see cref="SynchronizationContext"/>. It is not necessary to call this method for .NET <see cref="SynchronizationContext"/> types or <see cref="ActionDispatcherSynchronizationContext"/>.</para>
/// <para>If this method is called more than once for a type, the new value of <paramref name="properties"/> replaces the old value. The flags are not merged.</para>
/// </remarks>
public static void Register(Type synchronizationContextType, SynchronizationContextProperties properties)
{
Contract.Requires(synchronizationContextType != null);
lock (synchronizationContextProperties)
{
if (synchronizationContextProperties.ContainsKey(synchronizationContextType.FullName))
{
synchronizationContextProperties[synchronizationContextType.FullName] = properties;
}
else
{
synchronizationContextProperties.Add(synchronizationContextType.FullName, properties);
}
}
}
protected void SetWaitNotificationRequired()
{
//
// Prepare the method so that it can be called in a reliable fashion when a wait is needed.
// This will obviously only make the Wait reliable if the Wait method is itself reliable. The only thing
// preparing the method here does is to ensure there is no failure point before the method execution begins.
//
// Preparing the method in this way is quite expensive, but only needs to be done once per type, per AppDomain.
// So we keep track of a few types we've already prepared in this AD. It is uncommon to have more than
// a few SynchronizationContext implementations, so we only cache the first five we encounter; this lets
// our cache be much faster than a more general cache might be. This is important, because this
// is a *very* hot code path for many WPF and WinForms apps.
//
Type type = this.GetType();
if (s_cachedPreparedType1 != type &&
s_cachedPreparedType2 != type &&
s_cachedPreparedType3 != type &&
s_cachedPreparedType4 != type &&
s_cachedPreparedType5 != type)
{
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
if (s_cachedPreparedType1 == null)
{
s_cachedPreparedType1 = type;
}
else if (s_cachedPreparedType2 == null)
{
s_cachedPreparedType2 = type;
}
else if (s_cachedPreparedType3 == null)
{
s_cachedPreparedType3 = type;
}
else if (s_cachedPreparedType4 == null)
{
s_cachedPreparedType4 = type;
}
else if (s_cachedPreparedType5 == null)
{
s_cachedPreparedType5 = type;
}
}
_props |= SynchronizationContextProperties.RequireWaitNotification;
}
protected void SetWaitNotificationRequired()
{
//
// Prepare the method so that it can be called in a reliable fashion when a wait is needed.
// This will obviously only make the Wait reliable if the Wait method is itself reliable. The only thing
// preparing the method here does is to ensure there is no failure point before the method execution begins.
//
// Preparing the method in this way is quite expensive, but only needs to be done once per type, per AppDomain.
// So we keep track of a few types we've already prepared in this AD. It is uncommon to have more than
// a few SynchronizationContext implementations, so we only cache the first five we encounter; this lets
// our cache be much faster than a more general cache might be. This is important, because this
// is a *very* hot code path for many WPF and WinForms apps.
//
Type type = this.GetType();
if (s_cachedPreparedType1 != type &&
s_cachedPreparedType2 != type &&
s_cachedPreparedType3 != type &&
s_cachedPreparedType4 != type &&
s_cachedPreparedType5 != type)
{
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
if (s_cachedPreparedType1 == null) s_cachedPreparedType1 = type;
else if (s_cachedPreparedType2 == null) s_cachedPreparedType2 = type;
else if (s_cachedPreparedType3 == null) s_cachedPreparedType3 = type;
else if (s_cachedPreparedType4 == null) s_cachedPreparedType4 = type;
else if (s_cachedPreparedType5 == null) s_cachedPreparedType5 = type;
}
_props |= SynchronizationContextProperties.RequireWaitNotification;
}
// protected so that only the derived sync context class can enable these flags
protected void SetWaitNotificationRequired()
{
// Prepare the method so that it can be called in a reliable fashion when a wait is needed.
// This will obviously only make the Wait reliable if the Wait method is itself reliable. The only thing
// preparing the method here does is to ensure there is no failure point before the method execution begins.
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
_props |= SynchronizationContextProperties.RequireWaitNotification;
}
protected void SetWaitNotificationRequired()
{
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
this._props |= SynchronizationContextProperties.RequireWaitNotification;
}
// protected so that only the derived sync context class can enable these flags
protected void SetWaitNotificationRequired()
{
_props |= SynchronizationContextProperties.RequireWaitNotification;
}
protected void SetWaitNotificationRequired()
{
RuntimeHelpers.PrepareDelegate(new WaitDelegate(this.Wait));
this._props |= SynchronizationContextProperties.RequireWaitNotification;
}
/// <summary>
/// Verifies that <see cref="SynchronizationContext.Current"/> satisfies the guarantees required by the calling code.
/// </summary>
/// <param name="properties">The guarantees required by the calling code.</param>
public static void Verify(SynchronizationContextProperties properties)
{
if (SynchronizationContext.Current == null)
{
Verify(typeof(SynchronizationContext), properties);
}
else
{
Verify(SynchronizationContext.Current.GetType(), properties);
}
}
/// <summary>
/// Verifies that a <see cref="SynchronizationContext"/> satisfies the guarantees required by the calling code.
/// </summary>
/// <param name="synchronizationContextType">The type derived from <see cref="SynchronizationContext"/> to test.</param>
/// <param name="properties">The guarantees required by the calling code.</param>
public static void Verify(Type synchronizationContextType, SynchronizationContextProperties properties)
{
SynchronizationContextProperties supported = Lookup(synchronizationContextType);
if ((supported & properties) != properties)
{
throw new InvalidOperationException("This asynchronous object cannot be used with this SynchronizationContext");
}
}
