public static void Intercept <TService, TInterceptor>(this IRegistrator registrator, object serviceKey = null)
where TInterceptor : class, IInterceptor
{
var serviceType = typeof(TService);
Type proxyType;
if (serviceType.IsInterface())
{
proxyType = _proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else if (serviceType.IsClass())
{
proxyType = _proxyBuilder.CreateClassProxyTypeWithTarget(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else
{
throw new ArgumentException(
$"Intercepted service type {serviceType} is not a supported, cause it is nor a class nor an interface");
}
registrator.Register(serviceType, proxyType,
made: Made.Of(pt => pt.PublicConstructors().FindFirst(ctor => ctor.GetParameters().Length != 0),
Parameters.Of.Type <IInterceptor[]>(typeof(TInterceptor[]))),
setup: Setup.DecoratorOf(useDecorateeReuse: true, decorateeServiceKey: serviceKey));
}
public static void Intercept(this IRegistrator registrator, Type serviceType, Type interceptorType, object serviceKey = null)
{
Type proxyType;
if (serviceType.IsInterface())
{
proxyType = ProxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else if (serviceType.IsClass())
{
proxyType = ProxyBuilder.CreateClassProxyType(serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else
{
throw new ArgumentException($"Intercepted service type {serviceType} is not a supported: it is nor class nor interface");
}
Setup decoratorSetup = serviceKey == null
? Setup.DecoratorWith(useDecorateeReuse : true)
: Setup.DecoratorWith(r => serviceKey.Equals(r.ServiceKey), useDecorateeReuse: true);
registrator.Register(serviceType, proxyType,
made: Made.Of(type => type.GetPublicInstanceConstructors().SingleOrDefault(c => c.GetParameters().Length != 0), Parameters.Of.Type <IInterceptor[]>(interceptorType.MakeArrayType())),
setup: decoratorSetup);
}
public static void Intercept <TService, TInterceptor>(this IRegistrator registrator, object serviceKey = null)
where TInterceptor : class, IInterceptor
{
var serviceType = typeof(TService);
Type proxyType;
if (serviceType.IsInterface())
{
proxyType = ProxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else if (serviceType.IsClass())
{
proxyType = ProxyBuilder.CreateClassProxyType(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else
{
throw new ArgumentException(string.Format(
"Intercepted service type {0} is not a supported: it is nor class nor interface", serviceType));
}
var decoratorSetup = serviceKey == null
? Setup.DecoratorWith(useDecorateeReuse : true)
: Setup.DecoratorWith(r => serviceKey.Equals(r.ServiceKey), useDecorateeReuse: true);
registrator.Register(serviceType, proxyType,
made: Made.Of(type => type.PublicConstructors().SingleOrDefault(c => c.GetParameters().Length != 0),
Parameters.Of.Type <IInterceptor[]>(typeof(TInterceptor[]))),
setup: decoratorSetup);
}
public void Dispose()
{
var items = _items.Value;
for (var i = 0; i < items.Length; i++)
{
items[i].Dispose();
}
_items.Swap(_ => ArrayTools.Empty <IDisposable>());
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicArray{T}"/> struct with a specified initial capacity.
/// </summary>
/// <param name="capacity">The initial capacity of the list.</param>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="capacity"/> is less than 0.</exception>
public DynamicArray(int capacity)
{
if (capacity < 0)
{
throw new ArgumentOutOfRangeException(nameof(capacity));
}
this._array = capacity == 0 ? ArrayTools.Empty <T>() : new T[capacity];
this._length = 0;
}
public void DryIoc_can_consume_catalog()
{
var registrations = new List <ExportedRegistrationInfo>();
ComposablePartCatalog catalog = new TypeCatalog(typeof(Yes), typeof(No), typeof(Ok));
foreach (var part in catalog.Parts)
{
var creationInfoField = part.GetType().GetMembers(t => t.DeclaredFields)
.FirstOrDefault(f => f.Name == "_creationInfo")
.ThrowIfNull();
var creationInfo = creationInfoField.GetValue(part);
var getPartMethod = creationInfo.GetType().GetMembers(t => t.DeclaredMethods)
.FirstOrDefault(m => m.Name == "GetPartType")
.ThrowIfNull();
var implementationType = (Type)getPartMethod.Invoke(creationInfo, ArrayTools.Empty <object>());
ExportInfo[] exports = null;
foreach (var exportDefinition in part.ExportDefinitions)
{
//string serviceTypeFullName = null;
//object exportTypeObject;
//if (exportDefinition.Metadata.TryGetValue(CompositionConstants.ExportTypeIdentityMetadataName, out exportTypeObject))
// serviceTypeFullName = (string)exportTypeObject;
//var contractName = exportDefinition.ContractName;
//var serviceKey = string.Equals(contractName, serviceTypeFullName) ? null : contractName;
//var export = new ExportInfo(null, serviceKey) { ServiceTypeFullName = serviceTypeFullName };
var serviceInfo = GetServiceorDefault(exportDefinition);
var export = new ExportInfo(serviceInfo.ServiceType, serviceInfo.Details.ServiceKey);
exports = exports.AppendOrUpdate(export);
}
var registration = new ExportedRegistrationInfo
{
ImplementationType = implementationType,
Exports = exports
};
registrations.Add(registration);
}
var container = new Container().WithMefAttributedModel();
container.RegisterExports(registrations);
container.Resolve <IAnswer <Ok> >();
}
public static void RegisterInterfaceInterceptor <TService, TInterceptor>(this IRegistrator registrator)
where TInterceptor : class, IInterceptor
{
var serviceType = typeof(TService);
if (!serviceType.IsInterface)
{
throw new ArgumentException($"Intercepted service type {serviceType} is not an interface");
}
var proxyType = ProxyBuilder.Value.CreateInterfaceProxyTypeWithTargetInterface(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
registrator.Register(serviceType, proxyType,
made: Parameters.Of.Type <IInterceptor[]>(typeof(TInterceptor[])),
setup: Setup.Decorator);
}
public static Type CreateProxy(this IRegistrator container, Type serviceType)
{
Type proxyType;
if (serviceType.IsInterface())
{
proxyType = ProxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else if (serviceType.IsClass())
{
proxyType = ProxyBuilder.CreateClassProxyType(
serviceType, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else
{
throw new ArgumentException(
$"Intercepted service type {serviceType} is not a supported: it is nor class nor interface");
}
return(proxyType);
}
public async void Registering_greeting_with_middleware_configuration()
{
IContainer container = new Container();
container.Register <TestGreetingMiddleware>();
var contextItems = new Dictionary <object, object>();
HttpContextScopeContext.GetContextItems = () => contextItems;
using (var server = TestServer.Create(app =>
{
app.UseDryIocOwinMiddleware(
container.WithMvc(ArrayTools.Empty <Assembly>()),
scope => scope.Use(new Greeting {
Message = "Hey, DryIoc!"
}));
}))
{
var response = await server.HttpClient.GetAsync("/");
StringAssert.Contains("Hey, DryIoc!", response.Content.ReadAsStringAsync().Result);
}
}
public async void Configure_container_with_MVC_and_use_OWIN_middleware()
{
IContainer container = new Container();
container.Register <TestGreetingMiddleware>();
container.Register(Made.Of(() => new Greeting {
Message = "Hey, DryIoc!"
}), Reuse.InWebRequest);
var contextItems = new Dictionary <object, object>();
HttpContextScopeContext.GetContextItems = () => contextItems;
using (var server = TestServer.Create(app =>
{
container = container.WithMvc(ArrayTools.Empty <Assembly>());
app.UseDryIocOwinMiddleware(container);
}))
{
var response = await server.HttpClient.GetAsync("/");
StringAssert.Contains("Hey, DryIoc!", response.Content.ReadAsStringAsync().Result);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpaceOptimalDynamicArray{T}"/> class that is empty.
/// </summary>
public SpaceOptimalDynamicArray()
{
_blocks = ArrayTools.Empty <T[]>();
}
public void GetOutDegree_LongLine_IsCorrect()
{
var g = new DependencyGraph <int>(i => i == 5 ? new[] { 12, 4 } : i <= 0 ? ArrayTools.Empty <int>() : new[] { i - 1 });
Assert.That(g.GetOutDegree(5), Is.EqualTo(2));
}
public void ComputeStronglyConnectedComponents_LongLine_HaveCorrectLength()
{
var g = new DependencyGraph <int>(i => i == 5 ? new[] { 12, 4 } : i <= 0 ? ArrayTools.Empty <int>() : new[] { i - 1 });
var a = new TarjanStronglyConnectedComponentsAlgorithm <DependencyGraph <int>, int, DependencyGraph <int> .Edge>(g);
var scc = a.ComputeStronglyConnectedComponents(100);
Assert.That(scc.Length, Is.EqualTo(94));
Assert.That(scc[5].Length, Is.EqualTo(8));
var scc2 = a.ComputeStronglyConnectedComponents(105);
Assert.That(scc2.Length, Is.EqualTo(5));
}
public Expression ToExpression(Func <object, Expression> fallbackConverter)
{
return(New(GetType().GetConstructors()[0], ArrayTools.Empty <Expression>()));
}
public void Can_use_instance_method_for_service_creation()
{
var container = new Container();
container.Register <ServiceFactory>();
container.Register <IService>(made: Made.Of(
typeof(ServiceFactory).Method("Create", ArrayTools.Empty <Type>()),
ServiceInfo.Of <ServiceFactory>()));
var service = container.Resolve <IService>();
Assert.AreEqual("instance", service.Message);
}
public void Should_return_null_if_instance_factory_is_not_resolved_on_TryResolve()
{
var container = new Container();
container.Register <IService>(made: Made.Of(
typeof(ServiceFactory).Method("Create", ArrayTools.Empty <Type>()),
ServiceInfo.Of <ServiceFactory>()));
var service = container.Resolve <IService>(IfUnresolved.ReturnDefault);
Assert.IsNull(service);
}
public void Should_throw_if_instance_factory_unresolved()
{
var container = new Container();
container.Register <IService, SomeService>(made: Made.Of(
r => typeof(ServiceFactory).Method("Create", ArrayTools.Empty <Type>()),
ServiceInfo.Of <ServiceFactory>()));
var ex = Assert.Throws <ContainerException>(() =>
container.Resolve <IService>());
Assert.AreEqual(Error.UnableToResolveUnknownService, ex.Error);
}
public void Can_use_static_method_for_service_creation()
{
var container = new Container();
container.Register <SomeService>(made: Made.Of(
r => r.ImplementationType.Method("Create", ArrayTools.Empty <Type>())));
var service = container.Resolve <SomeService>();
Assert.AreEqual("static", service.Message);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicArray{T}"/> struct that is empty.
/// </summary>
/// <param name="initialize">Must be <c>true</c>.</param>
/// <remarks>This constructor is a workaround to non-existing default constructors for value types.</remarks>
public DynamicArray(bool initialize)
{
Debug.Assert(initialize);
this._array = ArrayTools.Empty <T>();
this._length = 0;
}
public static T[] Match2 <T>(this T[] source, Func <T, bool> condition)
{
if (source == null || source.Length == 0)
{
return(source);
}
if (source.Length > 2)
{
var matchStart = 0;
T[] matches = null;
var matchFound = false;
var i = 0;
while (i < source.Length)
{
matchFound = condition(source[i]);
if (!matchFound)
{
// for accumulated matched items
if (i != 0 && i > matchStart)
{
matches = ArrayTools.AppendTo(source, matchStart, i - matchStart, matches);
}
matchStart = i + 1; // guess the next match start will be after the non-matched item
}
++i;
}
// when last match was found but not all items are matched (hence matchStart != 0)
if (matchFound && matchStart != 0)
{
return(ArrayTools.AppendTo(source, matchStart, i - matchStart, matches));
}
if (matches != null)
{
return(matches);
}
if (matchStart != 0) // no matches
{
return(ArrayTools.Empty <T>());
}
return(source);
}
if (source.Length == 2)
{
var condition0 = condition(source[0]);
var condition1 = condition(source[1]);
return(condition0 && condition1 ? new[] { source[0], source[1] }
: condition0 ? new[] { source[0] }
: condition1 ? new[] { source[1] }
: ArrayTools.Empty <T>());
}
return(condition(source[0]) ? source : ArrayTools.Empty <T>());
}
/// <summary>
/// Registers types of given assembly by all conventional registrars. See <see cref="AddConventionalRegistrar"/> method.
/// </summary>
/// <param name="assembly">Assembly to register</param>
/// <param name="config">Additional configuration</param>
public void RegisterAssemblyByConvention(Assembly assembly, ConventionalRegistrationConfig config)
{
var context = new ConventionalRegistrationContext(assembly, this, config);
foreach (var registerer in _conventionalRegistrars)
{
registerer.RegisterAssembly(context);
}
if (config.InstallInstallers)
{
this.Install(assembly);
}
// 这里使用 TPL 并行库的原因是因为存在大量仓储类型与应用服务需要注册，应最大限度利用 CPU 来进行操作
Parallel.ForEach(_waitRegisterInterceptor, keyValue =>
{
var proxyBuilder = new DefaultProxyBuilder();
Type proxyType;
if (keyValue.Key.IsInterface)
{
proxyType = proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(keyValue.Key, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else if (keyValue.Key.IsClass())
{
proxyType = proxyBuilder.CreateClassProxyTypeWithTarget(keyValue.Key, ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
}
else
{
throw new ArgumentException($"类型 {keyValue.Value} 不支持进行拦截器服务集成。");
}
var decoratorSetup = Setup.DecoratorWith(useDecorateeReuse: true);
// 使用 ProxyBuilder 创建好的代理类替换原有类型的实现
IocContainer.Register(keyValue.Key, proxyType,
made: Made.Of(type => type.GetConstructors().SingleOrDefault(c => c.GetParameters().Length != 0),
Parameters.Of.Type <IInterceptor[]>(request =>
{
var objects = new List <object>();
foreach (var interceptor in keyValue.Value)
{
objects.Add(request.Container.Resolve(interceptor));
}
return(objects.Cast <IInterceptor>().ToArray());
}),
PropertiesAndFields.Auto),
setup: decoratorSetup);
});
_waitRegisterInterceptor.Clear();
}
/// <summary>
/// Ensures that a service always resolves as lazy proxy (uses DefaultProxyBuilder).
/// </summary>
/// <param name="registrator">The registrator.</param>
/// <param name="interfaceType">The type of the interface.</param>
/// <param name="serviceKey">Optional service key.</param>
public static IRegistrator ResolveAsLazyViaProxyBuilder(this IRegistrator registrator, Type interfaceType, object serviceKey = null)
{
// registration of lazy interceptor
registrator.Register(typeof(LazyInterceptor <>), setup: Setup.Wrapper, ifAlreadyRegistered: IfAlreadyRegistered.Keep);
// lazy proxy wrapper
var proxyBuilder = new DefaultProxyBuilder();
var proxyType = proxyBuilder.CreateInterfaceProxyTypeWithTargetInterface(interfaceType,
ArrayTools.Empty <Type>(), ProxyGenerationOptions.Default);
// decorator for the generated proxy class
var decoratorSetup = GetDecoratorSetup(serviceKey);
// make typeof(LazyInterceptor<interfaceType>[])
var lazyInterceptorArrayType = typeof(LazyInterceptor <>).MakeGenericType(interfaceType).MakeArrayType();
// register the proxy class as decorator
registrator.Register(interfaceType, proxyType,
Reuse.Transient,
setup: decoratorSetup,
made: Made.Of(type => type.PublicConstructors().SingleOrDefault(ctor => ctor.GetParameters().Length != 0),
Parameters.Of
.Type(typeof(IInterceptor[]), lazyInterceptorArrayType)
.Type(interfaceType, r => null)));
return(registrator);
}
public object ActivatorCreateInstance()
{
return(Activator.CreateInstance(typeof(X),
Activator.CreateInstance(typeof(A), ArrayTools.Empty <object>()),
Activator.CreateInstance(typeof(B), ArrayTools.Empty <object>())));
}