public TypeDiscoveryContext(
ITypeSystemObject type,
TypeRegistry typeRegistry,
TypeLookup typeLookup,
IDescriptorContext descriptorContext,
ITypeInterceptor typeInterceptor,
string scope)
{
Type = type ??
throw new ArgumentNullException(nameof(type));
_typeRegistry = typeRegistry ??
throw new ArgumentNullException(nameof(typeRegistry));
_typeLookup = typeLookup ??
throw new ArgumentNullException(nameof(typeLookup));
DescriptorContext = descriptorContext ??
throw new ArgumentNullException(nameof(descriptorContext));
TypeInterceptor = typeInterceptor ??
throw new ArgumentNullException(nameof(typeInterceptor));
Scope = scope;
IsDirective = type is DirectiveType;
IsSchema = type is Schema;
if (type is INamedType nt)
{
IsType = true;
IsIntrospectionType = nt.IsIntrospectionType();
}
InternalName = "Type_" + Guid.NewGuid().ToString("N");
}
public TypeInitializer(
IDescriptorContext descriptorContext,
TypeRegistry typeRegistry,
IReadOnlyList <ITypeReference> initialTypes,
IReadOnlyList <Type> externalResolverTypes,
IsOfTypeFallback?isOfType,
Func <TypeSystemObjectBase, bool> isQueryType)
{
_context = descriptorContext ??
throw new ArgumentNullException(nameof(descriptorContext));
_typeRegistry = typeRegistry ??
throw new ArgumentNullException(nameof(typeRegistry));
_initialTypes = initialTypes ??
throw new ArgumentNullException(nameof(initialTypes));
_externalResolverTypes = externalResolverTypes ??
throw new ArgumentNullException(nameof(externalResolverTypes));
_isOfType = isOfType;
_isQueryType = isQueryType ??
throw new ArgumentNullException(nameof(isQueryType));
_interceptor = descriptorContext.TypeInterceptor;
_typeInspector = descriptorContext.TypeInspector;
_typeLookup = new TypeLookup(_typeInspector, _typeRegistry);
_typeReferenceResolver = new TypeReferenceResolver(
_typeInspector, _typeRegistry, _typeLookup);
}
public TypeDiscoveryContext(
ITypeSystemObject type,
string scope,
IServiceProvider services,
IDescriptorContext descriptorContext,
ITypeInterceptor interceptor)
{
Type = type
?? throw new ArgumentNullException(nameof(type));
Scope = scope;
Services = services
?? throw new ArgumentNullException(nameof(services));
DescriptorContext = descriptorContext
?? throw new ArgumentNullException(nameof(descriptorContext));
Interceptor = interceptor
?? throw new ArgumentNullException(nameof(interceptor));
IsDirective = type is DirectiveType;
IsSchema = type is Schema;
if (type is INamedType nt)
{
IsType = true;
IsIntrospectionType = nt.IsIntrospectionType();
}
InternalName = "Type_" + Guid.NewGuid().ToString("N");
}
public TypeDiscoverer(
ISet <ITypeReference> initialTypes,
IDictionary <ClrTypeReference, ITypeReference> clrTypeReferences,
IDescriptorContext descriptorContext,
ITypeInterceptor interceptor,
IServiceProvider services)
{
_unregistered.AddRange(IntrospectionTypes.All);
_unregistered.AddRange(Directives.All);
_unregistered.AddRange(clrTypeReferences.Values);
_unregistered.AddRange(initialTypes);
_clrTypeReferences = clrTypeReferences;
_typeRegistrar = new TypeRegistrar(
_registeredTypes,
clrTypeReferences,
descriptorContext,
interceptor,
services);
_handlers = new ITypeRegistrarHandler[]
{
new SchemaTypeReferenceHandler(),
new ClrTypeReferenceHandler(),
new SyntaxTypeReferenceHandler()
};
}
public RegisteredType(
TypeSystemObjectBase type,
bool isInferred,
TypeRegistry typeRegistry,
TypeLookup typeLookup,
IDescriptorContext descriptorContext,
ITypeInterceptor typeInterceptor,
string?scope)
{
Type = type;
_typeRegistry = typeRegistry;
_typeLookup = typeLookup;
IsInferred = isInferred;
DescriptorContext = descriptorContext;
TypeInterceptor = typeInterceptor;
IsExtension = Type is INamedTypeExtensionMerger;
IsSchema = Type is ISchema;
Scope = scope;
if (type is INamedType nt)
{
IsNamedType = true;
IsIntrospectionType = nt.IsIntrospectionType();
Kind = nt.Kind;
}
else if (type is DirectiveType)
{
IsDirectiveType = true;
Kind = TypeKind.Directive;
}
}
/// <summary>
/// API to configure interception for a type.
/// </summary>
/// <param name="typeToIntercept">Type to intercept.</param>
/// <param name="name">Name type is registered under.</param>
/// <param name="interceptor">Interceptor to use.</param>
/// <returns>This extension object.</returns>
public Interception SetInterceptorFor(Type typeToIntercept, string name, ITypeInterceptor interceptor)
{
NamedTypeBuildKey key = new NamedTypeBuildKey(typeToIntercept, name);
TypeInterceptionPolicy policy = new TypeInterceptionPolicy(interceptor);
Context.Policies.Set <ITypeInterceptionPolicy>(policy, key);
return(this);
}
/// <summary>
/// Creates a new instance of type <paramref name="type"/> that is intercepted with the behaviors in
/// <paramref name="interceptionBehaviors"/>.
/// </summary>
/// <param name="type">The type of the object to create.</param>
/// <param name="interceptor">The <see cref="ITypeInterceptor"/> to use when creating the proxy.</param>
/// <param name="interceptionBehaviors">The interception behaviors for the new proxy.</param>
/// <param name="constructorParameters">The arguments for the creation of the new instance.</param>
/// <returns>An instance of a class compatible with <paramref name="type"/> that includes execution of the
/// given <paramref name="interceptionBehaviors"/>.</returns>
/// <exception cref="ArgumentNullException">when <paramref name="type"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException">when <paramref name="interceptor"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException">when <paramref name="interceptionBehaviors"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">when <paramref name="interceptor"/> cannot intercept
/// <paramref name="type"/>.</exception>
public static object NewInstance(
Type type,
ITypeInterceptor interceptor,
IEnumerable <IInterceptionBehavior> interceptionBehaviors,
params object[] constructorParameters)
{
return(NewInstanceWithAdditionalInterfaces(type, interceptor, interceptionBehaviors, Type.EmptyTypes, constructorParameters));
}
internal override void DoConfigure(IUnityContainer container, ITypeInterceptor interceptor)
{
container.Configure <Interception>()
.SetInterceptorFor(
this.Type,
string.IsNullOrEmpty(this.Name) ? null : this.Name,
interceptor);
}
/// <summary>
/// Set the interceptor for a type, regardless of what name is used to resolve the instances.
/// </summary>
/// <param name="typeToIntercept">Type to intercept</param>
/// <param name="interceptor">Interceptor instance.</param>
/// <returns>This extension object.</returns>
public Interception SetDefaultInterceptorFor(Type typeToIntercept, ITypeInterceptor interceptor)
{
Guard.ArgumentNotNull(typeToIntercept, "typeToIntercept");
Guard.ArgumentNotNull(interceptor, "interceptor");
GuardTypeInterceptable(typeToIntercept, interceptor);
Context.Policies.Set <ITypeInterceptionPolicy>(new TypeInterceptionPolicy(interceptor), typeToIntercept);
return(this);
}
public TypeDiscoverer(
IDescriptorContext context,
TypeRegistry typeRegistry,
TypeLookup typeLookup,
IEnumerable <ITypeReference> initialTypes,
ITypeInterceptor interceptor,
bool includeSystemTypes = true)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (typeRegistry is null)
{
throw new ArgumentNullException(nameof(typeRegistry));
}
if (typeLookup is null)
{
throw new ArgumentNullException(nameof(typeLookup));
}
if (initialTypes is null)
{
throw new ArgumentNullException(nameof(initialTypes));
}
if (interceptor is null)
{
throw new ArgumentNullException(nameof(interceptor));
}
_typeRegistry = typeRegistry;
if (includeSystemTypes)
{
_unregistered.AddRange(
IntrospectionTypes.CreateReferences(context.TypeInspector));
_unregistered.AddRange(
Directives.CreateReferences(context.TypeInspector));
}
_unregistered.AddRange(typeRegistry.GetTypeRefs());
_unregistered.AddRange(initialTypes.Distinct());
_typeRegistrar = new TypeRegistrar(context, typeRegistry, typeLookup, interceptor);
_handlers = new ITypeRegistrarHandler[]
{
new SchemaTypeReferenceHandler(),
new ExtendedTypeReferenceHandler(context.TypeInspector),
new SyntaxTypeReferenceHandler(context.TypeInspector)
};
_typeInspector = context.TypeInspector;
}
/// <summary>
/// Creates a new instance of type <typeparamref name="T"/> that is intercepted with the behaviors in
/// <paramref name="interceptionBehaviors"/>.
/// </summary>
/// <typeparam name="T">The type of the object to create.</typeparam>
/// <param name="interceptor">The <see cref="ITypeInterceptor"/> to use when creating the proxy.</param>
/// <param name="interceptionBehaviors">The interception behaviors for the new proxy.</param>
/// <param name="constructorParameters">The arguments for the creation of the new instance.</param>
/// <returns>An instance of a class compatible with <typeparamref name="T"/> that includes execution of the
/// given <paramref name="interceptionBehaviors"/>.</returns>
/// <exception cref="ArgumentNullException">when <paramref name="interceptor"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentNullException">when <paramref name="interceptionBehaviors"/> is <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">when <paramref name="interceptor"/> cannot intercept
/// <typeparamref name="T"/>.</exception>
public static T NewInstance <T>(
ITypeInterceptor interceptor,
IEnumerable <IInterceptionBehavior> interceptionBehaviors,
params object[] constructorParameters)
where T : class
{
return
((T)NewInstanceWithAdditionalInterfaces(typeof(T), interceptor, interceptionBehaviors, Type.EmptyTypes, constructorParameters));
}
/// <summary>
/// Interceptor to use to create type proxy
/// </summary>
/// <param name="context">Context for current build operation.</param>
public ITypeInterceptor GetInterceptor(IUnityContainer container)
{
if (null == _policy)
{
_policy = (ITypeInterceptor)container.Resolve(_type, _name, null);
}
return(_policy);
}
public TypeRegistrar(
IDictionary <ITypeReference, RegisteredType> registeredTypes,
IDictionary <ClrTypeReference, ITypeReference> clrTypeReferences,
IDescriptorContext descriptorContext,
ITypeInterceptor interceptor,
IServiceProvider services)
{
_registered = registeredTypes;
_clrTypeReferences = clrTypeReferences;
_descriptorContext = descriptorContext;
_interceptor = interceptor;
_serviceFactory.Services = services;
}
public static object NewInstanceWithAdditionalInterfaces(
Type type,
ITypeInterceptor interceptor,
IEnumerable <IInterceptionBehavior> interceptionBehaviors,
IEnumerable <Type> additionalInterfaces,
params object[] constructorParameters)
{
Guard.ArgumentNotNull(type, "type");
Guard.ArgumentNotNull(interceptor, "interceptor");
Guard.ArgumentNotNull(interceptionBehaviors, "interceptionBehaviors");
Guard.ArgumentNotNull(additionalInterfaces, "additionalInterfaces");
if (!interceptor.CanIntercept(type))
{
throw new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
Resources.InterceptionNotSupported,
type.FullName),
"type");
}
var behaviors = interceptionBehaviors.ToList();
if (behaviors.Where(ib => ib == null).Count() > 0)
{
throw new ArgumentException(
string.Format(CultureInfo.CurrentCulture, Resources.NullBehavior),
"interceptionBehaviors");
}
Type implementationType = type;
var activeBehaviors = behaviors.Where(ib => ib.WillExecute);
Type[] allAdditionalInterfaces = GetAllAdditionalInterfaces(activeBehaviors, additionalInterfaces);
Type interceptionType = interceptor.CreateProxyType(implementationType, allAdditionalInterfaces);
var proxy = (IInterceptingProxy)Activator.CreateInstance(interceptionType, constructorParameters);
foreach (IInterceptionBehavior interceptionBehavior in activeBehaviors)
{
proxy.AddInterceptionBehavior(interceptionBehavior);
}
return(proxy);
}
public TypeRegistrar(
IDescriptorContext context,
TypeRegistry typeRegistry,
TypeLookup typeLookup,
ITypeInterceptor typeInterceptor)
{
_context = context ??
throw new ArgumentNullException(nameof(context));
_typeRegistry = typeRegistry ??
throw new ArgumentNullException(nameof(typeRegistry));
_typeLookup = typeLookup ??
throw new ArgumentNullException(nameof(typeLookup));
_interceptor = typeInterceptor ??
throw new ArgumentNullException(nameof(typeInterceptor));
_serviceFactory.Services = context.Services;
}
/// <summary>
/// Set the interceptor for a type, regardless of what name is used to resolve the instances.
/// </summary>
/// <param name="typeToIntercept">Type to intercept</param>
/// <param name="interceptor">Interceptor instance.</param>
/// <returns>This extension object.</returns>
public Interception SetDefaultInterceptorFor(Type typeToIntercept, ITypeInterceptor interceptor)
{
Guard.ArgumentNotNull(typeToIntercept, "typeToIntercept");
Guard.ArgumentNotNull(interceptor, "interceptor");
GuardTypeInterceptable(typeToIntercept, interceptor);
Context.Policies.Set <ITypeInterceptionPolicy>(new FixedTypeInterceptionPolicy(interceptor), typeToIntercept);
// add policy injection behavior if using this configuration API to set the interceptor
var interceptionBehaviorsPolicy = new InterceptionBehaviorsPolicy();
interceptionBehaviorsPolicy.AddBehaviorKey(NamedTypeBuildKey.Make <PolicyInjectionBehavior>());
Context.Policies.Set <IInterceptionBehaviorsPolicy>(interceptionBehaviorsPolicy, typeToIntercept);
return(this);
}
public TypeInitializer(
IServiceProvider services,
IDescriptorContext descriptorContext,
IEnumerable <ITypeReference> initialTypes,
IEnumerable <Type> externalResolverTypes,
ITypeInterceptor interceptor,
IsOfTypeFallback isOfType,
Func <TypeSystemObjectBase, bool> isQueryType)
{
_services = services;
_descriptorContext = descriptorContext;
_contextData = _descriptorContext.ContextData;
_initialTypes = initialTypes.ToList();
_externalResolverTypes = externalResolverTypes.ToList();
_interceptor = interceptor;
_isOfType = isOfType;
_isQueryType = isQueryType;
}
/// <summary>
/// Set the interceptor for a type, regardless of what name is used to resolve the instances.
/// </summary>
/// <param name="typeToIntercept">Type to intercept</param>
/// <param name="interceptor">Interceptor instance.</param>
/// <returns>This extension object.</returns>
public Interception SetDefaultInterceptorFor(Type typeToIntercept, ITypeInterceptor interceptor)
{
throw new NotImplementedException();
//Guard.ArgumentNotNull(typeToIntercept, "typeToIntercept");
//Guard.ArgumentNotNull(interceptor, "interceptor");
//GuardTypeInterceptable(typeToIntercept, interceptor);
//Context.Policies.Set(typeToIntercept, UnityContainer.All, typeof(ITypeInterceptionPolicy),
// new FixedTypeInterceptionPolicy(interceptor));
//// add policy injection behavior if using this configuration API to set the interceptor
//var interceptionBehaviorsPolicy = new InterceptionBehaviorsPolicy();
//interceptionBehaviorsPolicy.AddBehaviorKey(NamedTypeBuildKey.Make<PolicyInjectionBehavior>());
//Context.Policies.Set(typeToIntercept, UnityContainer.All,
// typeof(IInterceptionBehaviorsPolicy), interceptionBehaviorsPolicy);
//return this;
}
/// <summary>
/// API to configure interception for a type.
/// </summary>
/// <param name="typeToIntercept">Type to intercept.</param>
/// <param name="name">Name type is registered under.</param>
/// <param name="interceptor">Interceptor to use.</param>
/// <returns>This extension object.</returns>
public Interception SetInterceptorFor(Type typeToIntercept, string name, ITypeInterceptor interceptor)
{
Guard.ArgumentNotNull(typeToIntercept, "typeToIntercept");
Guard.ArgumentNotNull(interceptor, "interceptor");
GuardTypeInterceptable(typeToIntercept, interceptor);
var key = new NamedTypeBuildKey(typeToIntercept, name);
var policy = new FixedTypeInterceptionPolicy(interceptor);
Context.Policies.Set(key.Type, key.Name, typeof(ITypeInterceptionPolicy), policy);
// add policy injection behavior if using this configuration API to set the interceptor
var interceptionBehaviorsPolicy = new InterceptionBehaviorsPolicy();
interceptionBehaviorsPolicy.AddBehaviorKey(NamedTypeBuildKey.Make <PolicyInjectionBehavior>());
Context.Policies.Set(key.Type, key.Name, typeof(IInterceptionBehaviorsPolicy), interceptionBehaviorsPolicy);
return(this);
}
internal void Configure(IUnityContainer container)
{
IInterceptor interceptor = this.CreateInstance <IInterceptor>();
IInstanceInterceptor instanceInterceptor = interceptor as IInstanceInterceptor;
if (instanceInterceptor != null)
{
foreach (InterceptorTargetConfigurationElementBase target in Targets)
{
target.DoConfigure(container, instanceInterceptor);
}
}
else
{
ITypeInterceptor typeInterceptor = (ITypeInterceptor)interceptor;
foreach (InterceptorTargetConfigurationElementBase target in Targets)
{
target.DoConfigure(container, typeInterceptor);
}
}
}
public override void PreBuildUp(IBuilderContext context)
{
Guard.ArgumentNotNull(context, "context");
if (!this.CanIntercept(context))
{
return;
}
if (context.Existing != null)
{
return;
}
var interceptionPolicy = FindInterceptionPolicy <ITypeInterceptionPolicy>(context);
ITypeInterceptor interceptor = null;
if (interceptionPolicy == null)
{
interceptor = context.NewBuildUp <IInterceptor>(typeof(IInterceptor).AssemblyQualifiedName) as ITypeInterceptor;
if (null == interceptor)
{
return;
}
if (!interceptor.CanIntercept(context.BuildKey.Type))
{
return;
}
interceptionPolicy = new FixedTypeInterceptionPolicy(interceptor);
context.Policies.Set <ITypeInterceptionPolicy>(interceptionPolicy, context.BuildKey);
context.Policies.Clear <IInstanceInterceptionPolicy>(context.BuildKey);
}
var interceptionBehaviorsPolicy = FindInterceptionPolicy <IInterceptionBehaviorsPolicy>(context);
if (null == interceptionBehaviorsPolicy)
{
var policyInjectionBehavior = new InterceptionBehavior <PolicyInjectionBehavior>();
policyInjectionBehavior.AddPolicies(context.OriginalBuildKey.Type, context.BuildKey.Type, context.BuildKey.Name, context.Policies);
}
}
/// <summary>
/// API to configure interception for a type.
/// </summary>
/// <typeparam name="T">Type to intercept</typeparam>
/// <param name="interceptor">Interceptor object to use.</param>
/// <returns>This extension object.</returns>
public Interception SetInterceptorFor <T>(ITypeInterceptor interceptor)
{
return(this.SetInterceptorFor(typeof(T), null, interceptor));
}
/// <summary>
/// API to configure interception for a type.
/// </summary>
/// <typeparam name="T">Type to intercept</typeparam>
/// <param name="name">Name type is registered under.</param>
/// <param name="interceptor">Interceptor object to use.</param>
/// <returns>This extension object.</returns>
public Interception SetInterceptorFor <T>(string name, ITypeInterceptor interceptor)
{
return(this.SetInterceptorFor(typeof(T), name, interceptor));
}
/// <summary>
/// API to configure interception for a type.
/// </summary>
/// <param name="typeToIntercept">Type to intercept.</param>
/// <param name="interceptor">Interceptor to use.</param>
/// <returns>This extension object.</returns>
public Interception SetInterceptorFor(Type typeToIntercept, ITypeInterceptor interceptor)
{
return(this.SetInterceptorFor(typeToIntercept, null, interceptor));
}
/// <summary>
/// Set the interceptor for a type, regardless of what name is used to resolve the instances.
/// </summary>
/// <typeparam name="TTypeToIntercept">Type to intercept</typeparam>
/// <param name="interceptor">Interceptor instance.</param>
/// <returns>This extension object.</returns>
public Interception SetDefaultInterceptorFor <TTypeToIntercept>(ITypeInterceptor interceptor)
{
return(this.SetDefaultInterceptorFor(typeof(TTypeToIntercept), interceptor));
}
public static Type InterceptWithAttributes <TService>(this ITypeInterceptor interceptor) where TService : class
{
return(InterceptWithAttributes(interceptor, typeof(TService)));
}
/// <summary>
/// Create a new instance of <see cref="FixedTypeInterceptionPolicy"/> that
/// uses the given <see cref="ITypeInterceptor"/>.
/// </summary>
/// <param name="interceptor">Interceptor to use.</param>
public FixedTypeInterceptionPolicy(ITypeInterceptor interceptor)
{
this.interceptor = interceptor;
}
internal abstract void DoConfigure(IUnityContainer container, ITypeInterceptor interceptor);
public static Type Intercept <TToIntercept, TInterceptor>(this ITypeInterceptor interceptor) where TInterceptor : IInterceptionHandler, new()
{
return(interceptor.Intercept(typeof(TToIntercept), typeof(TInterceptor)));
}
/// <summary>
/// Create a new instance of <see cref="FixedTypeInterceptionPolicy"/> that
/// uses the given <see cref="ITypeInterceptor"/>.
/// </summary>
/// <param name="interceptor">Interceptor to use.</param>
public FixedTypeInterceptionPolicy(ITypeInterceptor interceptor)
{
this.interceptor = interceptor;
}
/// <summary>
/// Creates an instance of TInterface.
/// </summary>
/// <returns></returns>
public TInterface Create(ITypeInterceptor typeInterceptor, TInterceptionBehavior[] behaviors)
{
return((TInterface)Intercept.NewInstance <object>(typeInterceptor, behaviors));
}
