/// <summary> /// Execute an asynchronous redis operation. /// </summary> /// <typeparam name="T">The result type</typeparam> /// <param name="obj">The this object</param> /// <param name="message">The message</param> /// <param name="processor">The result processor</param> /// <param name="server">The server</param> /// <returns>An asynchronous task.</returns> public static object ExecuteAsync <T>(object obj, object message, object processor, object server) { var resultType = typeof(Task <T>); var asm = obj.GetType().Assembly; var batchType = asm.GetType("StackExchange.Redis.RedisBatch"); var messageType = asm.GetType("StackExchange.Redis.Message"); var processorType = asm.GetType("StackExchange.Redis.ResultProcessor`1").MakeGenericType(typeof(T)); var serverType = asm.GetType("StackExchange.Redis.ServerEndPoint"); var originalMethod = DynamicMethodBuilder <Func <object, object, object, object, Task <T> > > .CreateMethodCallDelegate( obj.GetType(), "ExecuteAsync", new Type[] { messageType, processorType, serverType }, new Type[] { resultType }); // we only trace RedisBatch methods here if (obj.GetType() == batchType) { using (var scope = CreateScope(obj, message, server)) { return(scope.Span.Trace(() => originalMethod(obj, message, processor, server))); } } else { return(originalMethod(obj, message, processor, server)); } }
/// <summary> /// ExecuteAsync calls the underlying ExecuteAsync and traces the request. /// </summary> /// <param name="this">The Api Controller</param> /// <param name="controllerContext">The controller context for the call</param> /// <param name="cancellationTokenSource">The cancellation token source</param> /// <returns>A task with the result</returns> public static object ExecuteAsync(object @this, object controllerContext, object cancellationTokenSource) { Type controllerType = @this.GetType(); // in some cases, ExecuteAsync() is an explicit interface implementation, // which is not public and has a different name, so try both var executeAsyncFunc = DynamicMethodBuilder <Func <object, object, CancellationToken, object> > .GetOrCreateMethodCallDelegate(controllerType, "ExecuteAsync") ?? DynamicMethodBuilder <Func <object, object, CancellationToken, object> > .GetOrCreateMethodCallDelegate(controllerType, "System.Web.Http.Controllers.IHttpController.ExecuteAsync"); using (Scope scope = CreateScope(controllerContext)) { return(scope.Span.Trace( () => { CancellationToken cancellationToken = ((CancellationTokenSource)cancellationTokenSource).Token; return executeAsyncFunc(@this, controllerContext, cancellationToken); }, onComplete: e => { if (e != null) { scope.Span.SetException(e); } // some fields aren't set till after execution, so repopulate anything missing UpdateSpan(controllerContext, scope.Span); scope.Span.Finish(); })); } }
private static async Task <object> ExecuteAsyncInternal(object wireProtocol, object connection, CancellationToken cancellationToken) { if (wireProtocol == null) { throw new ArgumentNullException(nameof(wireProtocol)); } var executeAsync = DynamicMethodBuilder <Func <object, object, CancellationToken, Task <object> > > .GetOrCreateMethodCallDelegate( wireProtocol.GetType(), "ExecuteAsync"); using (var scope = CreateScope(wireProtocol, connection)) { try { return(await executeAsync(wireProtocol, connection, cancellationToken).ConfigureAwait(false)); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
/// <summary> /// ExecuteReader traces any SQL call. /// </summary> /// <param name="this">The "this" pointer for the method call.</param> /// <param name="behavior">The behavior.</param> /// <param name="method">The method.</param> /// <returns>The original methods return.</returns> public static object ExecuteReaderWithMethod(dynamic @this, int behavior, string method) { var command = (DbCommand)@this; if (_executeReaderWithMethod == null) { _executeReaderWithMethod = DynamicMethodBuilder.CreateMethodCallDelegate <Func <object, CommandBehavior, string, object> >( command.GetType(), "ExecuteReader", isStatic: false); } using (var scope = CreateScope(command)) { try { return(_executeReaderWithMethod(command, (CommandBehavior)behavior, method)); } catch (Exception ex) { scope.Span.SetException(ex); throw; } } }
public static T ExecuteSyncImpl <T>(object multiplexer, object message, object processor, object server) { var resultType = typeof(T); var multiplexerType = multiplexer.GetType(); var asm = multiplexerType.Assembly; var messageType = asm.GetType("StackExchange.Redis.Message"); var processorType = asm.GetType("StackExchange.Redis.ResultProcessor`1").MakeGenericType(resultType); var serverType = asm.GetType("StackExchange.Redis.ServerEndPoint"); var originalMethod = DynamicMethodBuilder <Func <object, object, object, object, T> > .CreateMethodCallDelegate( multiplexerType, "ExecuteSyncImpl", new[] { messageType, processorType, serverType }, new[] { resultType }); using (var scope = CreateScope(multiplexer, message)) { try { return(originalMethod(multiplexer, message, processor, server)); } catch (Exception ex) { scope.Span.SetException(ex); throw; } } }
/// <summary> /// ExecuteReader traces any SQL call. /// </summary> /// <param name="this">The "this" pointer for the method call.</param> /// <param name="behavior">The behavior.</param> /// <returns>The original methods return.</returns> public static object ExecuteReader(dynamic @this, int behavior) { var command = (DbCommand)@this; if (_executeReader == null) { _executeReader = DynamicMethodBuilder <Func <object, CommandBehavior, object> > .CreateMethodCallDelegate( command.GetType(), "ExecuteReader", new Type[] { typeof(CommandBehavior) }); } using (var scope = CreateScope(command)) { try { return(_executeReader(command, (CommandBehavior)behavior)); } catch (Exception ex) { scope.Span.SetException(ex); throw; } } }
/// <summary> /// Calls the underlying ExecuteAsync and traces the request. /// </summary> /// <param name="apiController">The Api Controller</param> /// <param name="controllerContext">The controller context for the call</param> /// <param name="cancellationToken">The cancellation token</param> /// <returns>A task with the result</returns> private static async Task <HttpResponseMessage> ExecuteAsyncInternal(object apiController, object controllerContext, CancellationToken cancellationToken) { Type controllerType = apiController.GetType(); // in some cases, ExecuteAsync() is an explicit interface implementation, // which is not public and has a different name, so try both var executeAsyncFunc = DynamicMethodBuilder <Func <object, object, CancellationToken, Task <HttpResponseMessage> > > .GetOrCreateMethodCallDelegate(controllerType, "ExecuteAsync") ?? DynamicMethodBuilder <Func <object, object, CancellationToken, Task <HttpResponseMessage> > > .GetOrCreateMethodCallDelegate(controllerType, "System.Web.Http.Controllers.IHttpController.ExecuteAsync"); using (Scope scope = CreateScope(controllerContext)) { try { var responseMessage = await executeAsyncFunc(apiController, controllerContext, cancellationToken).ConfigureAwait(false); // some fields aren't set till after execution, so populate anything missing UpdateSpan(controllerContext, scope.Span); return(responseMessage); } catch (Exception ex) { scope.Span.SetException(ex); throw; } } }
/// <summary> /// Execute an asynchronous redis operation. /// </summary> /// <typeparam name="T">The result type</typeparam> /// <param name="multiplexer">The connection multiplexer running the command.</param> /// <param name="message">The message to send to redis.</param> /// <param name="processor">The processor to handle the result.</param> /// <param name="state">The state to use for the task.</param> /// <param name="server">The server to call.</param> /// <returns>An asynchronous task.</returns> private static async Task <T> ExecuteAsyncImplInternal <T>(object multiplexer, object message, object processor, object state, object server) { var genericType = typeof(T); var multiplexerType = multiplexer.GetType(); var asm = multiplexerType.Assembly; var messageType = asm.GetType("StackExchange.Redis.Message"); var processorType = asm.GetType("StackExchange.Redis.ResultProcessor`1").MakeGenericType(genericType); var stateType = typeof(object); var serverType = asm.GetType("StackExchange.Redis.ServerEndPoint"); var originalMethod = DynamicMethodBuilder <Func <object, object, object, object, object, Task <T> > > .CreateMethodCallDelegate( multiplexerType, "ExecuteAsyncImpl", new[] { messageType, processorType, stateType, serverType }, new[] { genericType }); using (var scope = CreateScope(multiplexer, message)) { try { return(await originalMethod(multiplexer, message, processor, state, server).ConfigureAwait(false)); } catch (Exception ex) { scope.Span.SetException(ex); throw; } } }
public static object Execute(object wireProtocol, object connection, object cancellationTokenSource) { // TResult MongoDB.Driver.Core.WireProtocol.IWireProtocol<TResult>.Execute(IConnection connection, CancellationToken cancellationToken) if (wireProtocol == null) { throw new ArgumentNullException(nameof(wireProtocol)); } var execute = DynamicMethodBuilder <Func <object, object, CancellationToken, object> > .GetOrCreateMethodCallDelegate( wireProtocol.GetType(), "Execute"); using (var scope = CreateScope(wireProtocol, connection)) { try { var tokenSource = cancellationTokenSource as CancellationTokenSource; var cancellationToken = tokenSource?.Token ?? CancellationToken.None; return(execute(wireProtocol, connection, cancellationToken)); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="TResponse">Type type of the response</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <returns>The original result</returns> private static async Task <TResponse> CallElasticsearchAsyncInternal <TResponse>(object pipeline, object requestData, CancellationToken cancellationToken) { if (_requestDataType == null) { _requestDataType = requestData.GetType(); } var originalMethod = DynamicMethodBuilder <Func <object, object, CancellationToken, Task <TResponse> > > .GetOrCreateMethodCallDelegate( pipeline.GetType(), "CallElasticsearchAsync", new[] { _requestDataType, CancellationTokenType }, new[] { typeof(TResponse) }); using (var scope = CreateScope(pipeline, requestData)) { try { return(await originalMethod(pipeline, requestData, cancellationToken).ConfigureAwait(false)); } catch (Exception ex) { scope.Span.SetException(ex); throw; } } }
/// <summary> /// 调用初始化拦截器的方法。 /// </summary> /// <param name="emitter"></param> /// <param name="initMethod"></param> /// <returns></returns> private static EmitHelper CallInitialize(this EmitHelper emitter, DynamicMethodBuilder initMethod) { return(emitter .ldarg_0 .ldloc(STACK_INTERCEPTOR_LIST_INDEX) .ldloc(STACK_CALLINFO_INDEX) .call(initMethod.MethodBuilder)); }
public static void GetDiv() { var func = new DynamicMethodBuilder <Func <int, int, int> >("GetDiv") .IL(il => il .Divide(il.LoadArgument(0, 1)) // пусть принимает Builder? .Return()) .Build(); }
public static void GetRem() { var func = new DynamicMethodBuilder <Func <int, int, int> >("GetRem") .IL(il => il .Remainder(il.LoadArgument(0, 1)) .Return()) .Build(); }
/// <summary> /// 调用拦截器。 /// </summary> /// <param name="emitter"></param> /// <param name="interceptMethod"></param> /// <param name="interceptType"></param> /// <returns></returns> private static EmitHelper CallInterceptors(this EmitHelper emitter, DynamicMethodBuilder interceptMethod, InterceptType interceptType) { return(emitter .ldarg_0 .ldloc(STACK_INTERCEPTOR_LIST_INDEX) .ldloc(STACK_CALLINFO_INDEX) .ldc_i4((int)interceptType) .call(interceptMethod.MethodBuilder)); }
public static Func <T> GetEmptyObject2 <T>() { var func = new DynamicMethodBuilder <Func <T> >("GetEmptyObject") .Locals <Types <T> >() .IL(il => il .Return(il.LoadLocal(0))) .Build(); return(func); }
protected override IMethodBuilder GetMethodBuilder() { var dynamicMethodBuilder = new DynamicMethodBuilder(); var field = typeof(DynamicMethodBuilder).GetField( "methodSkeletonFactory", BindingFlags.Instance | BindingFlags.NonPublic); var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DynamicMethodAssembly.dll"); Func<IDynamicMethodSkeleton> methodSkeletonFactory = () => new InterceptionMethodBuilderMethodSkeleton(path); field.SetValue(dynamicMethodBuilder, methodSkeletonFactory); return dynamicMethodBuilder; }
/// <summary> /// Traces SendReceive. /// </summary> /// <typeparam name="T">The return type</typeparam> /// <param name="redisNativeClient">The redis native client</param> /// <param name="cmdWithBinaryArgs">The command with args</param> /// <param name="fn">The function</param> /// <param name="completePipelineFn">An optional function to call to complete a pipeline</param> /// <param name="sendWithoutRead">Whether or to send without waiting for the result</param> /// <returns>The original result</returns> public static T SendReceive <T>(object redisNativeClient, byte[][] cmdWithBinaryArgs, object fn, object completePipelineFn, bool sendWithoutRead) { var originalMethod = DynamicMethodBuilder <Func <object, byte[][], object, object, bool, T> > .GetOrCreateMethodCallDelegate( redisNativeClient.GetType(), "SendReceive", methodGenericArguments : new Type[] { typeof(T) }); using (var scope = Integrations.Redis.CreateScope(GetHost(redisNativeClient), GetPort(redisNativeClient), GetRawCommand(cmdWithBinaryArgs))) { return((T)scope.Span.Trace(() => originalMethod(redisNativeClient, cmdWithBinaryArgs, fn, completePipelineFn, sendWithoutRead))); } }
public static Func <T> GetEmptyObject <T>() { var func = new DynamicMethodBuilder <Func <T> >("GetEmptyObject") .IL(il => il .NewObject <T>() .Return()) .Build(); return(func); }
public static void GetDivRemAdd() { var func = new DynamicMethodBuilder <Func <int, int, int> >("GetDivRemAdd") .IL(il => il .Divide(il.LoadArgument(0), il.LoadArgument(1)) .Remainder(il.LoadArgument(0), il.LoadArgument(1)) .Add() .Return()) .Build(); }
internal static DynamicMethod CreateInvokeExact(MethodType type) { FinishTypes(type); DynamicMethodBuilder dm = new DynamicMethodBuilder("InvokeExact", type, typeof(MethodHandle), null, null, null, false); Type targetDelegateType = GetMemberWrapperDelegateType(type.insertParameterTypes(0, CoreClasses.java.lang.invoke.MethodHandle.Wrapper.ClassObject)); dm.ilgen.Emit(OpCodes.Ldarg_0); dm.ilgen.Emit(OpCodes.Ldfld, typeof(MethodHandle).GetField("form", BindingFlags.Instance | BindingFlags.NonPublic)); dm.ilgen.Emit(OpCodes.Ldfld, typeof(LambdaForm).GetField("vmentry", BindingFlags.Instance | BindingFlags.NonPublic)); if (type.returnType() == java.lang.Void.TYPE) { dm.ilgen.Emit(OpCodes.Call, typeof(MethodHandleUtil).GetMethod("GetVoidAdapter", BindingFlags.Static | BindingFlags.NonPublic)); } else { dm.ilgen.Emit(OpCodes.Ldfld, typeof(MemberName).GetField("vmtarget", BindingFlags.Instance | BindingFlags.NonPublic)); } dm.ilgen.Emit(OpCodes.Castclass, targetDelegateType); dm.ilgen.Emit(OpCodes.Ldarg_0); for (int i = 0; i < type.parameterCount(); i++) { dm.Ldarg(i); TypeWrapper tw = TypeWrapper.FromClass(type.parameterType(i)); if (tw.IsNonPrimitiveValueType) { tw.EmitBox(dm.ilgen); } else if (tw.IsGhost) { tw.EmitConvSignatureTypeToStackType(dm.ilgen); } else if (tw == PrimitiveTypeWrapper.BYTE) { dm.ilgen.Emit(OpCodes.Conv_I1); } } dm.CallDelegate(targetDelegateType); TypeWrapper retType = TypeWrapper.FromClass(type.returnType()); if (retType.IsNonPrimitiveValueType) { retType.EmitUnbox(dm.ilgen); } else if (retType.IsGhost) { retType.EmitConvStackTypeToSignatureType(dm.ilgen, null); } else if (!retType.IsPrimitive && retType != CoreClasses.java.lang.Object.Wrapper) { dm.EmitCheckcast(retType); } dm.Ret(); dm.ilgen.DoEmit(); return(dm.dm); }
protected override IMethodBuilder GetMethodBuilder() { var dynamicMethodBuilder = new DynamicMethodBuilder(); var field = typeof(DynamicMethodBuilder).GetField( "methodSkeletonFactory", BindingFlags.Instance | BindingFlags.NonPublic); var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DynamicMethodAssembly.dll"); Func <IDynamicMethodSkeleton> methodSkeletonFactory = () => new InterceptionMethodBuilderMethodSkeleton(path); field.SetValue(dynamicMethodBuilder, methodSkeletonFactory); return(dynamicMethodBuilder); }
public static void AfterAction( object diagnosticSource, object actionDescriptor, object httpContext, object routeData) { AspNetCoreMvc2Integration integration = null; try { if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems)) { integration = contextItems?[HttpContextKey] as AspNetCoreMvc2Integration; } } catch (Exception ex) { Log.ErrorExceptionForFilter($"Error accessing {nameof(AspNetCoreMvc2Integration)}.", ex); } try { if (_afterAction == null) { var type = actionDescriptor.GetType().Assembly.GetType("Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions"); _afterAction = DynamicMethodBuilder <Action <object, object, object, object> > .CreateMethodCallDelegate( type, "AfterAction"); } } catch { // TODO: log this as an instrumentation error, we cannot call instrumented method, // profiled app will continue working without DiagnosticSource } try { // call the original method, catching and rethrowing any unhandled exceptions _afterAction?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData); } catch (Exception ex) { integration?.SetException(ex); throw; } finally { integration?.Dispose(); } }
/// <summary> /// CallElasticsearch traces a call to Elasticsearch /// </summary> /// <typeparam name="TResponse">The type of the response</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <returns>The original result</returns> public static object CallElasticsearch <TResponse>(object pipeline, object requestData) { var originalMethod = DynamicMethodBuilder <Func <object, object, TResponse> > .GetOrCreateMethodCallDelegate( pipeline.GetType(), "CallElasticsearch", methodGenericArguments : new Type[] { typeof(TResponse) }); return(CreateScope(pipeline, requestData).Span.Trace(() => { return originalMethod(pipeline, requestData); })); }
protected override IMethodBuilder GetMethodBuilder() { var dynamicMethodBuilder = new DynamicMethodBuilder(); var field = typeof(DynamicMethodBuilder).GetField( "methodSkeletonFactory", BindingFlags.Instance | BindingFlags.NonPublic); var path = Path.Combine(Path.GetDirectoryName(new Uri(typeof(DynamicMethodBuilderVerificationTests).Assembly.CodeBase).LocalPath), "DynamicMethodAssembly.dll"); Func <IDynamicMethodSkeleton> methodSkeletonFactory = () => new InterceptionMethodBuilderMethodSkeleton(path); field.SetValue(dynamicMethodBuilder, methodSkeletonFactory); return(dynamicMethodBuilder); }
internal IdentityField(IdentitySpecification <TEntity> identitySpecification) { this.identitySpecification = identitySpecification; this.nextIdentity = this.identitySpecification.Seed; MemberExpression member = ExpressionHelper.FindMemberExpression(identitySpecification.IdentityColumn.Body); PropertyInfo identityInfo = member.Member as PropertyInfo; this.identityType = identityInfo.PropertyType; this.identitySetter = DynamicMethodBuilder.CreatePropertySetter <TEntity>(identityInfo); this.identityGetter = this.identitySpecification.IdentityColumn.Compile(); }
/// <summary> /// Wrapper method used to instrument Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions.AfterAction() /// </summary> /// <param name="diagnosticSource">The DiagnosticSource that this extension method was called on.</param> /// <param name="actionDescriptor">An ActionDescriptor with information about the current action.</param> /// <param name="httpContext">The HttpContext for the current request.</param> /// <param name="routeData">A RouteData with information about the current route.</param> public static void AfterAction( object diagnosticSource, object actionDescriptor, dynamic httpContext, object routeData) { AspNetCoreMvc2Integration integration = null; try { IDictionary <object, object> contextItems = httpContext?.Items; integration = contextItems?[HttpContextKey] as AspNetCoreMvc2Integration; } catch { // TODO: log this as an instrumentation error, but continue calling instrumented method } try { if (_afterAction == null) { Type type = actionDescriptor.GetType().Assembly.GetType("Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions"); _afterAction = DynamicMethodBuilder.CreateMethodCallDelegate <Action <object, object, object, object> >( type, "AfterAction", isStatic: true); } } catch { // TODO: log this as an instrumentation error, we cannot call instrumented method, // profiled app will continue working without DiagnosticSource } try { // call the original method, catching and rethrowing any unhandled exceptions _afterAction?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData); } catch (Exception ex) { integration?.SetException(ex); throw; } finally { integration?.Dispose(); } }
public static void BeforeAction( object diagnosticSource, object actionDescriptor, object httpContext, object routeData) { AspNetCoreMvc2Integration integration = null; try { integration = new AspNetCoreMvc2Integration(actionDescriptor, httpContext); if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems)) { contextItems[HttpContextKey] = integration; } } catch (Exception ex) { Log.ErrorExceptionForFilter($"Error creating {nameof(AspNetCoreMvc2Integration)}.", ex); } try { if (_beforeAction == null) { var assembly = actionDescriptor.GetType().GetTypeInfo().Assembly; var type = assembly.GetType("Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions"); _beforeAction = DynamicMethodBuilder <Action <object, object, object, object> > .CreateMethodCallDelegate( type, "BeforeAction"); } } catch (Exception ex) { // profiled app will continue working without DiagnosticSource Log.ErrorException("Error calling Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions.BeforeAction()", ex); } try { // call the original method, catching and rethrowing any unhandled exceptions _beforeAction?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData); } catch (Exception ex) when(integration?.SetException(ex) ?? false) { // unreachable code throw; } }
// called from InvokeExact DynamicMethod and ByteCodeHelper.GetDelegateForInvokeBasic() internal static object GetVoidAdapter(MemberName mn) { MethodType type = mn.getMethodType(); if (type.voidAdapter == null) { if (type.returnType() == java.lang.Void.TYPE) { return(mn.vmtarget); } type.voidAdapter = DynamicMethodBuilder.CreateVoidAdapter(type); } return(type.voidAdapter); }
public static void BeforeAction( object diagnosticSource, object actionDescriptor, dynamic httpContext, object routeData) { AspNetCoreMvc2Integration integration = null; try { integration = new AspNetCoreMvc2Integration(actionDescriptor, httpContext); IDictionary <object, object> contextItems = httpContext.Items; contextItems[HttpContextKey] = integration; } catch { // TODO: log this as an instrumentation error, but continue calling instrumented method } try { if (_beforeAction == null) { Assembly assembly = actionDescriptor.GetType().GetTypeInfo().Assembly; Type type = assembly.GetType("Microsoft.AspNetCore.Mvc.Internal.MvcCoreDiagnosticSourceExtensions"); _beforeAction = DynamicMethodBuilder <Action <object, object, object, object> > .CreateMethodCallDelegate( type, "BeforeAction"); } } catch { // TODO: log this as an instrumentation error, we cannot call instrumented method, // profiled app will continue working without DiagnosticSource } try { // call the original method, catching and rethrowing any unhandled exceptions _beforeAction?.Invoke(diagnosticSource, actionDescriptor, httpContext, routeData); } catch (Exception ex) { integration?.SetException(ex); throw; } }
public static object GetIlComparer() { var t = typeof(object); var compGen = typeof(ILEqualityComparer <>).MakeGenericType(t); var def = compGen.GetProperty("Default") !.GetMethod !; var eq = compGen.GetMethod(nameof(Equals), new[] { t, t }) !; var func = new DynamicMethodBuilder <Func <object> >("GetDiv") .IL(il => il .Call(def).CastClass(typeof(object)).Return()) .Build(); var a = func(); return(a); }
/// <summary> /// Get the configuration for the multiplexer. /// </summary> /// <param name="multiplexer">The multiplexer</param> /// <returns>The configuration</returns> public static string GetConfiguration(object multiplexer) { try { if (_getConfigurationMethod == null) { _getConfigurationMethod = DynamicMethodBuilder <Func <object, string> > .CreateMethodCallDelegate(multiplexer.GetType(), "get_Configuration"); } return(_getConfigurationMethod(multiplexer)); } catch { return(null); } }