public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
 {
   if (dispatchRuntime == null)
     throw new ArgumentNullException("dispatchRuntime");
   dispatchRuntime.InstanceProvider = this.instanceProvider;
   dispatchRuntime.InstanceContextInitializers.Add((IInstanceContextInitializer) new UnityInstanceContextInitializer());
 }

 public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
 {
     foreach (DispatchOperation op in dispatchRuntime.Operations)
     {
         op.ParameterInspectors.Add(new ParameterValidatorBehavior(ThrowErrorOnFirstError, ThrowErrorAfterValidation));
     }
 }

 void IContractBehavior.ApplyDispatchBehavior(ContractDescription description, ServiceEndpoint endpoint, DispatchRuntime dispatch)
 {
     if (dispatch.ClientRuntime != null)
     {
         dispatch.ClientRuntime.OperationSelector = new MethodInfoOperationSelector(description, MessageDirection.Output);
     }
 }

 public void ApplyDispatchBehavior(
   ContractDescription contractDescription,
   ServiceEndpoint endpoint,
   DispatchRuntime dispatchRuntime)
 {
     dispatchRuntime.InstanceProvider = this;
 }

 /// <summary>
 /// 注册 服务实例创建提供者,将基于PIAB的实例生成器注入WCF扩展
 /// </summary>
 /// <param name="contractDescription"></param>
 /// <param name="endpoint"></param>
 /// <param name="dispatchRuntime"></param>
 public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
                                   DispatchRuntime dispatchRuntime)
 {
     Type serviceContractType = contractDescription.ContractType;
     dispatchRuntime.InstanceProvider = new PolicyInjectionInstanceProvider(serviceContractType,
                                                                            this.PolicyInjectorName);
 }

 public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
                                   DispatchRuntime dispatchRuntime)
 {
     if (!TypeHelper.IsTypeOf<IDispatchMessageInspector>(_inspectorType)) return;
     var inspector = TypeHelper.CreateInstance<IDispatchMessageInspector>(_inspectorType);
     dispatchRuntime.MessageInspectors.Add(inspector);
 }

        EndpointDispatcher(EndpointDispatcher baseEndpoint, IEnumerable<AddressHeader> headers)
        {
            EndpointAddressBuilder builder = new EndpointAddressBuilder(baseEndpoint.EndpointAddress);
            foreach (AddressHeader h in headers)
            {
                builder.Headers.Add(h);
            }
            EndpointAddress address = builder.ToEndpointAddress();

            this.addressFilter = new EndpointAddressMessageFilter(address);
            // channelDispatcher is Attached
            this.contractFilter = baseEndpoint.ContractFilter;
            this.contractName = baseEndpoint.ContractName;
            this.contractNamespace = baseEndpoint.ContractNamespace;
            this.dispatchRuntime = baseEndpoint.DispatchRuntime;
            // endpointFilter is lazy
            this.filterPriority = baseEndpoint.FilterPriority + 1;
            this.originalAddress = address;
            if (PerformanceCounters.PerformanceCountersEnabled)
            {
                this.perfCounterId = baseEndpoint.perfCounterId;
                this.perfCounterBaseId = baseEndpoint.perfCounterBaseId;
            }
            this.id = baseEndpoint.id;
        }

        public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, DispatchRuntime dispatchRuntime)
        {
            var behavior =
                dispatchRuntime.ChannelDispatcher.Host.Description.FindBehavior
                        <WebAuthenticationConfigurationBehavior,
                         WebAuthenticationConfigurationAttribute>(b => b.BaseBehavior);

            if (behavior == null)
                behavior = contractDescription.FindBehavior
                        <WebAuthenticationConfigurationBehavior,
                         WebAuthenticationConfigurationAttribute>(b => b.BaseBehavior);

            if (behavior == null)
                throw new ServiceAuthenticationConfigurationMissingException();

            var authorizationBehavior =
                dispatchRuntime.ChannelDispatcher.Host.Description.FindBehavior
                        <WebAuthorizationConfigurationBehavior,
                        WebAuthorizationConfigurationAttribute>(b => b.BaseBehavior);

            Type authorizationPolicy = null;
            if (authorizationBehavior != null)
                authorizationPolicy = authorizationBehavior.AuthorizationPolicyType;

            foreach (var endpointDispatcher in dispatchRuntime.ChannelDispatcher.Endpoints)
                endpointDispatcher.DispatchRuntime.MessageInspectors.Add(
                    new ServiceAuthenticationInspector(
                        behavior.ThrowIfNull().AuthenticationHandler,
                        behavior.UsernamePasswordValidatorType,
                        behavior.RequireSecureTransport,
                        behavior.Source,
                        authorizationPolicy));
        }

		void IContractBehavior.ApplyDispatchBehavior (
			ContractDescription description,
			ServiceEndpoint endpoint,
			DispatchRuntime dispatch)
		{
			throw new NotImplementedException ();
		}

 /// <summary>
 /// 
 /// </summary>
 /// <param name="contractDescription"></param>
 /// <param name="endpoint"></param>
 /// <param name="dispatchRuntime">The runtime object that can be used to modify the default service behavior.</param>
 public void ApplyDispatchBehavior(
     ContractDescription contractDescription,
     ServiceEndpoint endpoint,
     DispatchRuntime dispatchRuntime)
 {
     dispatchRuntime.InstanceProvider = this;   // set the provider to manage service objects instantiation
 }

 void IContractBehavior.ApplyDispatchBehavior(ContractDescription contract, ServiceEndpoint endpoint, DispatchRuntime runtime)
 {
     //if (s_Logger.IsDebugEnabled)
     //{
     //    s_Logger.DebugFormat("Applying dispatch ExceptionMarshallingBehavior to contract {0}", contract.ContractType.FullName);
     //}
     ApplyDispatchBehavior(runtime.ChannelDispatcher);
 }

 /// <summary>
 /// Implements a modification or extension of the client across a contract.
 /// </summary>
 public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
                                   DispatchRuntime dispatchRuntime)
 {
     foreach (OperationDescription od in contractDescription.Operations)
     {
         InjectNetDataContractSerializer(od);
     }
 }

 public static TerminatingOperationBehavior CreateIfNecessary(DispatchRuntime dispatch)
 {
     if (IsTerminatingOperationBehaviorNeeded(dispatch))
     {
         return new TerminatingOperationBehavior();
     }
     return null;
 }

        /// <summary>
        /// Implements a modification or extension of the client across a contract.
        /// </summary>
        /// <param name="contractDescription">The contract description to be modified.</param>
        /// <param name="endpoint">The endpoint that exposes the contract.</param>
        /// <param name="dispatchRuntime">The dispatch runtime that controls service execution.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="dispatchRuntime"/> is <c>null</c>.</exception>
        public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint,
            DispatchRuntime dispatchRuntime)
        {
            Argument.IsNotNull("dispatchRuntime", dispatchRuntime);

            dispatchRuntime.InstanceProvider = _instanceProvider;
            dispatchRuntime.InstanceContextInitializers.Add(new InstanceContextInitializer());
        }

 internal static TransactionBehavior CreateIfNeeded(DispatchRuntime dispatch)
 {
     if (NeedsTransactionBehavior(dispatch))
     {
         return new TransactionBehavior(dispatch);
     }
     return null;
 }

 void IContractBehavior.ApplyDispatchBehavior(ContractDescription description,ServiceEndpoint endpoint,DispatchRuntime dispatchRuntime)
 {
     PoolName = PoolName ?? "Pool executing endpoints of " + ServiceType;
      lock(typeof(ThreadPoolHelper))
      {
     ThreadPoolHelper.ApplyDispatchBehavior(ProvideSynchronizer(),PoolSize,ServiceType,PoolName,dispatchRuntime);
      }
 }

 public static SecurityImpersonationBehavior CreateIfNecessary(DispatchRuntime dispatch)
 {
     if (IsSecurityBehaviorNeeded(dispatch))
     {
         return new SecurityImpersonationBehavior(dispatch);
     }
     return null;
 }

 public void ApplyDispatchBehavior(ContractDescription description, ServiceEndpoint endpoint, DispatchRuntime dispatch)
 {
     dispatch.InstanceProvider = new ComPlusInstanceProvider(this.info);
     dispatch.InstanceContextInitializers.Add(new ComPlusInstanceContextInitializer(this.info));
     foreach (DispatchOperation operation in dispatch.Operations)
     {
         operation.CallContextInitializers.Add(new ComPlusThreadInitializer(description, operation, this.info));
     }
 }

 public void ApplyDispatchBehavior(ContractDescription description, ServiceEndpoint endpoint, DispatchRuntime dispatch)
 {
     dispatch.InstanceProvider = new MEFInstanceProvider();
     lock (lockobject)
     {
         if (IOC.Container == null)
             IOC.Container = MEFInstanceProvider._container;
     }
 }

        internal static void ApplyDispatchBehavior(Type type, string threadName, DispatchRuntime dispatch)
        {
            Debug.Assert(dispatch.SynchronizationContext == null);

            if (m_Contexts.ContainsKey(type) == false)
            {
                m_Contexts[type] = new AffinitySynchronizer(threadName);
            }
            dispatch.SynchronizationContext = m_Contexts[type];
        }