public void Valid() { #pragma warning disable REFL039 // Prefer typeof(...) over instance.GetType when the type is sealed. var @delegate = Create(); Action action = () => { }; Action <int> actionInt = _ => { }; Func <int> funcInt = () => 0; Func <int, int> funcIntInt = x => x; Assert.NotNull(@delegate.GetType().GetMethod("Invoke", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)); Assert.NotNull(action.GetType().GetMethod(nameof(action.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(action.GetType().GetMethod(nameof(Action.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(actionInt.GetType().GetMethod(nameof(actionInt.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); Assert.NotNull(actionInt.GetType().GetMethod(nameof(Action <int> .Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); Assert.NotNull(funcInt.GetType().GetMethod(nameof(funcInt.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(funcInt.GetType().GetMethod(nameof(Func <int> .Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(funcIntInt.GetType().GetMethod(nameof(funcIntInt.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); Assert.NotNull(funcIntInt.GetType().GetMethod(nameof(Func <int, int> .Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); #pragma warning restore REFL039 // Prefer typeof(...) over instance.GetType when the type is sealed. Assert.NotNull(typeof(Action).GetMethod(nameof(action.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(typeof(Action).GetMethod(nameof(Action.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(typeof(Action <int>).GetMethod(nameof(actionInt.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); Assert.NotNull(typeof(Action <int>).GetMethod(nameof(Action <int> .Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); Assert.NotNull(typeof(Func <int>).GetMethod(nameof(funcInt.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(typeof(Func <int>).GetMethod(nameof(Func <int> .Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, Type.EmptyTypes, null)); Assert.NotNull(typeof(Func <int, int>).GetMethod(nameof(funcIntInt.Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); Assert.NotNull(typeof(Func <int, int>).GetMethod(nameof(Func <int, int> .Invoke), BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, null, new[] { typeof(int) }, null)); }
public static void Add<T>(Func<T> schedule) where T : IBackgroundTask { #if NETSTANDARD1_0 var typeName = schedule.GetType().GenericTypeArguments[0]?.Name; #else var typeName = schedule.GetType().GetGenericArguments()[0]?.Name; #endif if (typeName != null && !schedules.ContainsKey(typeName)) schedules.Add(typeName, schedule()); }
public IPrimitive PerformLayout(LayoutContext layoutContext) { if (!_cache.TryGetValue((_item.GetType(), _dependency), out var item) || !item.TryGetTarget(out var primitiveComponent)) { var vc = _item(_dependency); primitiveComponent = vc.Layout(layoutContext); var componentReference = new WeakReference <IPrimitive>(primitiveComponent); _cache.Add((_item.GetType(), _dependency), componentReference); } return(primitiveComponent); }
public void MetodoMain() { int numero = 10; // C# 1.0: Uso de delegados Console.WriteLine("\n\t *** C# 1.0: Uso delegados ***"); // Creo una instancia (objeto) del delegado que apunta a Cuadrado() dlgCuadrado _miDlgCuadrado = new dlgCuadrado(Cuadrado); // Llamo al objeto delegado y le paso un parámetro. CUMPLO LA FIRMA Console.WriteLine("\nMI DELEGADO {0} --> {1}", _miDlgCuadrado.GetType().Name, _miDlgCuadrado(numero)); // C# 2.0: Uso de delegados con código de inicialización (métodos anónimos) Console.WriteLine("\n\t *** C# 2.0: Uso delegados con código de inicialización ***"); dlgCuadrado _miDlgCuadradoAnonimo = delegate(int x) { return(x * x); }; Console.WriteLine("\nMI DELEGADO ANÓNIMO {0} --> {1}", _miDlgCuadradoAnonimo.GetType().Name, _miDlgCuadradoAnonimo(numero)); // C# 3.0: Uso de delegados genérico integrado con expresión lambda Console.WriteLine("\n\t *** C# 3.0: Uso delegados con exp. Lambda ***"); // Creo un delegado al que le asigno una exp lambda Func <int, int> _midlgCuadrado2 = x => x * x; Console.WriteLine("\nDELEGADO FUNC CON EXP. LAMBDA {0} --> {1}", _midlgCuadrado2.GetType().Name, _midlgCuadrado2(numero)); Console.ReadLine(); }
protected async Task <IActionResult> WithContextAsync <T1>(Func <User, T1, Task <IActionResult> > callback) where T1 : class, IContainerDocument { if (callback is null) { throw new ArgumentNullException(nameof(callback)); } try { var tasks = new List <Task>() { UserService.CurrentUserAsync(OrganizationId, null), GetContextDocumentAsync <T1>() }; await tasks.WhenAll().ConfigureAwait(false); var arguments = tasks .Select(task => (object)((dynamic)task).Result) .ToArray(); return(await((Task <IActionResult>)callback.GetType().GetMethod(nameof(callback.Invoke)).Invoke(callback, arguments)).ConfigureAwait(false)); } catch (ErrorResultException exc) { return(exc.ToActionResult()); } }
public static Exception ArgumentNull <T>(Func <T> arg) { var message = "Argument of type '{0}' cannot be null".FormatInvariant(typeof(T)); var argName = arg.GetType().Name; return(new ArgumentNullException(argName, message)); }
public T GetModelBy <T, E>(Func <E, bool> selector = null) where E : class { try { if (selector == null) { throw new ArgumentNullException(ArgumentNullException); } E entity = GetSingleBy(selector); if (entity == null) { return(default(T)); } string typeName = selector.GetType().GenericTypeArguments[0].Name; dynamic translator = TranslatorFactory.Create(typeName); if (translator == null) { throw new Exception(TranslatorNullException); } return(translator.Translate(entity)); } catch (Exception) { throw; } }
internal UserDefinedFunction(Func <int, IEnumerable <dynamic>, IEnumerable <dynamic> > func) { udfProxy = SparkCLREnvironment.SparkCLRProxy.SparkContextProxy.CreateUserDefinedCSharpFunction( func.GetType().Name, SparkContext.BuildCommand(new CSharpWorkerFunc(func), SerializedMode.Row, SerializedMode.Row), Functions.GetReturnType(typeof(RT))); }
/// <summary> /// Initialize GenericFitness /// </summary> /// <param name="func">function to generate in BF</param> /// <param name="ga">Genetic algorithm</param> /// <param name="maxIterationCount">Max iteration count</param> /// <param name="trainingRatio">Pourcentage of all possible inputs taken into acount /// to calculate fitness. /// For example if <paramref name="T">T</paramref> is short and trainingRatio = 0.5, /// the number of test will be 0.5*sizeof(Short) = 128. /// traningRatio must be greater than 1. sizeof(T) and sizeof(TResult) must be less than 64 bits. /// </param> public GenericFitness(Func <T, TResult> func, GA ga, int maxIterationCount, double trainingRatio = 1) : base(ga, maxIterationCount) { _func = func; var type = _func.GetType(); var t = type.GetGenericArguments()[0]; var t_result = type.GetGenericArguments()[1]; if (!ValidStruct(t)) { throw new ArgumentException("Func<T, TResult> : T is not a valid struct", "func"); } if (!ValidStruct(t_result)) { throw new ArgumentException("Func<T, TResult> : TResult is not a valid struct", "func"); } input_size = Marshal.SizeOf(t); output_size = Marshal.SizeOf(t_result); _trainingRatio = trainingRatio > 0 ? trainingRatio : 1; if (Math.Pow(256, input_size) > long.MaxValue / _trainingRatio) { throw new ArgumentException("sizeof(T) * trainingRatio > long.MaxSize"); } if (_targetFitness == 0) { _targetFitness = 256 * 256 * input_size * _trainingRatio; } }
/// <summary> /// Adds the renderer. /// </summary> /// <param name="renderer">The renderer.</param> public void AddRenderer(Func <IRenderer> renderer) { if (_renderers == null) { _renderers = new Dictionary <string, Func <IRenderer> >(); } renderer().Extensions.Each(ext => { if (!_renderers.ContainsKey(ext)) { _renderers.Add(ext, renderer); } else { IRenderer alreadySet = _renderers[ext](); Logger.AddEntry("{0}::Renderer of type ({1}) for extension ({2}) has already been added, Renderer of type ({3}) will not be added", LogEventType.Warning, typeof(ServiceProxyResponder).Name, alreadySet.GetType().Name, ext, renderer.GetType().Name ); } }); }
public static void SetInputPrefix(object __instance, object input, out KeyValuePair <SObject, SObject> __state) { __state = new KeyValuePair <SObject, SObject>(null, null); Type IStorageType = __instance.GetType().Assembly.GetType("Pathoschild.Stardew.Automate.IStorage"); Type ITrackedStack = __instance.GetType().Assembly.GetType("Pathoschild.Stardew.Automate.ITrackedStack"); Type IConsumable = __instance.GetType().Assembly.GetType("Pathoschild.Stardew.Automate.IConsumable"); MethodInfo Instance_IsValidCrop = __instance.GetType().GetMethod("IsValidCrop"); Func <dynamic, bool> func = x => (bool)Instance_IsValidCrop.Invoke(__instance, new object[] { x }); Type[] TryGetIngredientParams = new Type[] { func.GetType(), typeof(int), IConsumable.MakeByRefType() }; MethodInfo IStorage_TryGetIngredient = input.GetType().GetMethod("TryGetIngredient", TryGetIngredientParams); object[] TryGetIngredientArgs = new object[] { func, 1, null }; bool ret = (bool)IStorage_TryGetIngredient.Invoke(input, TryGetIngredientArgs); if (ret) { //Save the State SObject Machine = (SObject)(MachineType.GetProperty("Machine", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance)); SObject crop = (SObject)IConsumable.GetProperty("Sample").GetValue(TryGetIngredientArgs[2]); __state = new KeyValuePair <SObject, SObject>(Machine, crop); } }
public Visitor <R> When <T>(Func <T, R> fun) { MethodInfo methodInfo = fun.GetType().GetMethod(nameof(Func <T, R> .Invoke)); dict.Add(typeof(T), new Tuple <object, MethodInfo>(fun, methodInfo)); return(this); }
public static int test_0_delegate_callvirt_fullaot () { Func<string> f = delegate () { return "A"; }; var f2 = (Func<Func<string>, string>)Delegate.CreateDelegate (typeof (Func<Func<string>, string>), null, f.GetType ().GetMethod ("Invoke")); var s = f2 (f); return s == "A" ? 0 : 1; }
public static void Add <T>(Func <T> schedule) where T : IPeriodicTask { var typeName = schedule.GetType().GetGenericArguments()[0]?.Name; if (typeName != null && !_schedules.ContainsKey(typeName)) { _schedules.Add(typeName, schedule()); } }
public static bool IsAwaitable <TResult>(this Func <TResult> action) where TResult : class { var resultType = action .GetType() .GetGenericArguments() .First(); return(resultType.IsGenericType && resultType.GetGenericTypeDefinition() == typeof(Task <>)); }
public TypedHandlerRegister WithAsyncSentHandler <TResult>(HandlerPriority priority, Func <TypedSentContext <TResult>, Task> handler) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } var handlerInfo = new TypedHandlerInfo { Handler = context => handler((TypedSentContext <TResult>)context), InitialConstructor = GetOrAddFromCtorCache(HandlerType.Sent, handler.GetType(), false, (Func <ITypedBuilderContext, HttpRequestMessage, HttpResponseMessage, TypedSentContext>)((ctx, request, response) => new TypedSentContext <TResult>(ctx, request, response))), ContinuationConstructor = GetOrAddFromCtorCache(HandlerType.Sent, handler.GetType(), true, (Func <TypedSentContext, TypedSentContext>)(ctx => new TypedSentContext <TResult>(ctx))), }; WithHandler(HandlerType.Sent, priority, handlerInfo); return(this); }
public static ServiceDescriptor Describe(Type serviceType, Func <IServiceProvider, object> factory, ServiceLifetime lifetime) { if (factory is null) { throw new ArgumentNullException(nameof(factory)); } return(new ServiceDescriptor(serviceType, factory.GetType().GetGenericArguments()[1], lifetime, null, factory)); }
public TypedHandlerRegister WithAsyncErrorHandler <TError>(HandlerPriority priority, Func <TypedErrorContext <TError>, Task> handler) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } var handlerInfo = new TypedHandlerInfo { Handler = context => handler((TypedErrorContext <TError>)context), InitialConstructor = GetOrAddFromCtorCache(HandlerType.Error, handler.GetType(), false, (Func <ITypedBuilderContext, HttpRequestMessage, HttpResponseMessage, object, TypedErrorContext>)((ctx, request, response, error) => new TypedErrorContext <TError>(ctx, request, response, TypeHelpers.CheckType <TError>(error, ctx.SuppressTypeMismatchExceptions)))), ContinuationConstructor = GetOrAddFromCtorCache(HandlerType.Error, handler.GetType(), true, (Func <TypedErrorContext, TypedErrorContext>)(ctx => new TypedErrorContext <TError>(ctx))), }; WithHandler(HandlerType.Error, priority, handlerInfo); return(this); }
internal static void EnsureInitialized(this IHttpRoute route, Func <IReadOnlyCollection <IHttpRoute> > initializer) { Debug.Assert(route.GetType().Name == "RouteCollectionRoute", "Extension method only intended to support testing RouteCollectionRoute.EnsureInitialized"); var type = route.GetType(); var method = type.GetRuntimeMethod(nameof(EnsureInitialized), new[] { initializer.GetType() }); method.Invoke(route, new object[] { initializer }); }
static void Main(string[] args) { Action <string> one = s => { return; }; Action <int, string> two = (i, s) => { return; }; Func <int, string> function = (i) => { return(null); }; var single = one.GetType().IsActionDelegate(); var dueces = two.GetType().IsActionDelegate(); var func = function.GetType().IsActionDelegate(); }
private void CreateExpressionDelegate() { var constructorInfo = typeof(Foo).GetConstructor(Type.EmptyTypes); var newExpression = Expression.New(constructorInfo); var lambda = Expression.Lambda <Func <Foo> >(newExpression); expressionDelegate = lambda.Compile(); var type = expressionDelegate.GetType(); }
private void GenerateMethodBody(ILGenerator generator, Jace.Execution.ParameterInfo[] parameters, Func <Dictionary <string, double>, double> function) { Type dictionaryType = typeof(Dictionary <string, double>); ConstructorInfo dictionaryConstructorInfo = dictionaryType.GetConstructor(Type.EmptyTypes); FieldInfo functionField = typeof(FuncAdapterArguments).GetField("function", BindingFlags.NonPublic | BindingFlags.Instance); generator.DeclareLocal(dictionaryType); generator.DeclareLocal(typeof(double)); generator.Emit(OpCodes.Newobj, dictionaryConstructorInfo); generator.Emit(OpCodes.Stloc_0); for (int i = 0; i < parameters.Length; i++) { Jace.Execution.ParameterInfo parameter = parameters[i]; generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Ldstr, parameter.Name); switch (i) { case 0: generator.Emit(OpCodes.Ldarg_1); break; case 1: generator.Emit(OpCodes.Ldarg_2); break; case 2: generator.Emit(OpCodes.Ldarg_3); break; default: generator.Emit(OpCodes.Ldarg, i + 1); break; } if (parameter.DataType != DataType.FloatingPoint) { generator.Emit(OpCodes.Conv_R8); } generator.Emit(OpCodes.Callvirt, dictionaryType.GetMethod("Add", new Type[] { typeof(string), typeof(double) })); } generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldfld, functionField); generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Callvirt, function.GetType().GetMethod("Invoke")); generator.Emit(OpCodes.Ret); }
/// <summary> /// 重试 /// </summary> /// <param name="reTryCount">重试次数</param> /// <param name="reTryAction">重试操作</param> /// <param name="reTryDelay">重试间隔</param> /// <param name="remark">备注</param> /// <returns>true:重试成功;false:重试失败</returns> public static ReTryRunResult <T> ReTryRun <T>(uint reTryCount, Func <ReTryRunResult <T> > reTryAction, TimeSpan?reTryDelay = null, string remark = "") { if (reTryCount <= 0) { throw new FException("reTryCount至少重试1次"); } if (reTryAction == null) { throw new FException("action不能为空"); } bool 是匿名方法 = reTryAction.GetType().Name.Contains("AnonymousType"); string methodName = 是匿名方法 ? "匿名方法" : reTryAction.Method.Name; for (uint i = 1; i <= reTryCount; i++) { if (i != 1) { LogHelper.Trace($"开始重试:{methodName} {remark}"); } try { //如果执行抛出异常,那么重试 var reTryRunResult = reTryAction(); if (!reTryRunResult.IsReTrySuccess) { bool 非最后一次 = i != reTryCount; if (非最后一次 && reTryDelay.HasValue) { Task.Delay(reTryDelay.Value).Wait(); } continue; } if (i != 1) { LogHelper.Trace($"重试{i}次成功:{methodName} {remark}"); } return(reTryRunResult); } catch (Exception ex) { LogHelper.Error(ex, $"{ex.Message} {remark}", "ReTryRun"); } } LogHelper.Trace($"重试失败:{methodName} {remark}"); return(new ReTryRunResult <T> { IsReTrySuccess = false }); }
private static void Describe(Func <string, string> hello) { var typ = hello.GetType(); Console.WriteLine("Type of function: " + typ); var targetType = hello.Target?.GetType(); Console.WriteLine("Target Type of function: " + targetType); }
/// <summary> /// Registers mapping configurations for specific types /// </summary> /// <typeparam name="TSource">source type</typeparam> /// <typeparam name="TTarget">target type</typeparam> /// <param name="func">the method which supplies mapping service between the types given in the type parameters</param> public void Register <T>(Func <T, IValidationResult> func) { var alreadyExists = _cache.Any(mapping => mapping.GetType() == func.GetType()); if (alreadyExists) { throw new Exception($"Validation configuration for {typeof(T)} has already been defined before"); } _cache.Add(func); }
/// <summary> /// Enumerate the types of handlers configured in the factory's pipeline. /// </summary> /// <returns> /// A sequence of 0 or more types. /// </returns> /// <remarks> /// This operation uses Reflection, so it can be relatively expensive; use sparingly. /// </remarks> public IEnumerable <Type> EnumerateHandlerTypes() { for (int handlerIndex = 0; handlerIndex < _handlerFactories.Count; handlerIndex++) { Func <DelegatingHandler> factory = _handlerFactories[handlerIndex]; Type factoryDelegateType = factory.GetType(); yield return(factoryDelegateType.GenericTypeArguments[0]); } }
private void AssociateView(Type viewType, Type presenterType) { // creo la view Object view = viewType.GetConstructor(Type.EmptyTypes).Invoke(new object[] { }); // creo il presenter passandogli la view presenterType.GetConstructor(new Type[] { viewType, _addItemDelegate.GetType(), _items.GetType() }) .Invoke(new object[] { view, _addItemDelegate, _items }); // mostro la view (view as Form).Show(); }
public void T02_factory_from_factory() { var container = new Container(log: Log); Func <Foo> factory = () => new Foo(); container.RegisterFactory(factory); var f = container.Resolve <Func <Foo> >(); Assert.Equal(factory.GetType(), f.GetType()); Assert.NotEqual(f(), f()); }
public void Subscribe <T>(Func <T, Task> handler) where T : class, IMessage { if (!_subscriptions.ContainsKey(typeof(T)) || typeof(T) is ICommand) { _subscriptions.Add(typeof(T), new List <ISubscription>()); } _subscriptions[typeof(T)].Add(new Subscription <T>(handler)); Console.WriteLine($"Subscribed {typeof(T).Name} with handler {handler.GetType().Name}."); }
public MailboxMessage(string key, Func <Task> task, TaskCompletionSource <object> taskCompletionSource = null) { if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentException("Value cannot be null or whitespace.", nameof(key)); } Key = key; HasReturnValue = task.GetType().GetGenericArguments()[0].IsGenericType; Task = task; TaskCompletionSource = taskCompletionSource ?? new TaskCompletionSource <object>(); }
public void Should_delegate_calls_to_delegate_generator_asking_about_delegate_proxy() { // Arrange var fake = new Func<int>(() => 10); var invoke = fake.GetType().GetMethod("Invoke"); string reason = null; A.CallTo(() => this.delegateProxyGenerator.MethodCanBeInterceptedOnInstance(invoke, fake, out reason)) .Returns(true).AssignsOutAndRefParameters("reason"); // Act string output = null; var result = this.selector.MethodCanBeInterceptedOnInstance(invoke, fake, out output); // Assert Assert.That(result, Is.True); Assert.That(output, Is.EqualTo("reason")); }
private void GenerateMethodBody(ILGenerator generator, Jace.Execution.ParameterInfo[] parameters, Func<Dictionary<string, double>, double> function) { Type dictionaryType = typeof(Dictionary<string, double>); ConstructorInfo dictionaryConstructorInfo = dictionaryType.GetConstructor(Type.EmptyTypes); FieldInfo functionField = typeof(FuncAdapterArguments).GetField("function", BindingFlags.NonPublic | BindingFlags.Instance); generator.DeclareLocal(dictionaryType); generator.DeclareLocal(typeof(double)); generator.Emit(OpCodes.Newobj, dictionaryConstructorInfo); generator.Emit(OpCodes.Stloc_0); for (int i = 0; i < parameters.Length; i++) { Jace.Execution.ParameterInfo parameter = parameters[i]; generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Ldstr, parameter.Name); switch (i) { case 0: generator.Emit(OpCodes.Ldarg_1); break; case 1: generator.Emit(OpCodes.Ldarg_2); break; case 2: generator.Emit(OpCodes.Ldarg_3); break; default: generator.Emit(OpCodes.Ldarg, i + 1); break; } if (parameter.DataType != DataType.FloatingPoint) generator.Emit(OpCodes.Conv_R8); generator.Emit(OpCodes.Callvirt, dictionaryType.GetMethod("Add", new Type[] { typeof(string), typeof(double) })); } generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldfld, functionField); generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Callvirt, function.GetType().GetMethod("Invoke")); generator.Emit(OpCodes.Ret); }