internal static Delegate InternalCreateDelegate(Type type, object firstArgument, MethodInfo method)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
RuntimeMethodInfo info = method as RuntimeMethodInfo;
if (info == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "method");
}
Type baseType = type.BaseType;
if ((baseType == null) || (baseType != typeof(MulticastDelegate)))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
Delegate delegate2 = InternalAlloc(type.TypeHandle.GetRuntimeType());
if (!delegate2.BindToMethodInfo(firstArgument, info.MethodHandle.GetMethodInfo(), info.GetDeclaringTypeInternal(), DelegateBindingFlags.RelaxedSignature | DelegateBindingFlags.SkipSecurityChecks))
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(delegate2);
}
internal static Delegate?CreateDelegateInternal(
RuntimeType rtType,
RuntimeMethodInfo rtMethod,
object?firstArgument,
DelegateBindingFlags flags
)
{
Delegate d = InternalAlloc(rtType);
if (
d.BindToMethodInfo(
firstArgument,
rtMethod,
rtMethod.GetDeclaringTypeInternal(),
flags
)
)
{
return(d);
}
else
{
return(null);
}
}
internal static Delegate CreateDelegate(Type type, object target, RuntimeMethodHandle method)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (method.IsNullHandle())
{
throw new ArgumentNullException("method");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
Type baseType = type.BaseType;
if ((baseType == null) || (baseType != typeof(MulticastDelegate)))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
Delegate delegate2 = InternalAlloc(type.TypeHandle.GetRuntimeType());
if (!delegate2.BindToMethodInfo(target, method.GetMethodInfo(), RuntimeMethodHandle.GetDeclaringType(method.GetMethodInfo()), DelegateBindingFlags.RelaxedSignature))
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(delegate2);
}
// V1 API.
public static Delegate CreateDelegate(Type type, MethodInfo method, bool throwOnBindFailure)
{
// Validate the parameters.
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
if (!(method is RuntimeMethodInfo))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "method");
}
Type c = type.BaseType;
if (c == null || c != typeof(MulticastDelegate))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
// Initialize the delegate...
Delegate d = InternalAlloc(type.TypeHandle);
// This API existed in v1/v1.1 and only expected to create closed
// instance delegates. Constrain the call to BindToMethodInfo to
// open delegates only for backwards compatibility. But we'll allow
// relaxed signature checking and open static delegates because
// there's no ambiguity there (the caller would have to explicitly
// pass us a static method or a method with a non-exact signature
// and the only change in behavior from v1.1 there is that we won't
// fail the call).
if (!d.BindToMethodInfo(null, method.MethodHandle, method.DeclaringType.TypeHandle,
DelegateBindingFlags.OpenDelegateOnly |
DelegateBindingFlags.RelaxedSignature))
{
if (throwOnBindFailure)
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
d = null;
}
return(d);
}
//
// internal implementation details (FCALLS and utilities)
//
// V2 internal API.
internal static Delegate CreateDelegateNoSecurityCheck(
Type type,
object?target,
RuntimeMethodHandle method
)
{
// Validate the parameters.
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (method.IsNullHandle())
{
throw new ArgumentNullException(nameof(method));
}
if (!(type is RuntimeType rtType))
{
throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(type));
}
if (!rtType.IsDelegate())
{
throw new ArgumentException(SR.Arg_MustBeDelegate, nameof(type));
}
// Initialize the method...
Delegate d = InternalAlloc(rtType);
// This is a new internal API added in Whidbey. Currently it's only
// used by the dynamic method code to generate a wrapper delegate.
// Allow flexible binding options since the target method is
// unambiguously provided to us.
if (
!d.BindToMethodInfo(
target,
method.GetMethodInfo(),
RuntimeMethodHandle.GetDeclaringType(method.GetMethodInfo()),
DelegateBindingFlags.RelaxedSignature
)
)
{
throw new ArgumentException(SR.Arg_DlgtTargMeth);
}
return(d);
}
[System.Security.SecurityCritical] // auto-generated
internal unsafe static Delegate CreateDelegateNoSecurityCheck(Type type, Object target, RuntimeMethodHandle method)
{
// Validate the parameters.
if (type == null)
{
throw new ArgumentNullException("type");
}
Contract.EndContractBlock();
if (method.IsNullHandle())
{
throw new ArgumentNullException("method");
}
RuntimeType rtType = type as RuntimeType;
if (rtType == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
if (!rtType.IsDelegate())
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
// Initialize the method...
Delegate d = InternalAlloc(rtType);
// This is a new internal API added in Whidbey. Currently it's only
// used by the dynamic method code to generate a wrapper delegate.
// Allow flexible binding options since the target method is
// unambiguously provided to us.
// <
if (!d.BindToMethodInfo(target,
method.GetMethodInfo(),
RuntimeMethodHandle.GetDeclaringType(method.GetMethodInfo()),
DelegateBindingFlags.RelaxedSignature | DelegateBindingFlags.SkipSecurityChecks))
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(d);
}
// V2 API.
public static Delegate CreateDelegate(Type type, Object firstArgument, MethodInfo method, bool throwOnBindFailure)
{
// Validate the parameters.
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
if (!(method is RuntimeMethodInfo))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "method");
}
Type c = type.BaseType;
if (c == null || c != typeof(MulticastDelegate))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
// Initialize the method...
Delegate d = InternalAlloc(type.TypeHandle);
if (!d.BindToMethodInfo(firstArgument, method.MethodHandle, method.DeclaringType.TypeHandle,
DelegateBindingFlags.RelaxedSignature))
{
if (throwOnBindFailure)
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
d = null;
}
return(d);
}
public static Delegate CreateDelegate(Type type, MethodInfo method, bool throwOnBindFailure)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
RuntimeMethodInfo info = method as RuntimeMethodInfo;
if (info == null)
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "method");
}
Type baseType = type.BaseType;
if ((baseType == null) || (baseType != typeof(MulticastDelegate)))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
Delegate delegate2 = InternalAlloc(type.TypeHandle.GetRuntimeType());
if (delegate2.BindToMethodInfo(null, info.MethodHandle.GetMethodInfo(), info.GetDeclaringTypeInternal().TypeHandle.GetRuntimeType(), DelegateBindingFlags.RelaxedSignature | DelegateBindingFlags.OpenDelegateOnly))
{
return(delegate2);
}
if (throwOnBindFailure)
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(null);
}
// Caution: this method is intended for deserialization only, no security checks are performed.
internal static Delegate InternalCreateDelegate(Type type, Object firstArgument, MethodInfo method)
{
// Validate the parameters.
if (type == null)
{
throw new ArgumentNullException("type");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
Type c = type.BaseType;
if (c == null || c != typeof(MulticastDelegate))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
// Initialize the method...
Delegate d = InternalAlloc(type.TypeHandle);
// This API is used by the formatters when deserializing a delegate.
// They pass us the specific target method (that was already the
// target in a valid delegate) so we should bind with the most
// relaxed rules available (the result will never be ambiguous, it
// just increases the chance of success with minor (compatible)
// signature changes). We explicitly skip security checks here --
// we're not really constructing a delegate, we're cloning an
// existing instance which already passed its checks.
if (!d.BindToMethodInfo(firstArgument, method.MethodHandle, method.DeclaringType.TypeHandle,
DelegateBindingFlags.SkipSecurityChecks |
DelegateBindingFlags.RelaxedSignature))
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(d);
}
internal static Delegate UnsafeCreateDelegate(RuntimeType rtType, RuntimeMethodInfo rtMethod, Object firstArgument, DelegateBindingFlags flags)
{
#if FEATURE_LEGACYNETCF
if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8)
{
if (rtMethod.IsGenericMethodDefinition)
{
throw new MissingMethodException(rtMethod.DeclaringType.FullName, rtMethod.Name);
}
}
#endif
Delegate d = InternalAlloc(rtType);
if (d.BindToMethodInfo(firstArgument, rtMethod, rtMethod.GetDeclaringTypeInternal(), flags))
{
return(d);
}
else
{
return(null);
}
}
//
// internal implementation details (FCALLS and utilities)
//
// V2 internal API.
internal unsafe static Delegate CreateDelegate(Type type, Object target, RuntimeMethodHandle method)
{
// Validate the parameters.
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
if (method.IsNullHandle())
{
throw new ArgumentNullException("method");
}
Type c = type.BaseType;
if (c == null || c != typeof(MulticastDelegate))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
// Initialize the method...
Delegate d = InternalAlloc(type.TypeHandle);
// This is a new internal API added in Whidbey. Currently it's only
// used by the dynamic method code to generate a wrapper delegate.
// Allow flexible binding options since the target method is
// unambiguously provided to us.
if (!d.BindToMethodInfo(target, method, method.GetDeclaringType(), DelegateBindingFlags.RelaxedSignature))
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(d);
}
public static Delegate CreateDelegate(Type type, object firstArgument, MethodInfo method, bool throwOnBindFailure)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (!(type is RuntimeType))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"), "type");
}
if (method == null)
{
throw new ArgumentNullException("method");
}
if (!(method is RuntimeMethodInfo))
{
throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeMethodInfo"), "method");
}
Type baseType = type.BaseType;
if ((baseType == null) || (baseType != typeof(MulticastDelegate)))
{
throw new ArgumentException(Environment.GetResourceString("Arg_MustBeDelegate"), "type");
}
Delegate delegate2 = InternalAlloc(type.TypeHandle);
if (delegate2.BindToMethodInfo(firstArgument, method.MethodHandle, method.DeclaringType.TypeHandle, DelegateBindingFlags.RelaxedSignature))
{
return(delegate2);
}
if (throwOnBindFailure)
{
throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTargMeth"));
}
return(null);
}
