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);
}
