public void Configure(IBuilder app)
        {
            app.UseOwin(addToPiepline =>
            {
                addToPiepline(next =>
                {
                    return async env =>
                    {
                        var accept = env["websocket.Accept"] as WebSocketAccept;
                        if (accept == null)
                        {
                            // Not a websocket request
                            await next(env);
                        }
                        else
                        {
                            accept(null, WebSocketEcho);
                        }
                    };
                });
            });

            app.Run(async context =>
            {
                context.Response.ContentType = "text/plain";
                await context.Response.WriteAsync("Not a WebSocket");
            });
        }

        private IBuilder ConvertBuilder(IBuilder builder)
        {
            var moduleReferenceBuilder = builder as ModuleReferenceBuilder;
            if (moduleReferenceBuilder != null)
            {
                if (moduleReferenceBuilder.Reference.Type == ReferenceType.Build &&
                    solutionBuilder.Projects.Contains(moduleReferenceBuilder.ReferencedProject))
                {
                    log.DebugFormat("Transforming module reference builder {0}", moduleReferenceBuilder);

                    return ConvertToInSolutionReference(moduleReferenceBuilder, moduleReferenceBuilder.ReferencedProject);
                    
                }
            }
            else
            {
                var suiteReferenceBuilder = builder as SuiteReferenceBuilder;
                if (suiteReferenceBuilder != null)
                {
                    if (suiteReferenceBuilder.Reference.Type == ReferenceType.Build &&
                        solutionBuilder.Projects.Contains(suiteReferenceBuilder.ReferencedProject))
                    {
                        log.DebugFormat("Transforming module reference builder {0}", suiteReferenceBuilder);

                        return ConvertToInSolutionReference(suiteReferenceBuilder, suiteReferenceBuilder.ReferencedProject);
                    }
                }
            }

            return null;
        }

        /// <summary>
        ///指导者构造者构造职责链
        /// </summary>
        /// <param name="builder"></param>
        public void Construction(IBuilder builder)
        {
            //构造审核通过处理链
            var approve = new ApproveHandel();
            //完善资料处理链
            var complete = new CompleteDataHandel();
            //提交保证金
            var submit = new SubmitDepositHandel();

            builder.BuilderHandel(approve);
            builder.BuilderHandel(complete);
            builder.BuilderHandel(submit);

            var listHandel = builder.Handers;
            //使用默认排序接口对责任类排序
            listHandel.Sort();

            //设置责任链的处理顺序
            for (var i = 0; i < listHandel.Count - 1; i++)
            {
                var obj = listHandel[i];
                var objNext = listHandel[i + 1];
                obj.SetHaners(objNext);
            }
        }

        public void Configure(IBuilder app)
        {
            var configuration = app.GetTestConfiguration();

            // Set up application services
            app.UseServices(services =>
            {
                // Add MVC services to the services container
                services.AddMvc(configuration);

                services.AddSingleton<INestedProvider<ActionDescriptorProviderContext>, ActionDescriptorCreationCounter>();
            });

            // Add MVC to the request pipeline
            app.UseMvc(routes =>
            {
                routes.MapRoute("areaRoute",
                                "{area:exists}/{controller}/{action}",
                                new { controller = "Home", action = "Index" });

                routes.MapRoute("ActionAsMethod", "{controller}/{action}",
                    defaults: new { controller = "Home", action = "Index" });

            });
        }

 public MainPipelineExecutor(IBuilder builder, IEventAggregator eventAggregator, IPipelineCache pipelineCache, IPipeline<ITransportReceiveContext> mainPipeline)
 {
     this.mainPipeline = mainPipeline;
     this.pipelineCache = pipelineCache;
     this.builder = builder;
     this.eventAggregator = eventAggregator;
 }

        public void Configure(IBuilder app)
        {
            // Setup configuration sources
            var configuration = new Configuration();
            configuration.AddJsonFile("config.json");
            configuration.AddEnvironmentVariables();

            // Set up application services
            app.UseServices(services =>
            {
                // Add MVC services to the services container
                services.AddMvc();
            });

            // Add static files to the request pipeline
            app.UseStaticFiles();

            // Add MVC to the request pipeline
            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default", 
                    template: "{controller}/{action}/{id?}",
                    defaults: new { controller = "Home", action = "Index" });

                routes.MapRoute(
                    name: "api",
                    template: "{controller}/{id?}");
            });
        }

 public FarmerController(IBuilder<Organization, OrganizationInput> organizationBuilder, IBuilder<LandOwner, LandOwnerInput> landOwnerBuilder, IFarmerService farmerService, IFarmerRepo farmerRepo)
 {
     this.organizationBuilder = organizationBuilder;
     this.landOwnerBuilder = landOwnerBuilder;
     this.farmerService = farmerService;
     this.farmerRepo = farmerRepo;
 }

 public override IEnumerable<StudyHandler> PlanSchedule(IBuilder builder)
 {
     //迭代器返回方式
     yield return new StudyHandler(builder.StudyA);
     yield return new StudyHandler(builder.StudyB);
     yield return new StudyHandler(builder.StudyC);
 }

        public void Configure(IBuilder app)
        {
            // Setup configuration sources
            var configuration = new Configuration();
            configuration.AddEnvironmentVariables();

            app.UseOwin();

            // Set up application services
            app.UseServices(services =>
            {                // Add MVC services to the services container
                services.AddMvc();
                services.SetupOptions<MvcOptions>(options => {
                    System.Diagnostics.Debug.WriteLine(options.OutputFormatters.Select(item => item.GetType().Name));

                    options.OutputFormatters.RemoveAt(0);
                });
            });

            // Add static files to the request pipeline
            app.UseStaticFiles();

            // Add MVC to the request pipeline
            app.UseMvc(routes =>
            {
                //routes.MapRoute(
                //    name: "default",
                //    template: "{controller}/{action}/{id?}",
                //    defaults: new { controller = "Home", action = "Index" });

                routes.MapRoute(
                    name: "api",
                    template: "{controller}/{id?}");
            });
        }

 public MidFieldDecl(
     IBuilder parent,
     Identifier name )
     : base(parent)
 {
     _name = name;
 }

        public void Configure(IBuilder app, ILibraryManager libManager, IApplicationShutdown shutdown)
        {
            var web = libManager.GetLibraryInformation("Runt.Web");

            Console.WriteLine("Path: " + web.Path);
            Console.WriteLine("Name: " + web.Name);
            var fileSystem = new PhysicalFileSystem(Path.GetDirectoryName(web.Path));

            app.UseServices(services =>
            {
                services.AddSignalR();
                services.AddSingleton<IEditor, Editor>();
            });

            app.UseSignalR("/io", typeof(RuntConnection), new ConnectionConfiguration
            {
                EnableJSONP = false
            });
            app.UseDefaultFiles(new DefaultFilesOptions
            {
                FileSystem = fileSystem
            });
            app.UseStaticFiles(new StaticFileOptions
            {
                FileSystem = fileSystem,
                ContentTypeProvider = contentTypeProvider,
                ServeUnknownFileTypes = true
            });
            app.UseDirectoryBrowser(new DirectoryBrowserOptions
            {
                FileSystem = fileSystem
            });
        }

 public ConsultaFornecedor(IFornecedores fornecedores, IBuilder<Fornecedor, FornecedorCadastroVm> builderFornecedor, IClienteVendas clienteVendas, IUsuarios usuarios)
 {
     _builderFornecedor = builderFornecedor;
     _clienteVendas = clienteVendas;
     _usuarios = usuarios;
     _fornecedores = fornecedores;
 }

 public Toolchain(string name, IGenerator generator, IBuilder builder, IExecutor executor)
 {
     Name = name;
     Generator = generator;
     Builder = builder;
     Executor = executor;
 }

 public override IMessage Receive(IBuilder builder, ExtensionRegistry extensions) {
   QualityMessage message;
   lock (input) { // only one thread can read from the stream at one time
     message = QualityMessage.ParseDelimitedFrom(input, extensions);
   }
   return message;
 }

 public ConsultaCliente(IClientes clientes, IBuilder<Cliente, ClienteCadastroVm> builder, IUsuarios usuarios, IUnitOfWorkNh unitOfWorkNh)
 {
     _clientes = clientes;
     _builderCliente = builder;
     _usuarios = usuarios;
     _unitOfWorkNh = unitOfWorkNh;
 }

        public override void Render(IBuilder builder)
        {
            using (builder.Html())
            {
                using (builder.Head())
                {
                    using (builder.Link(
                        new Uri("/Home/Style"))) ;
                }
                using (builder.Body())
                {
                    using (builder.Div())
                    {
                        using (builder.Heading("Coded Views Project", HeadingTier.H1)) ;
                        using (builder.Paragraph())
                        {
                            using (builder.Text("An alternative to resolving .cshtml files from embedded resources.")) ;
                        }
                    }
                    using (builder.Div(new HtmlAttributes { { "id", "Content" } }))
                    {
                        RenderContent();

                        using (builder.Script(
                            new Uri("/Home/Script"), ScriptSourceType.JavaScript, new HtmlAttributes
                            {
                                {"async"},
                                {"data-something", 8}
                            })) ;
                    }
                }
            }
        }

 public IMessage ReadMessage(IBuilder builder)
 {
     return builder.WeakMergeFrom(CodedInputStream.CreateInstance(this.GetPayload(Stream))).WeakBuild();
     
     // this._stream.ReadMessage(builder, ExtensionRegistry.Empty); // this method doesn't seem to work with 7728. /raist.
     // return builder.WeakBuild();
 }

 public MidModuleDecl(
     IBuilder parent,
     MidEmitContext context,
     MidEmitEnv env)
     : base(parent, context, env)
 {
 }

    public void Configure(IBuilder app)
    {
        app.UseServices(services =>
        {
            /* Adding IConfiguration as a service in the IoC to avoid instantiating Configuration again.
             * Below code demonstrates usage of multiple configuration sources. For instance a setting say 'setting1' is found in both the registered sources, 
             * then the later source will win. By this way a Local config can be overridden by a different setting while deployed remotely.
            */
            var configuration = new Configuration();
            configuration.AddJsonFile("LocalConfig.json");
            configuration.AddEnvironmentVariables(); //All environment variables in the process's context flow in as configuration values.
            services.AddInstance<IConfiguration>(configuration);

            //Add all MVC related services to IoC.
            services.AddMvc();

            /*Add all EF related services to IoC.*/
            services.AddEntityFramework().AddSqlServer();
            services.AddTransient<MusicStoreContext>();

            //Add all Identity related services to IoC. 
            services.AddTransient<DbContext, ApplicationDbContext>();
            services.AddIdentity<ApplicationUser, IdentityRole>(s =>
            {
                s.AddEntity();
            });
            services.AddTransient<SignInManager<ApplicationUser>>();
        });


        /* Error page middleware displays a nice formatted HTML page for any unhandled exceptions in the request pipeline.
         * Note: ErrorPageOptions.ShowAll to be used only at development time. Not recommended for production.
         */
        app.UseErrorPage(ErrorPageOptions.ShowAll);

        //Serves static files in the application.
        app.UseFileServer();

        app.UseCookieAuthentication(new CookieAuthenticationOptions()
        {
            AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
            LoginPath = new PathString("/Account/Login"),
        });

        app.UseMvc(routes =>
        {
            routes.MapRoute(
                null,
                "{controller}/{action}",
                new { controller = "Home", action = "Index" });
        });

        //Populates the MusicStore sample data
        SampleData.InitializeMusicStoreDatabaseAsync(app.ApplicationServices).Wait();
        SampleData.InitializeIdentityDatabaseAsync(app.ApplicationServices).Wait();

        //Creates a Store manager user who can manage the store.
        CreateAdminUser(app.ApplicationServices).Wait();
    }

        /// <summary>
        /// Starts the configuration process for the saga infrastructure.
        /// </summary>
        /// <param name="configurer"></param>
        /// <param name="builder"></param>
        /// <returns></returns>
        public static Configure With(IConfigureComponents configurer, IBuilder builder)
        {
            _builderStatic = builder;

            configurer.ConfigureComponent<ReplyingToNullOriginatorDispatcher>(ComponentCallModelEnum.Singleton);

            return new Configure { configurer = configurer };
        }