C# IMatcher类代码示例

		public override bool SameMatcher(IMatcher other)
		{
			DateTimeMatcher dtOther = other as DateTimeMatcher;
			if (dtOther == null)
				return false;
			return m_end == dtOther.m_end && m_start == dtOther.m_start && m_type == dtOther.m_type;
		}

		public bool SameMatcher(IMatcher other)
		{
			if (other.GetType() != this.GetType())
				return false;
			ExactLiteralMatcher other1 = other as ExactLiteralMatcher;
			return m_target == other1.m_target && m_ws == other1.m_ws;
		}

 static void setComponentNames(Matcher matcher, IMatcher[] matchers)
 {
     var componentNames = getComponentNames(matchers);
     if(componentNames != null) {
         matcher.componentNames = componentNames;
     }
 }

 public VisualFingerprintMatchingFrm(IMatcher matcher, IResourceProvider resourceProvider, string resourcePath)
 {
     InitializeComponent();
     this.matcher = matcher;
     provider = resourceProvider;
     this.resourcePath = resourcePath;
     repository = new ResourceRepository(resourcePath);
 }

		public override bool Equals(IMatcher other)
		{
			var referenceMatcher = other as ReferenceMatcher;
			if (referenceMatcher == null)
				return false;

			return CompareValueTo(other);
		}

        static int[] extractIndices(IMatcher[] matchers)
        {
            var indices = new List<int>();
            for (int i = 0, matchersLength = matchers.Length; i < matchersLength; i++) {
                indices.AddRange(matchers[i].indices);
            }

            return indices.ToArray();
        }

		public bool Matches(IMatcher other)
		{
			if (this.Equals(other))
				return true;

			if (!this.CanMatch(other))
				return false;

			return this.MatchesCore(other);
		}

		private bool CompareValueTo(IMatcher other)
		{
			var valueMatcher = other as IValueMatcher;
			if (valueMatcher == null)
				return false;

			if (this.IsValueType)
				return Equals(this.reference, valueMatcher.Value);
			return ReferenceEquals(this.reference, valueMatcher.Value);
		}

 ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, IMatcher[] triggers, GroupEventType[] eventTypes)
 {
     _subsystem = subSystem;
     var groups = new Group[triggers.Length];
     for (int i = 0, triggersLength = triggers.Length; i < triggersLength; i++) {
         groups[i] = pool.GetGroup(triggers[i]);
     }
     _observer = new GroupObserver(groups, eventTypes);
     _buffer = new List<Entity>();
 }

        static string[] getComponentNames(IMatcher[] matchers)
        {
            for (int i = 0; i < matchers.Length; i++) {
                var matcher = matchers[i] as Matcher;
                if(matcher != null && matcher.componentNames != null) {
                    return matcher.componentNames;
                }
            }

            return null;
        }

    public static Entity GetEntityWithOrder(this Pool pool, int order, IMatcher matcher)
    {
        Entity[] entities = pool.GetGroup(Matcher.AllOf(CoreGameMatcher.Order, matcher)).GetEntities();

        foreach(Entity e in entities){
            if(e.order.value == order){
                return e;
            }
        }
        return null;
    }

        public WindsorPersister(IDatabase database, IKernel kernel, IMatcher matcher)
            : base(database, matcher)
        {
            if (kernel == null)
            {
                throw new ArgumentNullException("kernel");
            }

            var converter = new WindsorConverter(kernel);
            Settings.Converters = new[] {converter};
        }

        static int[] mergeIndices(IMatcher[] matchers) {
            var indices = new int[matchers.Length];
            for (int i = 0, matchersLength = matchers.Length; i < matchersLength; i++) {
                var matcher = matchers[i];
                if (matcher.indices.Length != 1) {
                    throw new MatcherException(matcher);
                }
                indices[i] = matcher.indices[0];
            }

            return indices;
        }

 public static IMatcher<string> WithForwardSlashes(IMatcher<string> matcher)
 {            
     return Matchers.Function((string actual,IMatchDiagnostics diag) =>
     {
         if (actual != null)
         {
             actual = actual.Replace("\\", "/");
         }
         return matcher.Matches(actual, diag);
     },
     "ignoring slash type, " + matcher
   );
 }

        public TaskRouter(IMatcher matcher, IEnumerable<IExecutorImplementation> taskQueues)
        {
            if (matcher == null)
            {
                throw new ArgumentNullException("matcher");
            }

            if (taskQueues == null)
            {
                throw new ArgumentNullException("taskQueues");
            }

            _matcher = matcher;
            _executors = taskQueues.ToDictionary(x => x.Name, x => x);
        }