Konfigurowanie MaxItemsInObjectGraph klienta WCF podczas korzystania z Unity

Question

Dla zestawu narzędzi, który korzysta z usługi zdalnego WCF, skonfigurowałem ChannelFactory<IMyService> w UnityContainer.

Teraz chcę skonfigurować zachowanie końcowego tego kanału za pomocą kodu (przy użyciu Jedności), aby zastosować to zachowanie:

<behaviors> 
    <endpointBehaviors> 
     <behavior name="BigGraph"> 
      <dataContractSerializer maxItemsInObjectGraph="1000000" /> 
     </behavior> 
     </endpointBehaviors> 
</behaviors> 

Znalazłem ten przykład na MSDN (http://msdn.microsoft.com/en-us/library/ms732038.aspx)

ChannelFactory<IDataService> factory = new ChannelFactory<IDataService>(binding, address); 
foreach (OperationDescription op in factory.Endpoint.Contract.Operations) 
{ 
    vardataContractBehavior = op.Behaviors.Find<DataContractSerializerOperationBehavior>() as DataContractSerializerOperationBehavior; 
    if (dataContractBehavior != null) 
    { 
     dataContractBehavior.MaxItemsInObjectGraph = 100000; 
    } 
} 
IDataService client = factory.CreateChannel(); 

ale teraz utknąłem próbując to zrobić w konfiguracji Unity. Czy powinienem przejrzeć przechwycenie?

Answer 1

Używamy rozszerzenia zasad kompilacji w jedności, aby dodać zachowania na hoście usługi. Na kliencie mamy ServiceFactory.

/// <summary> 
/// Factory for creating application service proxies used on the workstation 
/// </summary> 
/// <typeparam name="TInterface">Interface for the service contract</typeparam> 
public class ServiceFactory<TInterface> where TInterface : class 
{ 
    private readonly List<IEndpointBehavior> m_Behaviors = new List<IEndpointBehavior>(); 

    /// <summary> 
    /// Add a behavior that is added to the proxy endpoint when the channel is created. 
    /// </summary> 
    /// <param name="behavior">An <see cref="IEndpointBehavior"/> that should be added</param>. 
    public void AddBehavior(IEndpointBehavior behavior) 
    { 
     m_Behaviors.Add(behavior); 
    } 

    /// <summary> 
    /// Creates a channel of type <see cref="CommunicationObjectInterceptor{TInterface}"/> given the endpoint address which 
    /// will recreate its "inner channel" if it becomes in a faulted state. 
    /// </summary> 
    /// <param name="url">The endpoint address for the given channel to connect to</param>. 
    public TInterface CreateChannel(string url) 
    { 
     // create the channel using channelfactory adding the behaviors in m_Behaviors 
    } 
} 

Następnie konfigurujemy jedności z InjectionFactory

new InjectionFactory(c => 
      { 
       var factory = new ServiceFactory<TInterface>(); 
       factory.AddBehavior(c.Resolve<IClientTokenBehavior>()); 
       return factory.CreateChannel(url); 
      }); 

Robiąc to w ten sposób można również rozwiązać poprzez swoje zachowanie jedności, jeśli masz jakieś zależności.

Answer 2

Myślę, że powinieneś dodać jeszcze jeden poziom niezależności, więc nie musisz zadzierać z przechwytywaniem lub czymś podobnym. Ten problem można łatwo rozwiązać, tworząc nową klasę dla zawinięcia kanału WCF. Na przykład:

public class MyServiceClient : IMyService 
{ 
    public MyServiceClient(IChannelFactory<IMyService> channel) 
    { 
    } 

    public void DoSomething() //DoSomething is the implementation of IMyService 
    { 
    //Initialize the behavior in the channel 
    //Calls channel.DoSomething 
    } 
}