public static TInterface CreateInterfaceProxy <TInterface>(this IProxyFactory proxyGenerator)
where TInterface : class
{
var type = typeof(TInterface);
if (!type.IsInterface)
{
throw new InvalidOperationException($"the Type {type.FullName} is not interface");
}
return(proxyGenerator.CreateProxy <TInterface>());
}
public static TInterface CreateInterfaceProxy <TInterface, TImplement>(this IProxyFactory proxyGenerator, params object[] arguments) where TImplement : TInterface
where TInterface : class
{
var type = typeof(TInterface);
if (!type.IsInterface)
{
throw new InvalidOperationException($"the Type {type.FullName} is not interface");
}
return(proxyGenerator.CreateProxy <TInterface, TImplement>(arguments));
}
static object Wrap(IServiceProvider sp, Type serviceType, Type impType)
{
object target = sp.GetService(serviceType);
if (target != null)
{
IProxyFactory proxyFactory = sp.GetRequiredService<IProxyFactory>();
var proxyTarget = proxyFactory.CreateProxy(serviceType, target);
target = proxyTarget ?? target;
}
return target;
}
public static TClass CreateClassProxy <TClass>(this IProxyFactory proxyGenerator) where TClass : class
{
var type = typeof(TClass);
if (!type.IsClass)
{
throw new InvalidOperationException($"the Type {type.FullName} is not class");
}
return(proxyGenerator.CreateProxy <TClass>());
}
private static object Wrap(IServiceProvider serviceProvider, Type serviceType)
{
object target = serviceProvider.GetService(serviceType);
if (target != null && target is IInterceptable)
{
IProxyFactory proxyFactory = serviceProvider.GetRequiredService <IProxyFactory>();
return(proxyFactory.CreateProxy(serviceType, target));
}
return(target);
}
public static TClass CreateClassProxy <TClass, TImplement>(this IProxyFactory proxyGenerator, params object[] arguments) where TImplement : TClass
where TClass : class
{
var type = typeof(TClass);
if (!type.IsClass)
{
throw new InvalidOperationException($"the Type {type.FullName} is not class");
}
return(proxyGenerator.CreateProxy <TClass, TImplement>(arguments));
}
public ActionResult Create(ActorCreationData actor)
{
actor.Validate();
if (!actor.ValidationErrors.Any())
{
RunAndReleaseProxy(_proxyFactory.CreateProxy <IActorService>(), proxy => proxy.Add(actor));
TempData["Status"] = CrudNotification.Success;
TempData["Id"] = actor.Id;
return(View());
}
else
{
ViewBag.ValidationErrors = actor.ValidationErrors.ToList();
TempData["Status"] = CrudNotification.ValidationError;
return(View());
}
}
public void ShouldWrapCall()
{
// Given
ITestClassWithDependency testClassWithState = TestClassWithDependency.Create();
var proxyObject = _sutForInterface.CreateProxy(testClassWithState);
// When
var result = proxyObject.GetNextInt(2);
// Then
Assert.Equal(3, result);
}
public static void ReferenceService <T>(ProxyOptions options, IInvokeFilter[] filters) where T : class
{
// 注册调用方信息
options.ServiceKind = ServiceKind.Remote;
options.EndpointUri = AppEnv.GlobalConfiguration.ConsumerConfiguration.Url;
options.Attributes.Add(AttrKeys.NodeCodeConsumer, AppEnv.GlobalConfiguration.ConsumerConfiguration.NodeCode);
IProxyFactory proxyFactory = AppEnv.GlobalConfiguration.ProxyFactory;
var proxy = proxyFactory.CreateProxy <T>(options, AppEnv._invokeFilters.Concat(filters).ToArray());
AppEnv._typeBuilder.RegisterType <T>(proxy);
}
public Task <IEnumerable <ActiveOutageViewModel> > Handle(GetActiveOutagesQuery request, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
using (OutageAccessProxy outageProxy = _proxyFactory.CreateProxy <OutageAccessProxy, IOutageAccessContract>(EndpointNames.OutageAccessEndpoint))
{
try
{
_logger.LogInfo("[OutageQueryHandler::GetActiveOutages] Sending a GET query to Outage service for active outages.");
IEnumerable <ActiveOutageMessage> activeOutages = outageProxy.GetActiveOutages();
IEnumerable <ActiveOutageViewModel> activeOutageViewModels = _mapper.MapActiveOutages(activeOutages);
return activeOutageViewModels;
}
catch (Exception ex)
{
_logger.LogError("[OutageQueryHandler::GetActiveOutages] Failed to GET active outages from Outage service.", ex);
throw ex;
}
}
}));
}
public static T Of <T>(IProxyFactory factory = null)
{
if (factory == null)
{
factory = ProxyFactory.Default;
}
var proxy = (IProxy)factory.CreateProxy(typeof(T), new[] { typeof(IMocked) }, new object[0]);
proxy.Behaviors.Add(new MockProxyBehavior());
proxy.Behaviors.Add(new DefaultValueProxyBehavior());
return((T)proxy);
}
/// <summary>
/// Create a new <see cref="Interceptable<Task>"/> object.
/// </summary>
/// <param name="serviceProvider">The service providuer to provide injected service.</param>
/// <exception cref="ArgumentNullException">The specified argument <paramref name="serviceProvider"/> is null.</exception>
/// <exception cref="InvalidOperationException">The <paramref name="serviceProvider"/> cannot provide the <see cref="ProxyFactory"/>.</exception>
public Interceptable(IServiceProvider serviceProvider)
{
Guard.ArgumentNotNull(serviceProvider, "serviceProvider");
_serviceProvider = serviceProvider;
T target = _serviceProvider.GetService <T>();
if (null == target)
{
this.Proxy = null;
}
IProxyFactory proxyFactory = _serviceProvider.GetRequiredService <IProxyFactory>();
this.Proxy = proxyFactory.CreateProxy <T>(target);
}
public void CreateInstanceWithoutArguments()
{
var userIdProviderProxy = _proxyFactory.CreateProxy <IUserIdProvider>();
Assert.NotNull(userIdProviderProxy);
Assert.True(userIdProviderProxy.GetType().Namespace?.StartsWith(NamespacePrefix));
var userIdProviderProxy2 = _proxyFactory.CreateProxy <IUserIdProvider, EnvironmentUserIdProvider>();
Assert.NotNull(userIdProviderProxy2);
Assert.True(userIdProviderProxy2.GetType().Namespace?.StartsWith(NamespacePrefix));
var userId = userIdProviderProxy2.GetUserId();
Assert.NotNull(userId);
var eventProxy = _proxyFactory.CreateProxy <TestEvent>();
Assert.NotNull(eventProxy);
Assert.True(eventProxy.GetType().Namespace?.StartsWith(NamespacePrefix));
}
/// <summary>
/// Uses the <paramref name="proxyFactory"/> to create a proxy instance
/// that directly derives from the <typeparamref name="T"/> type
/// and implements the given <paramref name="baseInterfaces"/>.
/// </summary>
/// <remarks>
/// The <paramref name="proxyImplementation"/> will be used to intercept method calls
/// performed against the target instance.
/// </remarks>
/// <param name="targetType">The type that will be intercepted by the proxy.</param>
/// <param name="proxyFactory">The IProxyFactory instance that will be used to generate the proxy type.</param>
/// <param name="proxyImplementation">The functor that will invoked every time a method is called on the proxy.</param>
/// <param name="baseInterfaces">The additional list of interfaces that the proxy will implement.</param>
/// <returns>A valid proxy instance.</returns>
public static object CreateProxy(this IProxyFactory proxyFactory, Type targetType,
Func <string, Type[], object[], object> proxyImplementation, params Type[] baseInterfaces)
{
Func <IInvocationInfo, object> doIntercept = info =>
{
var targetMethod = info.TargetMethod;
var methodName = targetMethod.Name;
var arguments = info.Arguments;
Type[] typeArguments = info.TypeArguments;
return(proxyImplementation(methodName, typeArguments, arguments));
};
var interceptor = new FunctorAsInterceptor(doIntercept);
return(proxyFactory.CreateProxy(targetType, interceptor, baseInterfaces));
}
public object GetMock(Type type)
{
object mock;
if (!_parameters.TryGetValue(type, out mock))
{
throw new InvalidOperationException();
}
if (mock == null)
{
mock = _proxyFactory.CreateProxy(type);
_parameters[type] = mock;
}
return(mock);
}
public ActionResult Create()
{
Role[] roles = null;
RunAndReleaseProxy(_proxyFactory.CreateProxy <IRoleService>(),
proxy =>
{
roles = proxy.GetAll();
});
List <SelectListItem> rolesList = roles.Select(role => new SelectListItem()
{
Text = role.Name,
Value = role.Id.ToString()
}).ToList();
ViewBag.Roles = rolesList;
return(View());
}
public ActionResult Create(Language language)
{
language.Validate();
if (!language.ValidationErrors.Any())
{
RunAndReleaseProxy(_proxyFactory.CreateProxy <ILanguageService>(), proxy => proxy.Update(language));
TempData["Status"] = CrudNotification.Success;
TempData["Id"] = language.Id;
return(View());
}
else
{
ViewBag.ValidationErrors = language.ValidationErrors.ToList();
TempData["Status"] = CrudNotification.ValidationError;
return(View());
}
}
public Task <OmsGraphViewModel> Handle(GetTopologyQuery request, CancellationToken cancellationToken)
{
return(Task.Run(() =>
{
using (UITopologyServiceProxy topologyProxy = _proxyFactory.CreateProxy <UITopologyServiceProxy, ITopologyServiceContract>(EndpointNames.TopologyServiceEndpoint))
{
try
{
_logger.LogInfo("[TopologyQueryHandler::GetTopologyQuery] Sending GET query to topology client.");
UIModel topologyModel = topologyProxy.GetTopology();
OmsGraphViewModel graph = _mapper.Map(topologyModel);
return graph;
}
catch (Exception ex)
{
_logger.LogError("[TopologyQueryHandler::GetTopologyQuery] Sending GET query to topology client failed.", ex);
return null;
}
}
}));
}
public void Setup()
{
processor = Substitute.For<IOutgoingRequestProcessor>();
factory = Substitute.For<IProxyFactory>();
factory.CreateProxy<IMyService>().Returns((p, s, t) => new MyServiceProxy(p, s, t));
container = new ProxyContainer(processor, factory);
}
/// <summary>
/// Uses the <paramref name="factory"/> to create a proxy instance
/// that directly derives from the <typeparamref name="T"/> type
/// and implements the given <paramref name="baseInterfaces"/>.
/// The <paramref name="interceptor"/> instance, in turn, will be used
/// to intercept the method calls made to the proxy itself.
/// </summary>
/// <typeparam name="T">The type that will be intercepted by the proxy.</typeparam>
/// <param name="factory">The IProxyFactory instance that will be used to generate the proxy type.</param>
/// <param name="interceptor">The <see cref="IInterceptor"/> instance that will be used to intercept method calls made to the proxy.</param>
/// <param name="baseInterfaces">The additional list of interfaces that the proxy will implement.</param>
/// <returns>A valid proxy instance.</returns>
public static T CreateProxy <T>(this IProxyFactory factory, IInterceptor interceptor,
params Type[] baseInterfaces)
{
return((T)factory.CreateProxy(typeof(T), interceptor, baseInterfaces));
}
/// <summary>
/// Uses the <paramref name="factory"/> to create a proxy instance
/// that directly derives from the <typeparamref name="T"/> type
/// and implements the given <paramref name="baseInterfaces"/>.
/// The <paramref name="wrapper"/> instance, in turn, will be used
/// to intercept the method calls made to the proxy itself.
/// </summary>
/// <typeparam name="T">The type that will be intercepted by the proxy.</typeparam>
/// <param name="factory">The IProxyFactory instance that will be used to generate the proxy type.</param>
/// <param name="wrapper">The <see cref="IInvokeWrapper"/> instance that will be used to intercept method calls made to the proxy.</param>
/// <param name="baseInterfaces">The additional list of interfaces that the proxy will implement.</param>
/// <returns>A valid proxy instance.</returns>
public static T CreateProxy <T>(this IProxyFactory factory, IInvokeWrapper wrapper,
params Type[] baseInterfaces)
{
return((T)factory.CreateProxy(typeof(T), wrapper, baseInterfaces));
}
protected override object VisitInterception(IntercepCallSite interceptCallSite, ServiceProvider argument)
{
IProxyFactory proxyFactory = interceptCallSite.ProxyFactory;
return(proxyFactory.CreateProxy(interceptCallSite.ServiceType, VisitCallSite(interceptCallSite.TargetCallSite, argument)));
}
/// <summary>
/// Create the specified type of proxy.
/// </summary>
/// <typeparam name="T">The type of proxy.</typeparam>
/// <param name="proxyFactory">The proxy factory.</param>
/// <param name="target">The target object wrapped by the created proxy.</param>
/// <returns>The proxy wrapping the specified target.</returns>
public static T CreateProxy <T>(this IProxyFactory proxyFactory, T target)
{
Guard.ArgumentNotNull(proxyFactory, nameof(proxyFactory));
return((T)proxyFactory.CreateProxy(typeof(T), target));
}
private static IServiceCollection GetInterceptableServices(IServiceProvider serviceProvider, IServiceCollection services)
{
var serviceCollection = new ServiceCollection();
foreach (var service in services)
{
bool isOpneGeneric = service.ServiceType.GetTypeInfo().IsGenericTypeDefinition;
Func <IServiceProvider, object> factory = _ => Wrap(serviceProvider, service.ServiceType);
switch (service.Lifetime)
{
case ServiceLifetime.Scoped:
{
if (isOpneGeneric)
{
serviceCollection.AddScoped(service.ServiceType, service.ImplementationType);
}
else
{
serviceCollection.AddScoped(service.ServiceType, factory);
}
break;
}
case ServiceLifetime.Singleton:
{
if (isOpneGeneric)
{
serviceCollection.AddSingleton(service.ServiceType, service.ImplementationType);
}
else
{
serviceCollection.AddSingleton(service.ServiceType, factory);
}
break;
}
case ServiceLifetime.Transient:
{
if (isOpneGeneric)
{
serviceCollection.AddTransient(service.ServiceType, service.ImplementationType);
}
else
{
serviceCollection.AddTransient(service.ServiceType, factory);
}
break;
}
}
}
foreach (var group in serviceCollection.GroupBy(_ => _.ServiceType))
{
if (group.Count() > 1)
{
serviceCollection.AddTransient(typeof(IEnumerable <>).MakeGenericType(group.Key),
_ =>
{
IProxyFactory proxyFactory = serviceProvider.GetRequiredService <IProxyFactory>();
var proxies = serviceProvider.GetServices(group.Key).Select(target => proxyFactory.CreateProxy(group.Key, target)).ToArray();
Array array = Array.CreateInstance(group.Key, proxies.Length);
for (int i = 0; i < group.Count(); i++)
{
array.SetValue(proxies[i], i);
}
return(array);
});
}
}
return(serviceCollection);
}
public static object CreateProxy(this IProxyFactory proxyFactory, Type serviceType, params object[] arguments)
{
return(proxyFactory.CreateProxy(serviceType, arguments));
}
public static TService CreateProxy <TService>(this IProxyFactory proxyFactory) where TService : class
{
return((TService)proxyFactory.CreateProxy(typeof(TService)));
}
public static TService CreateProxy <TService, TImplement>(this IProxyFactory proxyFactory)
where TImplement : TService
where TService : class
{
return((TService)proxyFactory.CreateProxy(typeof(TService), typeof(TImplement)));
}
public ActionResult Index()
{
Language[] languages = null;
Genre[] genres = null;
RunAndReleaseProxy(_proxyFactory.CreateProxy <ILanguageService>(), proxy =>
{
languages = proxy.GetAll();
});
RunAndReleaseProxy(_proxyFactory.CreateProxy <IGenreService>(), proxy =>
{
genres = proxy.GetAll();
});
ViewBag.Languages = languages;
ViewBag.Genres = genres;
return(View());
}
/// <summary>
/// Create the interceptable proxy based on specified target object.
/// </summary>
/// <typeparam name="TProxy">The return type of created interceptable proxy.</typeparam>
/// <param name="proxyFactory">The factory to create interceptable proxy.</param>
/// <param name="target">The target object wrapped by the created proxy.</param>
/// <returns>The created interceptable proxy.</returns>
/// <exception cref="ArgumentNullException">The specified <paramref name="proxyFactory"/> is null.</exception>
public static TProxy CreateProxy <TProxy>(this IProxyFactory proxyFactory, TProxy target)
{
Guard.ArgumentNotNull(proxyFactory, "proxyFactory");
return((TProxy)proxyFactory.CreateProxy(typeof(TProxy), target));
}
public static TService CreateProxy <TService, TImplement>(this IProxyFactory proxyFactory, params object[] arguments)
where TImplement : TService
where TService : class
{
return((TService)proxyFactory.CreateProxy(typeof(TService), typeof(TImplement), arguments));
}
/// <summary>
/// 根据当前参数类型和接口建立代理类
/// </summary>
/// <param name="proxyFactory"></param>
/// <param name="declaringType"></param>
/// <param name="invocationHandler"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public static object CreateProxy(this IProxyFactory proxyFactory, Type declaringType, IInvocationHandler invocationHandler, params object[] arguments)
{
return(proxyFactory.CreateProxy(declaringType, Type.EmptyTypes, invocationHandler, arguments));
}
