C# IPipeline类代码示例

 /// <summary>
 /// Creates the profiler
 /// </summary>
 public PipelineStepProfiler(IPipeline pipeline, PipelineStepProfilerStats profilerStats)
 {
     if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
     if (profilerStats == null) throw new ArgumentNullException(nameof(profilerStats));
     _pipeline = pipeline;
     _profilerStats = profilerStats;
 }

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

 public TcpChannel(IPipeline pipeline, BufferPool pool)
 {
     _pipeline = pipeline;
     Pipeline.SetChannel(this);
     _readBuffer = pool.PopSlice();
     _stream = new PeekableMemoryStream(_readBuffer.Buffer, _readBuffer.StartOffset, _readBuffer.Capacity);
 }

 public void Initialize(IPipeline pipelineRunner)
 {
     pipelineRunner.Notify(WrapOperations)
         .After<KnownStages.IRequestDecoding>()
         .And
         .Before<KnownStages.IOperationExecution>();
 }

 public void Initialize(IPipeline pipelineRunner)
 {
     pipelineRunner.Notify(ChallengeIfUnauthorized)
         .After<KnownStages.IOperationExecution>()
         .And
         .Before<KnownStages.IResponseCoding>();
 }

        /// <summary>
        /// Creates the worker factory
        /// </summary>
        public ThreadPoolWorkerFactory(ITransport transport, IRebusLoggerFactory rebusLoggerFactory, IPipeline pipeline, IPipelineInvoker pipelineInvoker, Options options, Func<RebusBus> busGetter, BusLifetimeEvents busLifetimeEvents, ISyncBackoffStrategy backoffStrategy)
        {
            if (transport == null) throw new ArgumentNullException(nameof(transport));
            if (rebusLoggerFactory == null) throw new ArgumentNullException(nameof(rebusLoggerFactory));
            if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
            if (pipelineInvoker == null) throw new ArgumentNullException(nameof(pipelineInvoker));
            if (options == null) throw new ArgumentNullException(nameof(options));
            if (busGetter == null) throw new ArgumentNullException(nameof(busGetter));
            if (busLifetimeEvents == null) throw new ArgumentNullException(nameof(busLifetimeEvents));
            if (backoffStrategy == null) throw new ArgumentNullException(nameof(backoffStrategy));
            _transport = transport;
            _rebusLoggerFactory = rebusLoggerFactory;
            _pipeline = pipeline;
            _pipelineInvoker = pipelineInvoker;
            _options = options;
            _busGetter = busGetter;
            _backoffStrategy = backoffStrategy;
            _parallelOperationsManager = new ParallelOperationsManager(options.MaxParallelism);
            _log = _rebusLoggerFactory.GetCurrentClassLogger();

            if (_options.MaxParallelism < 1)
            {
                throw new ArgumentException($"Max parallelism is {_options.MaxParallelism} which is an invalid value");
            }

            if (options.WorkerShutdownTimeout < TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException($"Cannot use '{options.WorkerShutdownTimeout}' as worker shutdown timeout as it");
            }

            busLifetimeEvents.WorkersStopped += WaitForContinuationsToFinish;
        }

 public void Initialize(IPipeline pipeline)
 {
     pipeline.Notify(WriteResponse).After<KnownStages.ICodecResponseSelection>();
     //.And
     //.Before<KnownStages.IEnd>();
     Log = NullLogger.Instance;
 }

        public NancyPipelineRoutes(IPipeline pipeline, INotificationTarget notifier)
        {
            Post["/bitbucket"] = parameters => {
                string notificationString = Request.Form.Payload;

                var commitNotification = JsonConvert.DeserializeObject<BitbucketPostReceiveNotification>(notificationString);
                commitNotification.Commits.ForEach(c => pipeline.AddToPipeline(new Commit(c.Author, c.Message, c.Branch)));

                return "THANKS BITBUCKET";
            };

            Post["/jenkins"] = parameters => {
                var buildNotification = this.Bind<JenkinsBuildNotification>();

                var buildStep = pipeline[buildNotification.Name];

                if (buildNotification.Build.Phase == "STARTED") {
                    buildStep.Start();
                } else if (buildNotification.Build.Phase == "FINISHED") {
                    if (buildNotification.Build.Status == "SUCCESS")
                    {
                        buildStep.Pass();
                    }
                    else
                    {
                        buildStep.Fail();
                    }
                }

                return "THANKS FOR THE BUILD DEETS";
            };
        }

 public void Initialize(IPipeline pipelineRunner)
 {
     pipelineRunner.Notify(PostExecution).After<KnownStages.IOperationExecution>()
         .And.Before<KnownStages.IOperationResultInvocation>();
     pipelineRunner.Notify(RewriteResult).After<KnownStages.IOperationResultInvocation>()
         .And.Before<KnownStages.IResponseCoding>();
 }

 public void Initialize(IPipeline pipelineRunner)
 {
     pipelineRunner.Notify(AuthoriseRequest)
         .After<KnownStages.IBegin>()
         .And
         .Before<KnownStages.IHandlerSelection>();
 }

 public void Initialize(IPipeline pipelineRunner)
 {
     pipelineRunner.Notify(ProcessPostConditional)
         .Before<ConditionalLastModifiedContributor>()
         .And
         .Before<KnownStages.IResponseCoding>();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Cache"/> class.
        /// </summary>
        /// <param name="pipeline">The pipeline component.</param>
        /// <param name="cachePruner">The cache pruner component.</param>
        public Cache(IPipeline pipeline, ICachePruner cachePruner)
        {
            Ensure.ArgumentNotNull(pipeline, "pipeline");
            Ensure.ArgumentNotNull(cachePruner, "cachePruner");

            this.Pipeline = pipeline;
            cachePruner.Start(this);
        }

        protected ProxyBase(Type contract, IPipeline<ClientActionContext> pipeline)
        {
            if (contract == null) throw new ArgumentNullException(nameof(contract));
            if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));

            Contract = contract;
            _pipeline = pipeline;
        }

 public void Initialize(IPipeline pipelineRunner)
 {
     _authentication = _resolver.Resolve<IAuthenticationProvider>();
     pipelineRunner.Notify(ReadCredentials)
         .After<KnownStages.IBegin>()
         .And
         .Before<KnownStages.IHandlerSelection>();
 }

 public TcpServerChannel(IPipeline serverPipeline, IPipeline childPipeline, int maxNumberOfClients)
 {
     _bufferManager = new BufferManager(maxNumberOfClients, 65535);
     _argsPool = new ObjectPool<SocketAsyncEventArgs>(AllocateArgs);
     Pipeline = serverPipeline;
     _contexts = new ContextCollection(this);
     ChildPipeline = childPipeline;
 }