public void CreateInterfaceProxyWithTargetInterface()
{
ProxyGenerator generator = new ProxyGenerator();
IFooExtended proxiedFoo = (IFooExtended)generator.CreateInterfaceProxyWithTargetInterface(
typeof(IFooExtended), new ImplementedFoo(), new StandardInterceptor());
proxiedFoo.FooExtended();
}
internal static IServiceRemotingListener CreateServiceRemotingListener <TImplementation>(
ServiceContext context,
Type[] ifaces,
IServiceProvider container)
{
var client = container.GetRequiredService <TelemetryClient>();
Type firstIface = ifaces[0];
Type[] additionalIfaces = ifaces.Skip(1).ToArray();
var gen = new ProxyGenerator();
var impl = (IService)gen.CreateInterfaceProxyWithTargetInterface(
firstIface,
additionalIfaces,
(object)null,
new InvokeInNewScopeInterceptor <TImplementation>(container),
new LoggingServiceInterceptor(context, client));
return(new FabricTransportServiceRemotingListener(
context,
new ActivityServiceRemotingMessageDispatcher(context, impl, null)));
}
public void InterceptCatchesExceptions()
{
var telemetryChannel = new FakeChannel();
var config = new TelemetryConfiguration("00000000-0000-0000-0000-000000000001", telemetryChannel);
var client = new TelemetryClient(config);
var service = new Mock <IFakeService>();
service.Setup(s => s.TestServiceMethod()).Throws(new InvalidOperationException("Test Exception Text"));
var collection = new ServiceCollection();
collection.AddSingleton(client);
MockBuilder.RegisterStatelessServiceContext(collection);
collection.AddSingleton(service.Object);
ServiceProvider provider = collection.BuildServiceProvider();
var gen = new ProxyGenerator();
var impl = (IFakeService)gen.CreateInterfaceProxyWithTargetInterface(
typeof(IFakeService),
new Type[0],
(object)null,
new InvokeInNewScopeInterceptor <IFakeService>(provider));
var ex = (((Func <object>)(() => impl.TestServiceMethod()))).Should().Throw <InvalidOperationException>().Which;
ex.Message.Should().Be("Test Exception Text");
client.Flush();
RequestTelemetry requestTelemetry = telemetryChannel.Telemetry.OfType <RequestTelemetry>().FirstOrDefault();
requestTelemetry.Should().NotBeNull();
requestTelemetry.Success.Should().BeFalse();
ExceptionTelemetry exceptionTelemetry = telemetryChannel.Telemetry.OfType <ExceptionTelemetry>().FirstOrDefault();
exceptionTelemetry.Should().NotBeNull();
exceptionTelemetry.Exception.Should().BeSameAs(ex);
}
public static void AddApplication(this IServiceCollection services, IConfiguration configuration)
{
services.Configure <ProjectSettings>(configuration.Bind);
services.AddAutoMapper(typeof(ApplicationRegistry));
services.AddValidatorsFromAssembly(typeof(ApplicationRegistry).Assembly);
services.AddDNTNumbering(options =>
{
options.NumberedEntityMap[typeof(Task)] = new NumberedEntityOption
{
Start = 100,
Prefix = "Task-",
IncrementBy = 5
};
});
services.Scan(scan => scan
.FromCallingAssembly()
.AddClasses(classes => classes.AssignableTo <ISingletonDependency>())
.AsMatchingInterface()
.WithSingletonLifetime()
.AddClasses(classes => classes.AssignableTo <IScopedDependency>())
.AsMatchingInterface()
.WithScopedLifetime()
.AddClasses(classes => classes.AssignableTo <ITransientDependency>())
.AsMatchingInterface()
.WithTransientLifetime()
.AddClasses(classes => classes.AssignableTo(typeof(IBusinessEventHandler <>)))
.AsImplementedInterfaces()
.WithTransientLifetime());
foreach (var descriptor in services.Where(s => typeof(IApplicationService).IsAssignableFrom(s.ServiceType))
.ToList())
{
services.Decorate(descriptor.ServiceType, (target, serviceProvider) =>
ProxyGenerator.CreateInterfaceProxyWithTargetInterface(
descriptor.ServiceType,
target, serviceProvider.GetRequiredService <ValidationInterceptor>(),
(IInterceptor)serviceProvider.GetRequiredService <TransactionInterceptor>()));
}
}
public static IServiceCollection AddApp(this IServiceCollection services)
{
return(services
.AddSingleton <IStartup, ST.Startup>()
.AddSingleton <MainForm>()
.AddSingleton <IAppConfiguration, AppConfiguration>()
.AddSingleton <IRepoHolder, RepoHolder>()
.AddSingleton <IGitFileRepo, GitFileRepo>()
.AddSingleton <IProjectFileRepo, ProjectFileRepo>()
.AddSingleton <ITabsRepoBuilder, TabsRepoBuilder>()
.AddSingleton <IAppSemaphoreSlim, AppSemaphoreSlim>()
.AddSingleton <IGitVersion, RepoCommandProcessor>()
.AddSingleton <ILoggerFactory>(sp =>
{
var eventSetting = new EventLogSettings
{
Filter = (msg, level) => level > LogLevel.Debug,
SourceName = "GitLooker"
};
var provider = new EventLogLoggerProvider(eventSetting);
return new LoggerFactory(new[] { provider });
})
.AddLogging()
.AddSingleton(typeof(ILogger <>), typeof(Logger <>))
.AddSingleton <IGitValidator, GitValidator>()
.AddTransient <IProcessShell, ProcessShell>()
.AddTransient <IRepoCommandProcessor, RepoCommandProcessor>()
.AddTransient <RepoCommandProcessorController>()
.AddTransient <SemaphoreInteractionInterceptor>()
.AddTransient <TabReposControl>()
.AddTransient(service =>
{
var myInterceptedClass = service.GetService <RepoCommandProcessorController>();
var interceptor = service.GetService <SemaphoreInteractionInterceptor>();
var proxy = new ProxyGenerator();
return proxy.CreateInterfaceProxyWithTargetInterface <IRepoCommandProcessorController>(myInterceptedClass, interceptor);
})
.AddTransient <RepoControl>());
}
public void Cache_With_AOP()
{
ProxyGenerator proxyGenerator = new ProxyGenerator();
IRepository repository = new Repository();
IRepository repositoryProxy = proxyGenerator.CreateInterfaceProxyWithTargetInterface <IRepository>(repository, new CacheInterceptor());
Debug.WriteLine("First run...");
IList <string> languages = repositoryProxy.GetLanguages();
Assert.AreEqual <string>("English", languages[0]);
Assert.AreEqual <string>("Japanese", languages[1]);
Assert.AreEqual <string>("Simplified Chinese", languages[2]);
Assert.AreEqual <string>("Traditional Chinese", languages[3]);
Debug.WriteLine("Second run...");
IList <string> cachedLanguages = repositoryProxy.GetLanguages();
Assert.AreEqual <string>("English", cachedLanguages[0]);
Assert.AreEqual <string>("Japanese", cachedLanguages[1]);
Assert.AreEqual <string>("Simplified Chinese", cachedLanguages[2]);
Assert.AreEqual <string>("Traditional Chinese", cachedLanguages[3]);
Debug.WriteLine("First run...");
IList <Setting> settings = repositoryProxy.GetSettings();
Assert.AreEqual <string>("Domain", settings[0].Name);
Assert.AreEqual <string>("dev.pete.tw", settings[0].Value);
Assert.AreEqual <string>("Administrator", settings[1].Name);
Assert.AreEqual <string>("Pete", settings[1].Value);
Debug.WriteLine("Second run...");
IList <Setting> cachedSettings = repositoryProxy.GetSettings();
Assert.AreEqual <string>("Domain", cachedSettings[0].Name);
Assert.AreEqual <string>("dev.pete.tw", cachedSettings[0].Value);
Assert.AreEqual <string>("Administrator", cachedSettings[1].Name);
Assert.AreEqual <string>("Pete", cachedSettings[1].Value);
}
public static void AddApplication(this IServiceCollection services, IConfiguration configuration)
{
services.Configure <ProjectSetting>(configuration.Bind);
services.AddAutoMapper(typeof(ApplicationRegistry));
services.AddValidatorsFromAssemblyContaining(typeof(ApplicationRegistry));
services.Scan(scan => scan
.FromCallingAssembly()
.AddClasses(classes => classes.AssignableTo <ISingletonDependency>())
.AsMatchingInterface()
.WithSingletonLifetime()
.AddClasses(classes => classes.AssignableTo <IScopedDependency>())
.AsMatchingInterface()
.WithScopedLifetime()
.AddClasses(classes => classes.AssignableTo <ITransientDependency>())
.AsMatchingInterface()
.WithTransientLifetime()
.AddClasses(classes => classes.AssignableTo(typeof(IBusinessEventHandler <>)))
.AsImplementedInterfaces()
.WithTransientLifetime()
.AddClasses(classes => classes.AssignableTo(typeof(IModelValidator <>)))
.AsImplementedInterfaces()
.WithTransientLifetime()
.AddClasses(classes => classes.AssignableTo(typeof(IMapper <,>)))
.AsImplementedInterfaces()
.WithTransientLifetime());
foreach (var descriptor in services.Where(s => typeof(IApplicationService).IsAssignableFrom(s.ServiceType))
.ToList())
{
services.Decorate(descriptor.ServiceType, (target, serviceProvider) =>
ProxyGenerator.CreateInterfaceProxyWithTargetInterface(
descriptor.ServiceType,
target, serviceProvider.GetRequiredService <ValidationInterceptor>(),
serviceProvider.GetRequiredService <TransactionInterceptor>()));
}
}
public override object Create(IKernel kernel, object instance, ComponentModel model,
CreationContext context, params object[] constructorArguments)
{
var channelHolder = instance as IWcfChannelHolder;
if (channelHolder == null)
{
throw new ArgumentException(string.Format("Given instance is not an {0}", typeof(IWcfChannelHolder)), "instance");
}
var isDuplex = IsDuplex(channelHolder.RealProxy);
var proxyOptions = model.ObtainProxyOptions();
var serviceContract = model.GetServiceContract();
var remainingServices = model.Services.Except(new[] { serviceContract });
var generationOptions = CreateProxyGenerationOptions(serviceContract, proxyOptions, kernel, context);
generationOptions.AddMixinInstance(channelHolder);
var additionalInterfaces = GetInterfaces(remainingServices, proxyOptions, isDuplex);
var interceptors = GetInterceptors(kernel, model, serviceContract, channelHolder, context);
return(generator.CreateInterfaceProxyWithTargetInterface(serviceContract,
additionalInterfaces, channelHolder.Channel, generationOptions, interceptors));
}
/// <summary>
/// Creates dynamically generated slim WCF client that supports OMiau authorization.
/// </summary>
/// <typeparam name="TChannel">Service interface</typeparam>
/// <typeparam name="TSlimServiceClient">
/// Slim client interface (must derive from <typeparamref name="TChannel"/>)</typeparam>
/// <param name="realClient">Real service client</param>
/// <param name="tokenService">Token service</param>
/// <returns>Slim WCF client</returns>
public static TSlimServiceClient CreateSlimClient <TChannel, TSlimServiceClient>(
ClientBase <TChannel> realClient, ITokenService tokenService)
where TChannel : class
where TSlimServiceClient : class
{
if (realClient == null)
{
throw new ArgumentNullException(nameof(realClient));
}
if (tokenService == null)
{
throw new ArgumentNullException(nameof(tokenService));
}
if (!typeof(TChannel).IsAssignableFrom(typeof(TSlimServiceClient)))
{
throw new ArgumentNullException("Type arguments don't match.");
}
// Create a dispatcher for real client
var dispatcher = new SlimServiceClientDispatcher <TChannel>(realClient);
// Generate a "real object" of ILazyCatServiceSlimClient that will delegate calls
// to the dispatcher
var wrappedDispatcher = (TSlimServiceClient)ProxyGenerator.CreateInterfaceProxyWithoutTarget(
typeof(TSlimServiceClient),
dispatcher);
// Create async interceptor
var asyncInterceptor = new SlimServiceClientAsyncInterceptor <TSlimServiceClient>(
wrappedDispatcher, () => realClient.InnerChannel, tokenService);
// Glue everything together to get mind blowing wrapper Bacon Double Cheeseburger
var wrappedSlimClient = ProxyGenerator.CreateInterfaceProxyWithTargetInterface(
wrappedDispatcher, asyncInterceptor);
return(wrappedSlimClient);
}
public void ExceptionLogsFailedRequest()
{
var telemetryChannel = new FakeChannel();
var config = new TelemetryConfiguration("00000000-0000-0000-0000-000000000001", telemetryChannel);
var client = new TelemetryClient(config);
StatelessServiceContext ctx = MockBuilder.StatelessServiceContext();
Mock <IFakeService> fakeService = new Mock <IFakeService>();
fakeService.Setup(s => s.TestServiceMethod()).Throws(new InvalidOperationException("Test Exception Text"));
var gen = new ProxyGenerator();
var impl = (IFakeService)gen.CreateInterfaceProxyWithTargetInterface(
typeof(IFakeService),
new Type[0],
fakeService.Object,
new LoggingServiceInterceptor(ctx, client));
var ex = (((Func <object>)(() => impl.TestServiceMethod()))).Should().Throw <InvalidOperationException>().Which;
ex.Message.Should().Be("Test Exception Text");
client.Flush();
List <RequestTelemetry> requestTelemetries =
telemetryChannel.Telemetry.OfType <RequestTelemetry>().ToList();
requestTelemetries.Should().ContainSingle();
RequestTelemetry requestTelemetry = requestTelemetries[0];
requestTelemetry.Success.Should().BeFalse();
ExceptionTelemetry exceptionTelemetry = telemetryChannel.Telemetry.OfType <ExceptionTelemetry>().FirstOrDefault();
exceptionTelemetry.Should().NotBeNull();
exceptionTelemetry.Exception.Should().BeSameAs(ex);
}
public void ExceptionLogsFailedRequest()
{
var telemetryChannel = new FakeChannel();
var config = new TelemetryConfiguration("00000000-0000-0000-0000-000000000001", telemetryChannel);
var client = new TelemetryClient(config);
StatelessServiceContext ctx = MockBuilder.StatelessServiceContext();
Mock <IFakeService> fakeService = new Mock <IFakeService>();
fakeService.Setup(s => s.TestServiceMethod()).Throws(new InvalidOperationException("Test Exception Text"));
var gen = new ProxyGenerator();
var impl = (IFakeService)gen.CreateInterfaceProxyWithTargetInterface(
typeof(IFakeService),
new Type[0],
fakeService.Object,
new LoggingServiceInterceptor(ctx, client));
var ex = Assert.ThrowsAny <InvalidOperationException>(() => impl.TestServiceMethod());
Assert.Equal("Test Exception Text", ex.Message);
client.Flush();
List <RequestTelemetry> requestTelemetries =
telemetryChannel.Telemetry.OfType <RequestTelemetry>().ToList();
Assert.Single(requestTelemetries);
RequestTelemetry requestTelemetry = requestTelemetries[0];
Assert.False(requestTelemetry.Success);
ExceptionTelemetry exceptionTelemetry = telemetryChannel.Telemetry.OfType <ExceptionTelemetry>().FirstOrDefault();
Assert.NotNull(exceptionTelemetry);
Assert.Same(ex, exceptionTelemetry.Exception);
}
static void Main(string[] args)
{
#region 1.0 不使用StructureMap的情况
//var service2=new ServiceTwo();
//var service1=new ServiceOne(service2);
//service1.DoWorkOne();
#endregion
#region 2.0 使用StructureMap
//ObjectFactory.Initialize(config =>//不同的IOC工具初始化代码是不同的
//{
// config.Scan(scanner =>
// {
// scanner.TheCallingAssembly();
// scanner.WithDefaultConventions();//使用默认的惯例
// });
// var proxyGenerator = new ProxyGenerator();
// var aspect = new LoggingAspect(new LoggingService());
// var service = new ServiceOne(new ServiceTwo());
// var result = proxyGenerator.CreateInterfaceProxyWithTargetInterface(typeof(IServiceOne), service, aspect);//应用切面
// config.For<IServiceOne>().Use((IServiceOne) result);//告诉StructureMap使用产生的动态代理
//});
//var service1 = ObjectFactory.GetInstance<IServiceOne>();
//service1.DoWorkOne();
#endregion
#region 3.0 使用EnrichWith重构
ObjectFactory.Initialize(config =>
{
config.Scan(scanner =>
{
scanner.TheCallingAssembly();
scanner.WithDefaultConventions();
});
var proxyGenerator = new ProxyGenerator();
//EnrichWith期待传入一个Func参数
config.For <IServiceOne>().Use <ServiceOne>().EnrichWith(svc =>
{
var aspect = new LoggingAspect(new LoggingService());
var result = proxyGenerator.CreateInterfaceProxyWithTargetInterface(typeof(IServiceOne), svc, aspect);
return(result);
});
});
#endregion
#region 4.0使用ProxyHelper重构
ObjectFactory.Initialize(config =>
{
config.Scan(scanner =>
{
scanner.TheCallingAssembly();
scanner.WithDefaultConventions();
});
var proxyHelper = new ProxyHelper();
//注意Proxify方法本身以实参传入EnrichWith方法
config.For <IServiceOne>().Use <ServiceOne>().EnrichWith(proxyHelper.Proxify <IServiceOne, LoggingAspect>);
});
#endregion
Console.Read();
}
public static T Create <T>(T instance, IAsyncInterceptor interceptor) where T : class
{
T proxy = generator.CreateInterfaceProxyWithTargetInterface <T>(instance, interceptor);
return(proxy);
}
public object Proxify <T, TK>(object obj) where TK : IInterceptor
=>
_proxyGenerator.CreateInterfaceProxyWithTargetInterface(typeof(T), obj,
ObjectFactory.Locator.GetInstance <TK>());
public object Process(object target, IContext context)
{
return(_proxy.CreateInterfaceProxyWithTargetInterface(target.GetType().GetInterfaces().First(),
target.GetType().GetInterfaces(), target,
new DynamicProxyInterceptor()));
}
public TInterface CreateCannelWithRetries <TInterface>(IServiceProxy <TInterface> serviceProxy) where TInterface : class
{
return(proxyGenerator.CreateInterfaceProxyWithTargetInterface(serviceProxy.Channel, new ClientProxyRetryInterceptor()));
}
/// <summary>
///
/// </summary>
/// <typeparam name="TInterface"></typeparam>
/// <param name="interface"></param>
/// <param name="interceptors"></param>
/// <returns></returns>
public static TInterface GenerateInterfaceProxy <TInterface>(this TInterface @interface, params IInterceptor[] interceptors) where TInterface : class
{
var proxyGenerator = new ProxyGenerator();
return(proxyGenerator.CreateInterfaceProxyWithTargetInterface(@interface, interceptors));
}
// CreateInterfaceProxyWithTarget uses composition-based proxying to wrap a target object with // a proxy object implementing the desired interface. Calls are passed to the target object // after running interceptors. This model is similar to DispatchProxy. public static object Decorate(Type interfaceType, object target) => Generator.CreateInterfaceProxyWithTargetInterface(interfaceType, target, new DynamicProxyLoggingInterceptor(interfaceType.Name));
public static void RewireWithAspects(this IServiceCollection services, Action <IAspectOptions>?options = null)
{
var aspectRegistry = new AspectRegistry();
services.AddSingleton(aspectRegistry);
var optionsBuilder = new AspectOptionsBuilder();
options?.Invoke(optionsBuilder);
foreach (var map in optionsBuilder.Maps)
{
aspectRegistry.RegisterAspectTrigger(map.Attribute, map.Aspect);
}
foreach (var aspectType in aspectRegistry.RegisteredAspectTypes)
{
services.AddTransient(aspectType);
}
var descriptorsOfAnnotatedServices = services
.Where(IsSupportedServiceDescriptor)
.Where(x => aspectRegistry.HasTriggers(x.ImplementationType !))
.ToArray();
foreach (var serviceDescriptor in descriptorsOfAnnotatedServices)
{
aspectRegistry.RegisterAnnotatedService(serviceDescriptor.ImplementationType !);
}
// remove current service registrations
foreach (var serviceDescriptor in descriptorsOfAnnotatedServices)
{
services.Remove(serviceDescriptor);
}
// add service descriptor for implementation types
foreach (var serviceDescriptor in descriptorsOfAnnotatedServices)
{
services.Add(ServiceDescriptor.Describe(
serviceType: serviceDescriptor.ImplementationType !,
implementationType: serviceDescriptor.ImplementationType !,
lifetime: serviceDescriptor.Lifetime
));
}
// add new service descriptor with proxy factory
foreach (var serviceDescriptor in descriptorsOfAnnotatedServices)
{
var implementationType = serviceDescriptor.ImplementationType !;
var lifetime = serviceDescriptor.Lifetime;
var serviceType = serviceDescriptor.ServiceType;
services.Add(ServiceDescriptor.Describe(
serviceType: serviceType,
provider =>
{
var myClass = provider.GetRequiredService(implementationType);
var interceptor = new MethodInterceptor(new PipelineStepFactory(provider, aspectRegistry));
return(_proxyGenerator.CreateInterfaceProxyWithTargetInterface(
interfaceToProxy: serviceType,
target: myClass,
new IAsyncInterceptor[] { interceptor }
));
},
lifetime
));
}
}
public static TSomething MakeSomething <TSomething>(TSomething instance) where TSomething : class
{
TSomething proxy = _generator.CreateInterfaceProxyWithTargetInterface <TSomething>(instance, new MyInterceptor());
return(proxy);
}
public void LoadAssemblyIntoCache_InvalidCacheAfterTwoLoadAssemblyIntoCacheThatContainsSameGeneric()
{
//
// Step 1 - Save an assembly with 1 generic proxy
//
var proxyGeneratorModuleScope = new ModuleScope(
true,
true,
ModuleScope.DEFAULT_ASSEMBLY_NAME + "1",
"ProxyCache1.dll",
ModuleScope.DEFAULT_ASSEMBLY_NAME + "1",
"ProxyCache1.dll"
);
var proxyBuilder = new DefaultProxyBuilder(proxyGeneratorModuleScope);
var generator = new ProxyGenerator(proxyBuilder);
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IGenericInterface <IInterface1>),
new Class1(),
new DoNothingInterceptor()
);
proxyGeneratorModuleScope.SaveAssembly();
//
// Step 2 - Save another assembly with 1 generic proxy
// note : to reproduce the problem, must load previously saved assembly (in cache) before saving this assembly.
//
proxyGeneratorModuleScope = new ModuleScope(
true,
true,
ModuleScope.DEFAULT_ASSEMBLY_NAME + "2",
"ProxyCache2.dll",
ModuleScope.DEFAULT_ASSEMBLY_NAME + "2",
"ProxyCache2.dll"
);
proxyBuilder = new DefaultProxyBuilder(proxyGeneratorModuleScope);
generator = new ProxyGenerator(proxyBuilder);
var proxyAssembly = Assembly.LoadFrom("ProxyCache1.dll");
proxyGeneratorModuleScope.LoadAssemblyIntoCache(proxyAssembly);
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IGenericInterface <IInterface2>),
new Class2(),
new DoNothingInterceptor()
);
proxyGeneratorModuleScope.SaveAssembly();
//
// Step 3 - Load the last proxy assembly and try to create the first generic proxy (created in step 1)
// note : Creating proxy from step 2 works.
// exception : Missing method exception, it returns the wrong proxy and the constructor used doesn't match the arguments passed.
//
proxyGeneratorModuleScope = new ModuleScope(true);
proxyBuilder = new DefaultProxyBuilder(proxyGeneratorModuleScope);
generator = new ProxyGenerator(proxyBuilder);
proxyAssembly = Assembly.LoadFrom("ProxyCache2.dll");
proxyGeneratorModuleScope.LoadAssemblyIntoCache(proxyAssembly);
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IGenericInterface <IInterface1>),
new Class1(),
new DoNothingInterceptor()
);
}
public void LoadAssemblyIntoCache_InvalidCacheAfterTwoLoadAssemblyIntoCacheThatContainsSameInterface()
{
//
// Step 1 - Save an assembly with 1 interface proxy
//
var proxyGeneratorModuleScope = new ModuleScope(
true,
true,
ModuleScope.DEFAULT_ASSEMBLY_NAME + "3",
"ProxyCache3.dll",
ModuleScope.DEFAULT_ASSEMBLY_NAME + "3",
"ProxyCache3.dll"
);
var proxyBuilder = new DefaultProxyBuilder(proxyGeneratorModuleScope);
var generator = new ProxyGenerator(proxyBuilder);
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IInterface3),
new[] { typeof(IInterface2) },
new Class3(),
new DoNothingInterceptor()
);
proxyGeneratorModuleScope.SaveAssembly();
//
// Step 2 - Save another assembly with 1 interface proxy
// note : to reproduce the problem, must load previously saved assembly (in cache) before saving this assembly.
//
proxyGeneratorModuleScope = new ModuleScope(
true,
true,
ModuleScope.DEFAULT_ASSEMBLY_NAME + "4",
"ProxyCache4.dll",
ModuleScope.DEFAULT_ASSEMBLY_NAME + "4",
"ProxyCache4.dll"
);
proxyBuilder = new DefaultProxyBuilder(proxyGeneratorModuleScope);
generator = new ProxyGenerator(proxyBuilder);
var proxyAssembly = Assembly.LoadFrom("ProxyCache3.dll");
proxyGeneratorModuleScope.LoadAssemblyIntoCache(proxyAssembly);
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IInterface3),
new[] { typeof(IInterface1) },
new Class4(),
new DoNothingInterceptor()
);
proxyGeneratorModuleScope.SaveAssembly();
//
// Step 3 - Load the last proxy assembly and try to create the first interface proxy (created in step 1)
// note : Creating proxy from step 2 works.
// issue : returns the wrong proxy (the one from step 2)
//
proxyGeneratorModuleScope = new ModuleScope(true);
proxyBuilder = new DefaultProxyBuilder(proxyGeneratorModuleScope);
generator = new ProxyGenerator(proxyBuilder);
proxyAssembly = Assembly.LoadFrom("ProxyCache4.dll");
proxyGeneratorModuleScope.LoadAssemblyIntoCache(proxyAssembly);
var invalidProxy = generator.CreateInterfaceProxyWithTargetInterface(
typeof(IInterface3),
new[] { typeof(IInterface2) },
new Class3(),
new DoNothingInterceptor()
);
if (invalidProxy as IInterface2 == null)
{
Assert.Fail();
}
}
public IMyService Create()
{
IMyService proxy = _proxyGenerator.CreateInterfaceProxyWithTargetInterface <IMyService>(null, _interceptor);
return(proxy);
}
