public static AsyncInvocationRegion Create(Delegate @delegate) { #if PORTABLE return Create(@delegate.GetMethodInfo()); #else return Create(@delegate.Method); #endif }
public static bool IsAsyncOperation(Delegate @delegate) { #if PORTABLE return IsAsyncOperation(@delegate.GetMethodInfo()); #else return IsAsyncOperation(@delegate.Method); #endif }
void IActionInvoker.ClearIfMatched(Delegate action, object recipient) { object target = Target; if(recipient != target) return; #if !NETFX_CORE if(action != null && action.Method.Name != MethodName) #else if(action != null && action.GetMethodInfo().Name != MethodName) #endif return; targetReference = null; ClearCore(); }
/// <summary> /// Returns a value indicating whether the current weak delegate is a match (equivalent) for the specified strong delegate. /// </summary> /// <param name="strongDelegate">The <see cref="Delegate">delegate</see> to evaluate.</param> /// <returns>True if the current weak delegate is a match for the specified strong delegate; otherwise, false.</returns> public virtual bool IsMatch( Delegate strongDelegate ) { if ( strongDelegate == null ) return false; if ( !object.Equals( strongDelegate.Target, Target ) ) return false; if ( !strongDelegate.GetMethodInfo().Equals( method ) ) return false; return true; }
public ScriptUserdataDelegate(Script script, Delegate value) : base(script) { this.m_Delegate = value; this.m_Value = value; this.m_ValueType = value.GetType(); var method = m_Delegate.GetMethodInfo(); var infos = method.GetParameters(); var dynamicDelegate = method.Name.Equals(Script.DynamicDelegateName); int length = dynamicDelegate ? infos.Length - 1 : infos.Length; m_Objects = new object[length]; for (int i = 0; i < length; ++i) { var p = infos[dynamicDelegate ? i + 1 : i]; m_Parameters.Add(new FunctionParameter(p.ParameterType, p.DefaultValue)); } }
public bool IsEqualTo(object source, EventInfo eventInfo, Delegate handler) { if (source == this.source && eventInfo == this.eventInfo) { object target; if (handlerTarget.TryGetTarget(out target)) { return(handler.Target == target && handler.GetMethodInfo() == handlerMethod); } } return(false); }
public void RegisterFunction(string functionName, Delegate function, bool isOverWritable) { if (string.IsNullOrEmpty(functionName)) throw new ArgumentNullException("functionName"); if (function == null) throw new ArgumentNullException("function"); Type funcType = function.GetType(); if (!funcType.FullName.StartsWith("System.Func")) throw new ArgumentException("Only System.Func delegates are permitted.", "function"); #if NETFX_CORE foreach (Type genericArgument in funcType.GenericTypeArguments) #else foreach (Type genericArgument in funcType.GetGenericArguments()) #endif if (genericArgument != typeof(double)) throw new ArgumentException("Only doubles are supported as function arguments", "function"); functionName = ConvertFunctionName(functionName); if (functions.ContainsKey(functionName) && !functions[functionName].IsOverWritable) { string message = string.Format("The function \"{0}\" cannot be overwriten.", functionName); throw new Exception(message); } #if NETFX_CORE int numberOfParameters = function.GetMethodInfo().GetParameters().Length; #else int numberOfParameters = function.Method.GetParameters().Length; #endif if (functions.ContainsKey(functionName) && functions[functionName].NumberOfParameters != numberOfParameters) { string message = string.Format("The number of parameters cannot be changed when overwriting a method."); throw new Exception(message); } FunctionInfo functionInfo = new FunctionInfo(functionName, numberOfParameters, isOverWritable, function); if (functions.ContainsKey(functionName)) functions[functionName] = functionInfo; else functions.Add(functionName, functionInfo); }
public SubscriberReference(Delegate action) { if (action == null) throw new ArgumentNullException("action"); // If the delegates target is null, we can't hold a reference to it. // This happens when the callback method is static or a it has been // created as a lambda/anonymous delegate that doesn't capture any // instance variables. (Causes the compiler to generate a static method.) if (action.Target == null) throw new InvalidOperationException("Subscription with a static delegate method is not supported"); _weakReference = new WeakReference(action.Target); _delegateType = action.GetType(); _delegateMethod = action.GetMethodInfo(); }
/// <summary> /// Initializes a new instance of <see cref="DelegateReference"/>. /// </summary> /// <param name="delegate">The original <see cref="Delegate"/> to create a reference for.</param> /// <param name="keepReferenceAlive">If <see langword="false" /> the class will create a weak reference to the delegate, allowing it to be garbage collected. Otherwise it will keep a strong reference to the target.</param> /// <exception cref="ArgumentNullException">If the passed <paramref name="delegate"/> is not assignable to <see cref="Delegate"/>.</exception> public DelegateReference(Delegate @delegate, bool keepReferenceAlive) { if (@delegate == null) throw new ArgumentNullException("delegate"); if (keepReferenceAlive) { this._delegate = @delegate; } else { _weakReference = new WeakReference(@delegate.Target); _method = @delegate.GetMethodInfo(); _delegateType = @delegate.GetType(); } }
/// <summary> /// Raises the event. /// </summary> /// <param name="handler">The delegate to invoke.</param> /// <param name="sender">The sender.</param> /// <param name="eventArgs">The <see cref="EventArgs"/> instance containing the event data.</param> public static void Raise(this Delegate handler, object sender, EventArgs eventArgs) { if (handler == null) { return; } try { handler.GetMethodInfo() .Invoke(handler.Target, new[] { TargetFactory.GetPair(sender), eventArgs }); } catch (TargetInvocationException e) { throw new TargetInvocationException("Please check the inner exception for error details.", e.InnerException); } }
private object[] GetArguments(Delegate valueFactory) { object[] arguments = new object[valueFactory.GetMethodInfo().GetParameters().Length]; IEnumerable<ImportDefinition> ctorImportDefinitions = ImportDefinitions.Where(ReflectionModelServices.IsImportingParameter); foreach (ImportDefinition ctorImportDefinition in ctorImportDefinitions) { ParameterInfo parameterInfo = ReflectionModelServices.GetImportingParameter(ctorImportDefinition).Value; IEnumerable<Export> value; if (_imports.TryGetValue(ctorImportDefinition, out value)) { arguments[parameterInfo.Position] = value.Single().Value; _imports.Remove(ctorImportDefinition); } else { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "There is no export for parameter of type {0}", parameterInfo.ParameterType)); } } return arguments; }
/// <summary> /// Creates a CallbackFunction from a delegate. /// </summary> /// <param name="script">The script.</param> /// <param name="del">The delegate.</param> /// <param name="accessMode">The access mode.</param> /// <returns></returns> public static CallbackFunction FromDelegate(Script script, Delegate del, InteropAccessMode accessMode = InteropAccessMode.Default) { if (accessMode == InteropAccessMode.Default) accessMode = m_DefaultAccessMode; #if NETFX_CORE MethodMemberDescriptor descr = new MethodMemberDescriptor(del.GetMethodInfo(), accessMode); #else MethodMemberDescriptor descr = new MethodMemberDescriptor(del.Method, accessMode); #endif return descr.GetCallbackFunction(script, del.Target); }
private void storeMethodType(Delegate value) { if (value == null) { throw new DispatcherException ("EventDispatcher can't map something that isn't a delegate'", DispatcherExceptionType.ILLEGAL_CALLBACK_HANDLER); } #if NETFX_CORE MethodInfo methodInfo = value.GetMethodInfo(); #else MethodInfo methodInfo = value.Method; #endif int argsLen = methodInfo.GetParameters ().Length; switch(argsLen) { case 0: callbackTypes[value] = EventCallbackType.NO_ARGUMENTS; break; case 1: callbackTypes[value] = EventCallbackType.ONE_ARGUMENT; break; default: throw new DispatcherException ("Event callbacks must have either one or no arguments", DispatcherExceptionType.ILLEGAL_CALLBACK_HANDLER); } }
/// <summary> /// Removes a <see cref="Delegate"/> from the <see cref="WeakMulticastDelegate"/>. /// </summary> /// <param name="delegate">The <see cref="Delegate"/> to remove.</param> public void Remove(Delegate @delegate) { if (@delegate == null) return; for (int i = _delegates.Count - 1; i >= 0; i--) { InternalWeakDelegate weakDelegate = _delegates[i]; if (weakDelegate.TargetReference != null) { // The delegate method is an object method. object target = weakDelegate.TargetReference.Target; if (target == null) { // Remove garbage collected entry. _delegates.RemoveAt(i); } else if (target == @delegate.Target #if !NETFX_CORE && !NET45 && weakDelegate.MethodInfo.Equals(@delegate.Method)) #else && weakDelegate.MethodInfo.Equals(@delegate.GetMethodInfo())) #endif { // Remove matching entry. _delegates.RemoveAt(i); break; } } else { // The delegate method is a class method. if (@delegate.Target == null #if !NETFX_CORE && !NET45 && weakDelegate.MethodInfo.Equals(@delegate.Method)) #else && weakDelegate.MethodInfo.Equals(@delegate.GetMethodInfo())) #endif { // Remove matching entry. _delegates.RemoveAt(i); break; } } } }
private static MethodInfo GetMethod(Delegate x) { return x.GetMethodInfo(); }
/// <summary> /// Initializes a new instance of <see cref="WeakDelegate"/> /// </summary> /// <param name="delegate"></param> public WeakDelegate(Delegate @delegate) { _target = new WeakReference(@delegate.Target); _method = @delegate.GetMethodInfo(); }
private void appendEventHandler(StringBuilder sb, String name, Delegate eh) { if (eh != null) sb.AppendFormat("{0}={1};", name, eh.GetMethodInfo().Name); else sb.AppendFormat("{0}=null;", name); }
/*!*/ internal static MSA.Expression CallDelegate(Delegate/*!*/ method, MSA.Expression[]/*!*/ arguments) { MethodInfo methodInfo = method.GetMethodInfo(); // We prefer to peek inside the delegate and call the target method directly. However, we need to // exclude DynamicMethods since Delegate.Method returns a dummy MethodInfo, and we cannot emit a call to it. if (methodInfo.DeclaringType == null || !methodInfo.DeclaringType.IsPublic() || !methodInfo.IsPublic) { // do not inline: return Ast.Call(AstUtils.Constant(method), method.GetType().GetMethod("Invoke"), arguments); } if (method.Target != null) { // inline a closed static delegate: if (methodInfo.IsStatic) { return Ast.Call(null, method.GetMethodInfo(), ArrayUtils.Insert(AstUtils.Constant(method.Target), arguments)); } // inline a closed instance delegate: return Ast.Call(AstUtils.Constant(method.Target), methodInfo, arguments); } // inline an open static delegate: if (methodInfo.IsStatic) { return Ast.Call(null, methodInfo, arguments); } // inline an open instance delegate: return Ast.Call(arguments[0], methodInfo, ArrayUtils.RemoveFirst(arguments)); }
/// <summary> /// GetMethodName is not supported on some platforms. /// </summary> #if REFLECTION_SUPPORT #if !UNITY_EDITOR && NETFX_CORE static string GetMethodName(Callback callback) { System.Delegate d = callback as System.Delegate; return(d.GetMethodInfo().Name); }
/*!*/ internal static LibraryOverload Reflect(Delegate/*!*/ overloadDelegate) { return Create(overloadDelegate, EncodeCustomAttributes(overloadDelegate.GetMethodInfo())); }
//-------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="InternalWeakDelegate"/> class. /// </summary> /// <param name="delegate"> /// The original <see cref="System.Delegate"/> to create a weak reference for. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="delegate"/> is <see langword="null"/>. /// </exception> public InternalWeakDelegate(Delegate @delegate) { if (@delegate == null) throw new ArgumentNullException("delegate"); object target = @delegate.Target; TargetReference = (target != null) ? new WeakReference(target) : null; #if !NETFX_CORE && !NET45 MethodInfo = @delegate.Method; #else MethodInfo = @delegate.GetMethodInfo(); #endif DelegateType = @delegate.GetType(); Debug.Assert( (TargetReference != null && !MethodInfo.IsStatic) || (TargetReference == null && MethodInfo.IsStatic), "Sanity check."); CheckForClosure(MethodInfo); CheckForNonPublicEventHandler(target, MethodInfo); }
public WeakDelegate( Delegate strongDelegate ) : base( GetTarget( strongDelegate ) ) { type = strongDelegate.GetType(); method = strongDelegate.GetMethodInfo(); }
static bool IsValid(Callback callback) { System.Delegate d = callback as System.Delegate; return(d != null && d.GetMethodInfo() != null); }
/// <summary> /// Imports the delegate to the specified member. /// </summary> /// <param name="member">The member.</param> /// <param name="function">The function delegate.</param> /// <exception cref="System.ArgumentNullException">if member or function are null</exception> public static void Import(this IScriptObject script, string member, Delegate function) { if (member == null) throw new ArgumentNullException(nameof(member)); if (function == null) throw new ArgumentNullException(nameof(function)); script.SetValue(member, new ObjectFunctionWrapper(function.Target, function.GetMethodInfo()), true); }