public void CacheHitInterfaceProxy()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
generator.CreateInterfaceProxyWithoutTarget<IEmptyInterface>();
generator.CreateInterfaceProxyWithoutTarget<IEmptyInterface>();
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.IEmptyInterfaceProxy " +
"for target type Castle.DynamicProxy.Tests.LoggingTestCase+IEmptyInterface."));
}
public T Create <T>() where T : class
{
var generator = new ProxyGenerator();
var proxy = generator.CreateInterfaceProxyWithoutTarget <T>(new CallInterceptor(_baseUrl));
return(proxy);
}
public override object BuildProxy(ProxyGenerator generator, Type objType, CommonData data, object baseObj)
{
if (!objType.IsInterface)
{
throw new Exception("Set can only be created from ISet Interface");
}
object proxy;
if (baseObj == null)
{
proxy = generator.CreateInterfaceProxyWithoutTarget(objType,
new ProxyGenerationOptions(new GeneralProxyGenerationHook())
{
Selector = _setSelector
},
new GeneralGetInterceptor(data), new SetAddInterceptor(data), new SetRemoveInterceptor(data));
}
else
{
proxy = generator.CreateInterfaceProxyWithTarget(objType, baseObj,
new ProxyGenerationOptions(new GeneralProxyGenerationHook())
{
Selector = _setSelector
},
new GeneralGetInterceptor(data), new SetAddInterceptor(data), new SetRemoveInterceptor(data));
}
return(proxy);
}
public void Initialise(IoHandler ioHandler, string prefix)
{
ProxyInstance = ProxyGenerator.CreateInterfaceProxyWithoutTarget(ResultBaseType,
new ConfigurationInterceptor(ResultBaseType, ioHandler, prefix));
IsInitialised = true;
}
private static object ConvertReturnValue(object value, Type type)
{
if (value == null || value.GetType() == type)
{
return(value);
}
if (type.IsInterface)
{
ProxyGenerator generator = new ProxyGenerator();
return(generator.CreateInterfaceProxyWithoutTarget(type, new Wrapper(value)));
}
else
{
var result = type.GetConstructor(new Type[0]).Invoke(new object[0]);
foreach (var property in value.GetType().GetProperties())
{
var propertyValue = property.GetValue(value);
type.GetProperties()
.Where(p => CaptionsEquality(property.Name, p.Name))
.Single()
.SetValue(result, propertyValue);
}
return(result);
}
}
public static void Test()
{
ProxyGenerator generator = new ProxyGenerator();
//采用默认的基类(Object)
IPerson person =
generator.CreateInterfaceProxyWithoutTarget <IPerson>
(new ReadMethodInterceptor());
DisplayMessage(person);
ProxyGenerator proxyGenerator = new ProxyGenerator();
ProxyGenerationOptions options = new ProxyGenerationOptions();
//改变接口对象的基类为MarshalByRefObject
options.BaseTypeForInterfaceProxy = typeof(MarshalByRefObject);
Console.WriteLine();
Console.WriteLine("=====================================");
IPerson person1 =
(IPerson)proxyGenerator.CreateInterfaceProxyWithoutTarget(
typeof(IPerson),
null, options,
new ReadMethodInterceptor());
DisplayMessage(person1);
Console.ReadLine();
}
/// <summary>
/// 获取服务代理类
/// </summary>
/// <param name="serviceType">服务接口类型</param>
/// <returns>服务代理类</returns>
public object GetService(Type serviceType)
{
ServiceProxyInterceptor interceptor = new ServiceProxyInterceptor();
interceptor.ServiceAgent = serviceAgent;
RemoteCaller caller;
if (remoteCallers.ContainsKey(serviceType))
{
caller = remoteCallers[serviceType];
}
else
{
caller = new RemoteCaller();
remoteCallers.Add(serviceType, caller);
}
ProxyGenerationOptions option = new ProxyGenerationOptions();
option.AddMixinInstance(caller);
object proxy = generator.CreateInterfaceProxyWithoutTarget(serviceType, null, option, interceptor);
return(proxy);
}
public T CreateClient <T>(string serviceName) where T : class
{
HttpRequestInterceptor httpRequestInterceptor = new HttpRequestInterceptor(_httpClientFactory.CreateClient(serviceName));
return(_services.GetOrAdd(typeof(T).FullName,
_proxyGenerator.CreateInterfaceProxyWithoutTarget <T>(httpRequestInterceptor)) as T);
}
public void CacheHitInterfaceProxy()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator {
Logger = logger
};
// Act
generator.CreateInterfaceProxyWithoutTarget <IEmptyInterface>();
generator.CreateInterfaceProxyWithoutTarget <IEmptyInterface>();
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.IEmptyInterfaceProxy " +
"for target type Castle.DynamicProxy.Tests.LoggingTestCase+IEmptyInterface."));
}
private void ComponentContainer_NoComponentRegisted(object sender, NoComponentRegistedEventArgs e)
{
if (!e.ServiceType.IsInterface)
{
return;
}
IEnumerable <AttachedRuntimeInfo> matchedInfos = this.attachedImplementorInfo
.Where(info => info.Attachment.CanAttach(e.ServiceType));
int count = matchedInfos.Count();
if (count == 0)
{
return;
}
if (count > 1)
{
throw new ApplicationException();
}
var implementorType = matchedInfos.First().AttachedType;
e.ComponentProvider = cm =>
{
var implementor = (IImplementor)cm.CreateComponent(implementorType);
ImplementorAttributeExecuteInterceptor interceptor = new ImplementorAttributeExecuteInterceptor(e.ServiceType, implementor);
var rlt = proxyGenerator.CreateInterfaceProxyWithoutTarget(
e.ServiceType,
interceptor
);
return(rlt);
};
}
protected override void OnAfterStart()
{
try
{
_address = Constants.BaseAddress + Pid;
var binding = WcfUtils.GetNetNamedPipeBinding();
var ep = new EndpointAddress(_address);
var type = typeof(IRemoteVstService);
var proxyCreatorType = MakeGenericType(type);
var proxyCreator = GetProxyCreator(proxyCreatorType, binding, ep);
var x = _generator.CreateInterfaceProxyWithoutTarget(type, new[] { typeof(IContextChannel) },
CreateInterceptor(proxyCreator, type));
_vstService = x as IRemoteVstService;
_vstService.Ping();
_vstServiceAvailable = true;
IsBusy = false;
_pingTimer.Start();
}
catch (Exception ex)
{
ForceStop($"Failure when attempting to open the service channel: {ex}");
}
}
/// <summary>
/// 创建接口代理类
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public object CreateMicroClientProxy(Type type)
{
ProxyGenerator proxyGenerator = new ProxyGenerator();
object t = proxyGenerator.CreateInterfaceProxyWithoutTarget(type, new MicroClientProxy(middleService));
return(t);
}
public object CreateProxyInterface(Type type)
{
var args = OnAgentPreparation(type);
return(_proxyGenerator.CreateInterfaceProxyWithoutTarget(type, args.AdditionalInterfacesToProxy.ToArray(),
args.GenerationOptions, args.Interceptors.ToArray()));
}
public object Target(Type type, string url)
{
var clientDescriptor = new ClientDescriptor
{
MethodDescriptorTable = new MethodDescriptorTable(),
Name = _clientName,
Type = type
};
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
clientDescriptor.MethodDescriptorTable.Set(type, method);
var methodDescriptor = clientDescriptor.MethodDescriptorTable.Get(type, method);
if (methodDescriptor.Decoder == null)
{
methodDescriptor.Decoder = _decoder;
}
if (methodDescriptor.Encoder == null)
{
methodDescriptor.Encoder = _encoder;
}
}
var httpClientFactory = _services.GetRequiredService <IHttpClientFactory>();
var parameterExpanderLocator = _services.GetRequiredService <IParameterExpanderLocator>();
var goInterceptor = new FeignInterceptor(clientDescriptor, httpClientFactory, parameterExpanderLocator);
var feignProxy = ProxyGenerator.CreateInterfaceProxyWithoutTarget(type, Enumerable.Empty <Type>().ToArray(), goInterceptor);
return(ProxyGenerator.CreateInterfaceProxyWithTarget(type, feignProxy,
new HystrixInterceptor(_clientName, type, feignProxy, _fallbackType, _services)));
}
/// <summary>
/// 使用WebApi动态代理客户端
/// </summary>
/// <param name="service"></param>
/// <param name="optionAction"></param>
public static IServiceCollection AddWebApiProxy(this IServiceCollection service, Action <WebApiProxyOptions> optionAction)
{
AppDomain.CurrentDomain.UpdateExcutingAssemblies();
var option = new WebApiProxyOptions();
optionAction(option);
foreach (var o in option.WebApiProxies)
{
var types = o.GetType().Assembly.GetTypes().Where(x =>
x.IsInterface && x.GetMethods().SelectMany(m => m.GetCustomAttributes(typeof(ApiActionAttribute), true)).Any());
foreach (var type in types)
{
var proxy = ProxyGenerator.CreateInterfaceProxyWithoutTarget(type, new HttpApiClient(o.BaseUrl ?? option.ProxyHost));
service.AddSingleton(type, x => proxy);
}
}
foreach (var type in option.RegisteredServices)
{
if (type.Value.IsInterface)
{
var proxy = ProxyGenerator.CreateInterfaceProxyWithoutTarget(type.Value, new HttpApiClient(type.Key ?? option.ProxyHost));
service.AddSingleton(type.Value, x => proxy);
}
}
return(service);
}
public void InitialiseAt(int index, IoHandler ioHandler, string prefix)
{
object instance = ProxyGenerator.CreateInterfaceProxyWithoutTarget(ResultBaseType,
new InterfaceInterceptor(ResultBaseType, ioHandler, prefix));
_indexToProxyInstance[index] = instance;
}
public IWampClientProxy <TMessage> Create(IMessagePlayer <TMessage> player,
IMessageRecorder <TMessage> recorder,
WampMessage <TMessage> welcomeMessage)
{
ProxyGenerationOptions options =
new ProxyGenerationOptions();
options.Selector = new MockClientInterceptorSelector();
IWampFormatter <TMessage> formatter = mBinding.Formatter;
long sessionId = formatter.Deserialize <long>(welcomeMessage.Arguments[0]);
WelcomeDetails welcomeDetails = formatter.Deserialize <WelcomeDetails>(welcomeMessage.Arguments[1]);
IWampClientProxy <TMessage> result =
mGenerator.CreateInterfaceProxyWithoutTarget
(typeof(IWampClientProxy),
new[]
{
typeof(IWampClientProxy <TMessage>),
typeof(IWampConnectionMonitor)
},
options,
new RecordAndPlayRawInterceptor <TMessage>(player, recorder, mBinding),
new RecordAndPlayInterceptor <TMessage>
(mOutgoingSerializer, player, recorder, mBinding),
new SessionPropertyInterceptor(sessionId),
new WelcomeDetailsInterceptor(welcomeDetails))
as IWampClientProxy <TMessage>;
return(result);
}
public void Test1()
{
var proxyGen = new ProxyGenerator();
var client = new WebApiClient();
client.BaseUrl = "http://localhost:28180/api/ilogger/";
var i = new TestInterfaceInterceptor(client);
var p = proxyGen.CreateInterfaceProxyWithoutTarget <ILogger>(i);
var result = p.Log("Hello");
var t = p.LogAsync("AsyncErrorMessage");
t.Wait();
var asyncResult = t.Result;
Task.Run(() => p.LogAsync("Async Error Message").GetAwaiter().GetResult()).GetAwaiter().GetResult();
p.LogError("Error Message");
p.LogException(new Exception("Test Exception"));
p.LogException("Test Exception Message");
p.LogException(new Exception("Test Exception"), "Test Exception Message");
p.LogWarning("Test Warning");
}
/// <summary>
/// 注入自定义消息总线
/// 注：可以通过此方法注入多个总线
/// </summary>
/// <typeparam name="TMessageBus">自定义总线类型</typeparam>
/// <param name="services">服务容器</param>
/// <param name="options">配置</param>
/// <returns></returns>
public static IServiceCollection AddMessageBus <TMessageBus>(this IServiceCollection services, MessageBusOptions options)
where TMessageBus : class, IMessageBus
{
if (!typeof(TMessageBus).IsPublic)
{
throw new Exception($"{typeof(TMessageBus).FullName}必须公开");
}
services.AddHostedService <MessageBusBootstraper>();
MessageBusBootstraper.Bootstrap += serviceProvider => serviceProvider.GetService <TMessageBus>();
return(services.AddSingleton(serviceProvider =>
{
var busInstance = MessageBusFactory.GetBusInstance(serviceProvider, options);
if (typeof(TMessageBus) == typeof(IMessageBus))
{
return (TMessageBus)busInstance;
}
else
{
return Generator.CreateInterfaceProxyWithoutTarget <TMessageBus>(new ActLikeInterceptor(busInstance));
}
}));
}
public override object CreateMock(MockFactory mockFactory, CompositeType typesToMock, string name, MockStyle mockStyle, object[] constructorArgs)
{
if (typesToMock == null)
{
throw new ArgumentNullException("typesToMock");
}
Type primaryType = typesToMock.PrimaryType;
Type[] additionalInterfaces = BuildAdditionalTypeArrayForProxyType(typesToMock);
IInterceptor mockInterceptor = new MockObjectInterceptor(mockFactory, typesToMock, name, mockStyle);
object result;
if (primaryType.IsInterface)
{
result = generator.CreateInterfaceProxyWithoutTarget(primaryType, additionalInterfaces, new ProxyGenerationOptions {
BaseTypeForInterfaceProxy = typeof(InterfaceMockBase)
}, mockInterceptor);
((InterfaceMockBase)result).Name = name;
}
else
{
result = generator.CreateClassProxy(primaryType, additionalInterfaces, ProxyGenerationOptions.Default, constructorArgs, mockInterceptor);
//return generator.CreateClassProxy(primaryType, new []{typeof(IMockObject)}, mockInterceptor);
}
return(result);
}
public static object Generate <TInterface>(object obj34) where TInterface : class
{
// var obj = _proxyGenerator.CreateInterfaceProxyWithoutTarget<TInterface>(new Interceptor());
var obj = _proxyGenerator.CreateInterfaceProxyWithoutTarget(typeof(TInterface), new Interceptor());
return(obj);
}
private object CreateState(ProxyGenerator proxyGenerator)
{
return(proxyGenerator.CreateInterfaceProxyWithoutTarget(
_composite.Mapping.State,
_composite.Extensions.Select(e => e.State).ToArray(),
new StateInterceptor()));
}
/// <summary>
/// Executes the specified args.
/// </summary>
/// <param name="args">The args.</param>
public void Execute(ObjectConstructionArgs args)
{
if (args.Result == null &&
args.Configuration.Type.IsInterface)
{
args.Result = _generator.CreateInterfaceProxyWithoutTarget(args.Configuration.Type, new InterfacePropertyInterceptor(args));
}
}
private void CreateProxy(IInvocation invocation, PathAttribute pathAttribute)
{
var routePath = GetRoutePath(invocation, Path, pathAttribute.Path);
var proxy = _proxyGenerator.CreateInterfaceProxyWithoutTarget(invocation.Method.ReturnType, new Interceptor(_httpClient, _proxyGenerator, routePath));
invocation.ReturnValue = proxy;
}
private static TFactory CreateFactory <TFactory>(IServiceProvider serviceProvider)
where TFactory : class
{
var generator = new ProxyGenerator();
return(generator.CreateInterfaceProxyWithoutTarget <TFactory>(
new FactoryInterceptor(serviceProvider)));
}
public object CreateMock(Type mockType)
{
var interceptor = new MockInterceptor(invocationDescriptorFactory, invocationTransformer, invocationStage, invocationOperationManagerFinder);
var mock = proxyGenerator.CreateInterfaceProxyWithoutTarget(mockType, interceptor);
interceptor.SetMock(mockType, mock);
return(mock);
}
public TPluginType Create()
{
var container = _context.GetInstance <IContainer>();
var interceptor = new FactoryInterceptor(container, _conventionProvider);
return(_proxyGenerator.CreateInterfaceProxyWithoutTarget <TPluginType>(interceptor));
}
public TSettings Build <TSettings>() where TSettings : class
{
var interceptors = _interceptors.ToArray();
var proxy = _generator.CreateInterfaceProxyWithoutTarget <TSettings>(interceptors);
return(proxy);
}
protected T CreateProxy <T>([NotNull] Func <HttpWebRequest> requestFactory)
where T : class
{
var interceptor = new HttpRpcClientInterceptor(requestFactory);
var proxy = _proxyGenerator.CreateInterfaceProxyWithoutTarget <T>(interceptor);
return(proxy);
}
public static T WrapAs <T>(Delegate impl) where T : class
{
var generator = new ProxyGenerator();
var interceptor = new MethodInterceptor(impl);
var proxy = generator.CreateInterfaceProxyWithoutTarget <T>(interceptor);
return(proxy);
}
/// <summary>
/// Creates an instance of the configuration interface
/// </summary>
/// <returns></returns>
public T Build()
{
var handler = new IoHandler(_stores, _cacheInterval);
T instance = _generator.CreateInterfaceProxyWithoutTarget <T>(new ConfigurationInterceptor <T>(handler));
return(instance);
}
public void CanCreateInterfaceProxy()
{
var proxyGenerator = new ProxyGenerator();
proxyGenerator.CreateInterfaceProxyWithoutTarget<InterfaceWithMethodsWithAllKindsOfOptionalParameters>();
}
private object BuildFor(Type gatewayInterfaceType, IInterceptor interceptor)
{
var generator = new ProxyGenerator();
var proxy = generator.CreateInterfaceProxyWithoutTarget(gatewayInterfaceType, interceptor);
return proxy;
}
