public void doesnt_match_subpackage_c_based_on_required_and_noneOf()
{
instance.Require(REQUIRE).NoneOf(NONE_OF);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.False(typeFilter.Matches(ITEM_C));
}
public void doesnt_match_based_on_noneOf()
{
instance.NoneOf(NONE_OF);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.False(typeFilter.Matches(ITEM_C));
}
public void matches_based_on_anyOf()
{
instance.AnyOf(ANY_OF);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.That(typeFilter.Matches(ITEM_A), Is.True);
}
public void matches_based_on_noneOf()
{
instance.NoneOf(NONE_OF);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.True(typeFilter.Matches(ITEM_B));
}
public SwiftTranslator(Poco2SwiftType configuration, ITypeFilter filter, DocumentationCache documentation, IAppDomainProxy appDomain)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (filter == null)
{
throw new ArgumentNullException("filter");
}
if (documentation == null)
{
throw new ArgumentNullException("documentation");
}
if (appDomain == null)
{
throw new ArgumentNullException("appDomain");
}
_configuration = configuration;
_filter = filter;
_documentation = documentation;
_appDomain = appDomain;
InitPredefinedMapTypes();
InitExternalTypes();
}
private void MapTypeForFilterBinding(ITypeFilter filter, Type type, object item)
{
foreach (Type requiredType in RequiredTypesFor(filter, type))
{
_injector.Map(requiredType).ToValue(item);
}
}
public void matches_subpackage_b_based_on_required()
{
instance.Require(REQUIRE);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.True(typeFilter.Matches(ITEM_B));
}
public void AddFilter(ITypeFilter filter)
{
if (null == filter)
{
throw new ArgumentNullException("filter");
}
_filters.Add(filter);
}
/// <summary>
/// 构造方法。
/// </summary>
public Pointcut(ITypeFilter typeFilter, IMethodMatcher methodMatcher)
{
Check.MustNotNull(typeFilter, "typeFilter");
Check.MustNotNull(methodMatcher, "methodMatcher");
this.TypeFilter = typeFilter;
this.MethodMatcher = methodMatcher;
}
/// <summary>
/// 构造方法。
/// </summary>
public IntroductionAspect(ITypeFilter typeFilter, IIntroductionAdvice advice)
{
Check.MustNotNull(typeFilter, "typeFilter");
Check.MustNotNull(advice, "advice");
this.TypeFilter = typeFilter;
this.Advice = advice;
}
public void Deserialization()
{
ITypeFilter deserializedVersion
= (ITypeFilter)SerializationTestUtils.SerializeAndDeserialize(
TrueTypeFilter.True);
Assert.IsTrue(Object.ReferenceEquals(TrueTypeFilter.True, deserializedVersion),
"Singleton instance not being deserialized correctly");
}
/// <summary>
/// Initializes a new instance of the <see cref="ConventionSyntax"/> class.
/// </summary>
/// <param name="bindingBuilder">The binding builder.</param>
/// <param name="typeFilter">The type filter.</param>
/// <param name="bindingGeneratorFactory">The binding generator factory.</param>
public ConventionSyntax(
IConventionBindingBuilder bindingBuilder,
ITypeFilter typeFilter,
IBindingGeneratorFactory bindingGeneratorFactory)
{
this.bindingBuilder = bindingBuilder;
this.typeFilter = typeFilter;
this.bindingGeneratorFactory = bindingGeneratorFactory;
}
private void MapTypeForFilterBinding(ITypeFilter filter, Type type, object view)
{
List <Type> requiredTypes = RequiredTypesFor(filter, type);
foreach (Type requiredType in requiredTypes)
{
_injector.Map(requiredType).ToValue(view);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConventionSyntax"/> class.
/// </summary>
/// <param name="bindingBuilder">The binding builder.</param>
/// <param name="typeFilter">The type filter.</param>
/// <param name="bindingGeneratorFactory">The binding generator factory.</param>
public ConventionSyntax(
IConventionBindingBuilder bindingBuilder,
ITypeFilter typeFilter,
IBindingGeneratorFactory bindingGeneratorFactory)
{
this.bindingBuilder = bindingBuilder;
this.typeFilter = typeFilter;
this.bindingGeneratorFactory = bindingGeneratorFactory;
}
public void SetUp()
{
logger = new Mock<ILogger>();
handler = new Mock<IMediatorViewHandler>();
TypeMatcher matcher = new TypeMatcher().AllOf(typeof(SupportView));
filter = matcher.CreateTypeFilter();
mapper = new MediatorMapper(matcher.CreateTypeFilter(), handler.Object, logger.Object);
}
/// <summary>
/// Adds the include filter.
/// </summary>
/// <param name="filter">The filter type.</param>
/// <returns></returns>
public IAssemblyTypeScanner WithIncludeFilter(ITypeFilter filter)
{
if (filter != null)
{
TypeInclusionTypeFilter.Add(filter);
}
return(this);
}
public void matches_based_on_noneOf_twice()
{
instance.NoneOf(NONE_OF);
instance.NoneOf(NONE_OF_2);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.False(typeFilter.Matches(ITEM_B));
Assert.False(typeFilter.Matches(ITEM_C));
}
public void SetUp()
{
logger = new Mock <ILogging>();
handler = new Mock <IMediatorViewHandler>();
TypeMatcher matcher = new TypeMatcher().AllOf(typeof(SupportView));
filter = matcher.CreateTypeFilter();
mapper = new MediatorMapper(matcher.CreateTypeFilter(), handler.Object, logger.Object);
}
public void matches_based_on_anyOf_twice()
{
instance.AnyOf(ANY_OF);
instance.AnyOf(ANY_OF_2);
ITypeFilter typeFilter = instance.CreateTypeFilter();
Assert.True(typeFilter.Matches(ITEM_A));
Assert.True(typeFilter.Matches(ITEM_B));
Assert.True(typeFilter.Matches(ITEM_C));
}
private void UnmapTypeForFilterBinding(ITypeFilter filter, Type type, object item)
{
foreach (Type requiredType in RequiredTypesFor(filter, type))
{
if (_injector.SatisfiesDirectly(requiredType))
{
_injector.Unmap(requiredType);
}
}
}
public void Intersection()
{
Assert.IsTrue(exceptionFilter.Matches(typeof(SystemException)));
Assert.IsTrue(hasRootCauseFilter.Matches(typeof(StackOverflowException)));
ITypeFilter intersection = TypeFilters.Intersection(exceptionFilter, hasRootCauseFilter);
Assert.IsFalse(intersection.Matches(typeof(SystemException)));
Assert.IsFalse(intersection.Matches(typeof(TestObject)));
Assert.IsTrue(intersection.Matches(typeof(StackOverflowException)));
}
public void Union()
{
Assert.IsTrue(exceptionFilter.Matches(typeof(SystemException)));
Assert.IsFalse(exceptionFilter.Matches(typeof(TestObject)));
Assert.IsFalse(itoFilter.Matches(typeof(Exception)));
Assert.IsTrue(itoFilter.Matches(typeof(TestObject)));
ITypeFilter union = TypeFilters.Union(exceptionFilter, itoFilter);
Assert.IsTrue(union.Matches(typeof(SystemException)));
Assert.IsTrue(union.Matches(typeof(TestObject)));
}
private ScriptContext(string name, ITypeFilter typeFilter)
{
ArgumentUtility.CheckNotNullOrEmpty("name", name);
ArgumentUtility.CheckNotNull("typeFilter", typeFilter);
_name = name;
var moduleScope = ReflectionHelper.CreateModuleScope("Scripting.ScriptContext." + name, false);
_proxyProvider = new StableBindingProxyProvider(typeFilter, moduleScope);
}
private List <Type> RequiredTypesFor(ITypeFilter filter, Type type)
{
List <Type> requiredTypes = new List <Type>(filter.AllOfTypes);
if (!requiredTypes.Contains(type))
{
requiredTypes.Add(type);
}
return(requiredTypes);
}
public void GetDistinctTypes_WhenFiltered_ReturnsCorrectResult(ITypeFilter filter, int expected)
{
var fixture = new CustomAutoDataAttribute().Fixture;
var sut = fixture.Create <WindowLocator>();
var types = new List <Type> {
typeof(string), typeof(FakeWindow), typeof(object), typeof(FakeCustomWindow)
};
var actual = sut.GetDistinctTypes(types, filter).ToList();
Assert.Equal(expected, actual.Count);
}
private void UnmapTypeForFilterBinding(ITypeFilter filter, Type type, object view)
{
List <Type> requiredTypes = RequiredTypesFor(filter, type);
foreach (Type requiredType in requiredTypes)
{
if (_injector.HasDirectMapping(requiredType))
{
_injector.Unmap(requiredType);
}
}
}
public void DefaultClassFilterImplAlwaysMatchesRegardless()
{
Type oneType = typeof(One);
ControlFlowPointcut cut = new ControlFlowPointcut(oneType);
ITypeFilter filter = cut.TypeFilter;
Assert.IsTrue(filter.Matches(oneType),
"Must always match regardless of the supplied argument Type.");
Assert.IsTrue(filter.Matches(GetType()),
"Must always match even if the supplied argument Type is not " +
"a match for the Type supplied in the ctor.");
Assert.IsTrue(filter.Matches(null), // args are ingored in this impl...
"Must always match even if the supplied argument Type is null");
}
private List <Type> RequiredTypesFor(ITypeFilter filter, Type type)
{
List <Type> requiredTypes = new List <Type> ();
requiredTypes.AddRange(filter.AllOfTypes);
requiredTypes.AddRange(filter.AnyOfTypes);
if (requiredTypes.IndexOf(type) == -1)
{
requiredTypes.Add(type);
}
return(requiredTypes);
}
/// <summary>
/// Executes the <paramref name="filter"/> on the <paramref name="type"/>, logging information if it was
/// excluded.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="filter">The <see cref="Type"/> filter.</param>
/// <returns>The result of <see cref="ITypeFilter.ExcludeType"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> or <paramref name="filter"/> parameters
/// are <see langword="null"/>.</exception>
private static bool ApplyFilter(this Type type, ITypeFilter filter)
{
if (type == null)
throw new ArgumentNullException("type");
if (filter == null)
throw new ArgumentNullException("filter");
bool excludeType = filter.ExcludeType(type);
if (excludeType)
{
Trace.TraceInformation(
"The type '{0}' was excluded by the filter '{1}'.",
type,
filter.Name);
}
return excludeType;
}
/// <summary>
/// Adds field interception support to the target type.
/// </summary>
/// <param name="targetAssembly">The type that will be modified.</param>
/// <param name="hostTypeFilter">The filter that determines the host types to be modified.</param>
/// <param name="fieldFilter">The field filter that determines the fields that will be intercepted.</param>
public static void InterceptFields(this AssemblyDefinition targetAssembly, ITypeFilter hostTypeFilter,
IFieldFilter fieldFilter)
{
var typeWeaver = new ImplementFieldInterceptionHostWeaver(hostTypeFilter.ShouldWeave);
var fieldWeaver = new InterceptFieldAccess(fieldFilter);
var module = targetAssembly.MainModule;
var targetTypes = module.Types.Where(hostTypeFilter.ShouldWeave).ToArray();
foreach (var type in targetTypes)
{
typeWeaver.Weave(type);
foreach (var method in type.Methods.Where(m => m.HasBody))
{
fieldWeaver.Rewrite(method, method.GetILGenerator(), method.Body.Instructions.ToArray());
}
}
}
/// <summary>
/// Creates a new <see cref="ScriptContext"/>.
/// </summary>
/// <param name="name">The tag name of the <see cref="ScriptContext"/>. Must be unique. Suggested naming scheme:
/// company domain name + namespace of module (e.g. "rubicon.eu.Remotion.Data.DomainObjects.Scripting", "microsoft.com.Word.Scripting").
/// </param>
/// <param name="typeFilter">
/// The <see cref="ITypeFilter"/> which decides which <see cref="Type"/>|s are known in the <see cref="ScriptContext"/>.
/// </param>
public static ScriptContext Create(string name, ITypeFilter typeFilter)
{
ArgumentUtility.CheckNotNullOrEmpty("name", name);
ArgumentUtility.CheckNotNull("typeFilter", typeFilter);
lock (s_scriptContextLock)
{
var scriptContext = new ScriptContext(name, typeFilter);
try
{
s_scriptContexts.Add(name, scriptContext);
}
catch (ArgumentException)
{
var message = string.Format("ScriptContext '{0}' already exists.", name);
throw new ArgumentException(message);
}
return(scriptContext);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeMatchingPointcut"/> class for the given
/// attribute type
/// </summary>
/// <param name="classAttributeType">The attribute type to look for at the class level.</param>
/// <param name="methodAttributeType">The attribute type to look for at the method attribute.</param>
public AttributeMatchingPointcut(Type classAttributeType, Type methodAttributeType)
{
AssertUtils.IsTrue(classAttributeType != null || methodAttributeType != null,
"Either Type attribute type or Method attribute type needs to be specified (or both)");
if (classAttributeType != null)
{
this.typeFilter = new AttributeTypeFilter(classAttributeType);
} else
{
this.typeFilter = TrueTypeFilter.True;
}
if (methodAttributeType != null)
{
this.methodMatcher = new AttributeMethodMatcher(methodAttributeType);
} else
{
this.methodMatcher = TrueMethodMatcher.True;
}
}
public StableBindingProxyBuilder(Type proxiedType, ITypeFilter typeFilter, ModuleScope moduleScope)
{
ArgumentUtility.CheckNotNull("proxiedType", proxiedType);
ArgumentUtility.CheckNotNull("typeFilter", typeFilter);
_typeFilter = typeFilter;
_moduleScope = moduleScope;
_proxiedType = proxiedType;
_knownInterfaces = FindKnownInterfaces();
BuildClassMethodToInterfaceMethodsMap();
_forwardingProxyBuilder = new ForwardingProxyBuilder(_proxiedType.Name, _moduleScope, _proxiedType, _knownInterfaces);
_firstKnownBaseType = GetFirstKnownBaseType();
if (_firstKnownBaseType != null)
{
_publicMethodsInFirstKnownBaseType = _firstKnownBaseType.GetMethods().ToArray();
_knownBaseTypeStableMetadataTokenToMethodInfoMap = new StableMetadataTokenToMethodInfoMap(_firstKnownBaseType);
_firstKnownBaseTypeSpecialMethodsToPropertyMap = BuildSpecialMethodsToPropertyMap(_firstKnownBaseType);
}
}
public static Type LoadTypeByName(string name, bool disallowUnsafeTypes, ITypeFilter typeFilter)
{
if (disallowUnsafeTypes)
{
if (IsDisallowedType(name))
{
throw new EvilDeserializationException("Unsafe Type Deserialization Detected!", name);
}
if (!typeFilter.IsAllowed(name))
{
throw new UserEvilDeserializationException("Unsafe Type Deserialization Detected!", name);
}
}
try
{
// Try to load type name using strict version to avoid possible conflicts
// i.e. if there are different version available in GAC and locally
var typename = ToQualifiedAssemblyName(name, ignoreAssemblyVersion: false);
var type = Type.GetType(typename, true);
if (disallowUnsafeTypes && UnsafeInheritanceCheck(type))
{
throw new EvilDeserializationException(
"Unsafe Type Deserialization Detected!", name);
}
return(type);
}
catch (IOException)
{
var typename = ToQualifiedAssemblyName(name, ignoreAssemblyVersion: true);
var type = Type.GetType(typename, true);
if (disallowUnsafeTypes && UnsafeInheritanceCheck(type))
{
throw new EvilDeserializationException(
"Unsafe Type Deserialization Detected!", name);
}
return(type);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeMatchingPointcut"/> class for the given
/// attribute type
/// </summary>
/// <param name="classAttributeType">The attribute type to look for at the class level.</param>
/// <param name="methodAttributeType">The attribute type to look for at the method attribute.</param>
public AttributeMatchingPointcut(Type classAttributeType, Type methodAttributeType)
{
AssertUtils.IsTrue(classAttributeType != null || methodAttributeType != null,
"Either Type attribute type or Method attribute type needs to be specified (or both)");
if (classAttributeType != null)
{
this.typeFilter = new AttributeTypeFilter(classAttributeType);
}
else
{
this.typeFilter = TrueTypeFilter.True;
}
if (methodAttributeType != null)
{
this.methodMatcher = new AttributeMethodMatcher(methodAttributeType);
}
else
{
this.methodMatcher = TrueMethodMatcher.True;
}
}
/// <summary>
/// Executes the <paramref name="filter"/> on the <paramref name="type"/>, logging information if it was
/// excluded.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="filter">The <see cref="Type"/> filter.</param>
/// <returns>The result of <see cref="ITypeFilter.ExcludeType"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> or <paramref name="filter"/> parameters
/// are <see langword="null"/>.</exception>
private static bool ApplyFilter(this Type type, ITypeFilter filter)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
bool excludeType = filter.ExcludeType(type);
if (excludeType)
{
////TODO: Look into Tracing.
////Trace.TraceInformation(
//// "The type '{0}' was excluded by the filter '{1}'.",
//// type,
//// filter.Name);
}
return(excludeType);
}
public UnionTypeFilter(ITypeFilter[] filters)
{
_filters = filters;
}
/// <summary>
/// Creates the intersection of two <see cref="System.Type"/> filters.
/// </summary>
/// <remarks>
/// <p>
/// The filter arising from the intersection will match all of the
/// <see cref="System.Type"/> that both of the two supplied filters
/// would match.
/// </p>
/// </remarks>
/// <param name="first">
/// The first <see cref="System.Type"/> filter.
/// </param>
/// <param name="second">
/// The second <see cref="System.Type"/> filter.
/// </param>
/// <returns>
/// The intersection of the supplied <see cref="System.Type"/> filters.
/// </returns>
public static ITypeFilter Intersection(ITypeFilter first, ITypeFilter second)
{
return new IntersectionTypeFilter(new ITypeFilter[] {first, second});
}
public IntersectionTypeFilter(ITypeFilter[] filters)
{
_filters = filters;
}
/// <summary>
/// Creates a new instance of the
/// <see cref="Spring.Aop.Support.ComposablePointcut"/> class
/// that uses the supplied <paramref name="typeFilter"/> and
/// <paramref name="methodMatcher"/>.
/// </summary>
/// <param name="typeFilter">
/// The type filter to use.
/// </param>
/// <param name="methodMatcher">
/// The method matcher to use.
/// </param>
public ComposablePointcut(ITypeFilter typeFilter, IMethodMatcher methodMatcher)
{
_typeFilter = typeFilter;
_methodMatcher = methodMatcher;
}
/// <summary>
/// Creates a new instance of the
/// <see cref="Spring.Aop.Support.ComposablePointcut"/> class
/// that matches all the methods on all <see cref="System.Type"/>s.
/// </summary>
public ComposablePointcut()
{
_typeFilter = TrueTypeFilter.True;
_methodMatcher = TrueMethodMatcher.True;
}
public virtual void Visit(ITypeFilter customFiltersScore)
{
}
public SetterPointcut(Type type)
{
typeFilter = new RootTypeFilter(type);
}
/// <summary>
/// Intercepts all method bodies on the target item.
/// </summary>
/// <param name="target">The target to be modified.</param>
/// <param name="methodFilter">The method filter that will determine the methods that will be modified.</param>
public static void InterceptMethodBody(this IReflectionStructureVisitable target, IMethodFilter methodFilter, ITypeFilter typeFilter)
{
target.InterceptMethodBody(methodFilter.ShouldWeave, typeFilter.ShouldWeave);
}
/*============================================================================*/
/* Public Functions */
/*============================================================================*/
/**
* @inheritDoc
*/
public ITypeFilter CreateTypeFilter()
{
return _typeFilter == null ? _typeFilter = BuildTypeFilter () : _typeFilter;
}
public ITypeFilter CreateTypeFilter()
{
return typeFilter != null ? typeFilter : typeFilter = BuildTypeFilter();
}
/// <summary>
/// Adds field interception support to the target type.
/// </summary>
/// <param name="targetType">The type that will be modified.</param>
/// <param name="hostTypeFilter">The filter that determines the host types to be modified.</param>
/// <param name="fieldFilter">The field filter that determines the fields that will be intercepted.</param>
public static void InterceptFields(this IReflectionStructureVisitable targetType, ITypeFilter hostTypeFilter,
IFieldFilter fieldFilter)
{
var typeWeaver = new ImplementFieldInterceptionHostWeaver(hostTypeFilter.ShouldWeave);
var fieldWeaver = new InterceptFieldAccess(fieldFilter);
targetType.WeaveWith(fieldWeaver, m => true);
targetType.Accept(typeWeaver);
}
/// <summary>
/// Changes current pointcut to intersection of the current and supplied pointcut
/// </summary>
/// <param name="other">pointcut to diff against</param>
/// <returns>updated pointcut</returns>
public virtual ComposablePointcut Intersection(IPointcut other)
{
_typeFilter = TypeFilters.Intersection(_typeFilter, other.TypeFilter);
_methodMatcher = MethodMatchers.Intersection(_methodMatcher, other.MethodMatcher);
return this;
}
private List<Type> RequiredTypesFor(ITypeFilter filter, Type type)
{
List<Type> requiredTypes = new List<Type> ();
requiredTypes.AddRange (filter.AllOfTypes);
requiredTypes.AddRange (filter.AnyOfTypes);
if (requiredTypes.IndexOf(type) == -1)
requiredTypes.Add(type);
return requiredTypes;
}
/*============================================================================*/
/* Constructor */
/*============================================================================*/
public ViewProcessorMapping(ITypeFilter matcher, object processor)
{
_matcher = matcher;
SetProcessor(processor);
}
public void Setup()
{
EMPTY_CLASS_LIST = new List<Type> ();
MATCHER = new TypeFilter(EMPTY_CLASS_LIST, EMPTY_CLASS_LIST, EMPTY_CLASS_LIST);
}
private void UnmapTypeForFilterBinding(ITypeFilter filter, Type type, object view)
{
List<Type> requiredTypes = RequiredTypesFor(filter, type);
foreach (Type requiredType in requiredTypes)
{
if (_injector.HasDirectMapping(requiredType))
_injector.Unmap(requiredType);
}
}
private void MapTypeForFilterBinding(ITypeFilter filter, Type type, object view)
{
List<Type> requiredTypes = RequiredTypesFor(filter, type);
foreach (Type requiredType in requiredTypes)
{
_injector.Map(requiredType).ToValue(view);
}
}
/// <summary>
/// Changes the current type filter to be the intersection of the existing filter
/// and the supplied <paramref name="filter"/>.
/// </summary>
/// <param name="filter">The filter to diff against.</param>
/// <returns>
/// The intersection of the existing filter and the supplied <paramref name="filter"/>.
/// </returns>
public virtual ComposablePointcut Intersection(ITypeFilter filter)
{
_typeFilter = TypeFilters.Intersection(_typeFilter, filter);
return this;
}
/// <summary>
/// Initializes a new instance of the <see cref="AttributeMatchingPointcut"/> class for the
/// given attribute type
/// </summary>
/// <param name="attributeType">Type of the attribute.</param>
/// <param name="checkInherited">if set to <c>true</c> [check inherited].</param>
public AttributeMatchingPointcut(Type attributeType, bool checkInherited)
{
ValidateAttributeTypeArgument(attributeType);
this.typeFilter = new AttributeTypeFilter(attributeType, checkInherited);
this.methodMatcher = TrueMethodMatcher.True;
}
/// <summary>
/// Will look for a user defined logic class in a set of types.
/// </summary>
/// <param name="domainType"></param>
/// <param name="types"></param>
/// <param name="typeFilter"></param>
/// <returns></returns>
private Type GetLogicClass(Type domainType, IEnumerable<Type> types, ITypeFilter typeFilter)
{
//we have 2 criteria to search a logic class:
//1. look for the MDataLogic attribute
//2. look for descendants of the LogicBase<> class
var defaultImplementationName = domainType.Name.Substring(1);
//filter out the list of types, and assign a score (the lowest score will win)
//this score is used if multiple logic implementation candidates exist, then logicclasses with
//the Mdatalogic attr go first, then logicclasses who have the default logic name convention, last all others
var candidates = (from candidate in types
let score = candidate.HasAttribute<MDataLogicAttribute>() ? 0 : candidate.Name == defaultImplementationName ? 1 : 2
where candidate.BaseType == typeof(LogicBase<>).MakeGenericType(domainType)
orderby score
select candidate)
.ToList();
//if multiple logic class had the MDataLogic attribute throw an exception because this is not normal
if(candidates.Count(x=> x.HasAttribute<MDataLogicAttribute>()) > 1)
throw new FoundMultipleLogicImplementationsException(domainType, candidates);
//return the best candidate
return candidates.FirstOrDefault();
}
/// <summary>
/// 构造方法。
/// </summary>
public Pointcut(ITypeFilter typeFilter)
: this(typeFilter, TrueMethodMatcher.True)
{
}
public void AddFilter(ITypeFilter filter)
{
if (null == filter) throw new ArgumentNullException("filter");
_filters.Add(filter);
}
public virtual void Visit(ITypeFilter filter)
{
Write("type");
}
public NotFilter(ITypeFilter filter)
{
_filter = filter;
}
