public Aspect(
Type type,
AspectScope scope,
AspectActivation activation,
IAspectConstruction construction,
ICrosscutting crosscutting,
IEnumerable <Advice> advices,
IEnumerable <MemberImport> memberImports,
IEnumerable <MemberIntroduction> memberIntroductions)
{
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("construction", construction);
ArgumentUtility.CheckNotNull("crosscutting", crosscutting);
ArgumentUtility.CheckNotNull("advices", advices);
ArgumentUtility.CheckNotNull("memberImports", memberImports);
ArgumentUtility.CheckNotNull("memberIntroductions", memberIntroductions);
_type = type;
_scope = scope;
_activation = activation;
_construction = construction;
_crosscutting = crosscutting;
_advices = advices;
_memberImports = memberImports;
_memberIntroductions = memberIntroductions;
}
public virtual IEnumerable <IOrdering> Build(ICrosscutting crosscutting, OrderingAttributeBase ordering)
{
var position = ordering.Position;
var typeOrdering = ordering as AspectTypeOrderingAttribute;
if (typeOrdering != null)
{
return(Build(crosscutting.Type, typeOrdering.Aspects, position, (before, after) => new AspectTypeOrdering(before, after, c_source)));
}
var roleOrdering = ordering as AspectRoleOrderingAttribute;
if (roleOrdering != null)
{
return(Build(crosscutting.Role, roleOrdering.Aspects, position, (before, after) => new AspectRoleOrdering(before, after, c_source)));
}
var nameOrdering = ordering as AdviceNameOrderingAttribute;
if (nameOrdering != null)
{
return(Build(crosscutting.Name, nameOrdering.Advices, position, (before, after) => new AdviceNameOrdering(before, after, c_source)));
}
throw new Exception();
}
public Advice(
Aspect aspect, MethodInfo method, AdviceExecution execution, ICrosscutting crosscutting)
: base(aspect)
{
ArgumentUtility.CheckNotNull("method", method);
ArgumentUtility.CheckNotNull("aspect", aspect);
ArgumentUtility.CheckNotNull("crosscutting", crosscutting);
_method = method;
_execution = execution;
_crosscutting = crosscutting;
}
public static Aspect GetAspect(
Type type = null,
AspectScope scope = (AspectScope)0,
AspectActivation activation = (AspectActivation)0,
IAspectConstruction construction = null,
ICrosscutting crosscutting = null,
IEnumerable <Advice> advices = null,
IEnumerable <MemberImport> imports = null,
IEnumerable <MemberIntroduction> introductions = null)
{
type = type ?? typeof(UnspecifiedAspect);
scope = GetAspectScope(scope);
activation = GetAspectActivation(activation);
construction = construction ?? GetConstruction();
crosscutting = crosscutting ?? GetCrosscutting();
advices = advices ?? GetMultiple(() => GetAdvice());
imports = imports ?? new MemberImport[0];
introductions = introductions ?? new MemberIntroduction[0];
return(new Aspect(type, scope, activation, construction, crosscutting, advices, imports, introductions));
}
public override bool Accept(CrosscuttingDependencyProvider dependencyProvider, ICrosscutting crosscutting1, ICrosscutting crosscutting2)
{
return(dependencyProvider.VisitAspectRole(this, crosscutting1, crosscutting2));
}
public IEnumerable <IOrdering> BuildOrderings(ICrosscutting crosscutting, ICustomAttributeProvider customAttributeProvider)
{
return(customAttributeProvider.GetCustomAttributes <OrderingAttributeBase> (true).SelectMany(x => Build(crosscutting, x)));
}
public abstract bool Accept(CrosscuttingDependencyProvider dependencyProvider, ICrosscutting crosscutting1, ICrosscutting crosscutting2);
public static Advice GetAdvice(MethodInfo method = null, AdviceExecution execution = (AdviceExecution)0, Aspect aspect = null, ICrosscutting crosscutting = null)
{
method = method ?? GetMethodInfo(returnType: typeof(void), parameterTypes: Type.EmptyTypes);
crosscutting = crosscutting ?? GetCrosscutting();
aspect = aspect ?? GetAspect();
return(new Advice(aspect, method, execution, crosscutting));
}
public bool VisitAdviceName(AdviceNameOrdering ordering, ICrosscutting crosscutting1, ICrosscutting crosscutting2)
{
return(crosscutting1.Name == ordering.BeforeAdvice && crosscutting2.Name == ordering.AfterAdvice);
}
public bool VisitAspectRole(AspectRoleOrdering ordering, ICrosscutting crosscutting1, ICrosscutting crosscutting2)
{
return(crosscutting1.Role.IsMatchWildcard(ordering.BeforeRole) && crosscutting2.Role.IsMatchWildcard(ordering.AfterRole));
}
public bool VisitAspectType(AspectTypeOrdering ordering, ICrosscutting crosscutting1, ICrosscutting crosscutting2)
{
return(ordering.BeforeType.IsAssignableFrom(crosscutting1.Type) && ordering.AfterType.IsAssignableFrom(crosscutting2.Type));
}
