C# this.Accept方法代码示例

 internal static void Accept(this ControlPropertyBag propertyBag, ControlPropertyFiller[] fillers)
 {
     foreach (var filler in fillers)
     {
         propertyBag.Accept(filler);
     }
 }

 /// <summary>
 /// Modifies the current <paramref name="target"/> to support third-party method call interception for all method calls made inside the target.
 /// </summary>
 /// <param name="target">The target object.</param>
 /// <param name="methodCallFilter">The <see cref="IMethodCallFilter"/> instance that determines the method calls that will be intercepted.</param>
 /// <param name="hostMethodFilter">The <see cref="IMethodFilter"/> instance that determines the host method calls that will be modified</param>
 public static void InterceptMethodCalls(this IReflectionVisitable target, IMethodCallFilter methodCallFilter,
     IMethodFilter hostMethodFilter)
 {
     var rewriter = new InterceptMethodCalls(methodCallFilter);
     target.Accept(new ImplementModifiableType(GetDefaultTypeFilter()));
     target.WeaveWith(rewriter, hostMethodFilter.ShouldWeave);
 }

	/// <summary>
	/// Finds all projects in the solution matching the given predicate.
	/// </summary>
	/// <param name="solution">The solution to traverse.</param>
	/// <param name="predicate">Predicate used to match projects.</param>
	/// <returns>All project nodes matching the given predicate that were found.</returns>
	public static IEnumerable<IProjectNode> FindProjects (this ISolutionNode solution, Func<IProjectNode, bool> predicate)
	{
		var visitor = new FilteringProjectsVisitor(predicate);

		solution.Accept (visitor);

		return visitor.Projects;
	}

	/// <summary>
	/// Finds the first project in the solution matching the given predicate.
	/// </summary>
	/// <param name="solution">The solution to traverse.</param>
	/// <param name="predicate">Predicate used to match projects.</param>
	/// <returns>The first project matching the given predicate, or <see langword="null"/>.</returns>
	public static IProjectNode FindProject (this ISolutionNode solution, Func<IProjectNode, bool> predicate)
	{
		var visitor = new FilteringProjectsVisitor(predicate, true);

		solution.Accept (visitor);

		return visitor.Projects.FirstOrDefault ();
	}

        public static RulesEngineGraph GetGraph(this OdoyuleRulesEngine rulesEngine)
        {
            var inspector = new GraphRulesEngineVisitor();

            rulesEngine.Accept(inspector);

            return inspector.Graph;
        }

        public static void InterceptMethodBody(this IReflectionStructureVisitable target,
                                               Func<MethodReference, bool> methodFilter, Func<TypeReference, bool> typeFilter)
        {
            target.Accept(new ImplementModifiableType(typeFilter));

            var interceptMethodBody = new InterceptMethodBody(methodFilter);
            target.WeaveWith(interceptMethodBody, methodFilter);
        }

        public static void ShowVisualizer(this RulesEngine engine)
        {
            var visitor = new GraphRulesEngineVisitor();
            engine.Accept(visitor);

            RulesEngineGraph graph = visitor.Graph;

            RulesEngineDebugVisualizer.Show(graph);
        }

        /// <summary>
        /// Return a concrete implementation of a TCP listener
        /// </summary>
        /// <param name="port"></param>
        /// <param name="protocol"></param>
        /// <returns></returns>
        public static ICommServer GetTcpListener(
            this Socket port,
            IProtocol protocol)
        {
            var client = port.Accept();
            Debug.Print("open");

            return new TcpServer(
                client,
                protocol);
        }

        public static IObservable<Socket> ToListenerObservable(this Socket socket, int backlog, Selector selector)
        {
            return Observable.Create<Socket>(observer =>
            {
                socket.Listen(backlog);

                selector.AddCallback(SelectMode.SelectRead, socket, _ =>
                {
                    var accepted = socket.Accept();
                    accepted.Blocking = false;
                    observer.OnNext(accepted);
                });

                return Disposable.Create(() => selector.RemoveCallback(SelectMode.SelectRead, socket));
            });
        }

 public static ExpressionSyntax GenerateExpressionSyntax(
     this ITypeSymbol typeSymbol)
 {
     return typeSymbol.Accept(ExpressionSyntaxGeneratorVisitor.Instance).WithAdditionalAnnotations(Simplifier.Annotation);
 }

 public static String AsiToString(this IAsi asi)
     => asi.Accept(Program.DefaultPrinter).Trim('"');

 /// <summary>
 /// Extracts the first innermost atomic statement inside a given statement.
 /// </summary>
 /// <param name="stmt"></param>
 /// <returns></returns>
 public static Statement GetInnermostAtomicStatement(this Statement stmt)
 {
     InnermostAtomicStatementExtractor ase = new InnermostAtomicStatementExtractor();
     stmt.Accept(ase);
     return ase.Result;
 }

 /// <summary>
 /// Allows a <see cref="ITypeWeaver"/> instance to traverse any <see cref="IReflectionStructureVisitable"/>
 /// instance.
 /// </summary>
 /// <param name="visitable">The visitable object.</param>
 /// <param name="typeWeaver">The type weaver.</param>
 public static void Accept(this IReflectionStructureVisitable visitable, ITypeWeaver typeWeaver)
 {
     var visitor = new TypeWeaverVisitor(typeWeaver);
     visitable.Accept(visitor);
 }

 public static string ToLogString(this QueryNode node)
 {
     return node.Accept(new QueryNodeToStringVisitor());
 }

 /// <summary>
 /// Returns <c>true</c> if the given statement modifies the given variable.
 /// </summary>
 /// <remarks>
 /// The current implementation is not capable of detecting modifications of variables which are referenced as "out" arguments of some method.
 /// </remarks>
 /// <param name="stmt">statement</param>
 /// <param name="variable">variable</param>
 public static bool Modifies(this Statement stmt, IStorable variable)
 {
     VariableModificationDetector vmd = new VariableModificationDetector(variable);
     stmt.Accept(vmd);
     return vmd.Result;
 }