Hosten mehrerer Dienste innerhalb eines Diensthosts?

Question

Ich habe zwei völlig separate Dienste (zusammen mit ihren Verträgen), die völlig unterschiedliche Abhängigkeiten sowie völlig unterschiedliche Verantwortlichkeiten haben. Aber Dinge, die sie gemeinsam bekam sind:

• Sie müssen geöffnet/geschlossen werden zusammen
• Sie teilen die gleiche Basisadresse
• Sie haben die gleiche Bindung/Transport

Dummy Verträge :

public class IFoo { 
    void Foo(); 
} 

public class IBar { 
    void Bar(); 
} 

Nun, was ich tun möchte, ist, sie beide in demselben Service-Host zu hosten. Ich bin mir bewusst, dass es möglich ist, beide Dienste als Endpunkte zu entlarven und sie in der gleichen Diensttyp wie folgt implementieren:

public class FooBar : IFoo, IBar { } 

var host = new ServiceHost(typeof(FooBar)); 

Jedoch habe ich nach einem Weg, bin auf der Suche, so etwas zu tun:

public class FooImpl : IFoo { } 

public class BarImpl : IBar { } 

var host = new ServiceHost(); 
host.AddEndpoint(typeof(FooImpl); 
host.AddEndpoint(typeof(BarImpl); 
host.Open(); 

So kann ich meine Service-Implementierungen nett und ordentlich halten, jeder mit seinen eigenen Abhängigkeiten anstelle eines god-Objekts für alles.

Jeder hat eine Idee, wie dies zu erreichen ist?

Answer 1

Sie können mehrere ServiceHosts mit jeweils eigenem Service und Endpunkt hosten, die alle die gleiche Basisadresse und denselben Anschluss haben. Hier ist meine Implementierung ist, in eine ServiceHosting Klasse gekapselt:

public class ServiceHosting<T1, T2> 
{ 
    //Declaration 
    protected ServiceHost SelfHost; 
    protected string BaseUrlString; 
    protected int Port; 
    protected string HostUrlString = ""; 
    protected bool ExtendedBinding; 

    //Constructor 
    public ServiceHosting(string url, int port, bool extendedBinding = false) 
    { 
     BaseUrlString = url; 
     Port = port; 
     ExtendedBinding = extendedBinding; 
    } 

    //Properties 
    protected int Max => int.MaxValue; 

    public virtual bool StartService(int port) 
    { 
     try 
     { 
      var hostName = System.Net.Dns.GetHostName(); 

      HostUrlString = $@"net.tcp://{hostName}:{port}{BaseUrlString}"; //GM 10.09.2012: 

      try 
      { 
       SelfHost = new ServiceHost(typeof(T1), new Uri(HostUrlString)); 

       var smb = SelfHost.Description.Behaviors.Find<ServiceMetadataBehavior>() ?? 
          new ServiceMetadataBehavior() { }; 
       smb.MetadataExporter.PolicyVersion = PolicyVersion.Policy15; 

       SelfHost.Description.Behaviors.Add(smb); 

       var throttleBehavior = new ServiceThrottlingBehavior(); 
       SelfHost.Description.Behaviors.Add(throttleBehavior); 

       var mexUrlString = String.Format(@"net.tcp://{0}:{1}{2}/mex", hostName, port, BaseUrlString); 

       // Add MEX endpoint 
       SelfHost.AddServiceEndpoint(ServiceMetadataBehavior.MexContractName, MetadataExchangeBindings.CreateMexTcpBinding(), new Uri(mexUrlString)); 

       // Add binding 
       var binding = ConfigureBinding(); 

       // Add application endpoint 
       SelfHost.AddServiceEndpoint(typeof(T2), binding, ""); 

       if (ExtendedBinding) 
       { 
        foreach (ServiceEndpoint ep in SelfHost.Description.Endpoints) 
        { 
         foreach (OperationDescription op in ep.Contract.Operations) 
         { 
          var dataContractBehavior = op.Behaviors[typeof(DataContractSerializerOperationBehavior)] as DataContractSerializerOperationBehavior; 

          if (dataContractBehavior != null) 
          { 
           dataContractBehavior.MaxItemsInObjectGraph = Max; 
          } 
         } 
        } 
       } 

       // Open the service host to accept incoming calls 
       SelfHost.Open(); 
      } 
      catch (CommunicationException) 
      { 
       // log 
       SelfHost.Abort(); 
       return false; 
      } 
      catch (Exception) 
      { 
       // log 
       SelfHost.Abort(); 
       return false; 
      } 

     } 
     catch (Exception) 
     { 
      // log 
      return false; 
     } 
     return true; 
    } 

    private NetTcpBinding BaseConfigureBinding() 
    { 
     return new NetTcpBinding 
     { Security = { Mode = SecurityMode.None }, CloseTimeout = new TimeSpan(0, 0, 0, 5) }; 
    } 

    protected virtual NetTcpBinding ConfigureBinding() 
    { 
     var binding = BaseConfigureBinding(); 

     if (ExtendedBinding) 
     { 
      binding.MaxBufferPoolSize = Max; 
      binding.MaxReceivedMessageSize = Max; 
      binding.MaxBufferSize = Max; 
      binding.MaxConnections = 200; //rdoerig 12-03-2013 default value is 10: 
      binding.ListenBacklog = 200; //rdoerig 12-03-2013 default value is 10 : buffer of pending connections 

      binding.ReaderQuotas.MaxDepth = Max; 
      binding.ReaderQuotas.MaxStringContentLength = Max; 
      binding.ReaderQuotas.MaxArrayLength = Max; 
      binding.ReaderQuotas.MaxBytesPerRead = Max; 
      binding.ReaderQuotas.MaxNameTableCharCount = Max; 

      binding.CloseTimeout = new TimeSpan(0, 0, 10, 0); 
      binding.OpenTimeout = new TimeSpan(0, 0, 10, 0); 
      binding.ReceiveTimeout = new TimeSpan(0, 0, 10, 0); 
      binding.SendTimeout = new TimeSpan(0, 0, 10, 0); 

     } 

     return binding; 
    } 

    public bool StopService() 
    { 
     try 
     { 
      SelfHost?.Close(); 
     } 
     catch (Exception) 
     { 
      // log 
      return false; 
     } 
     return true; 
    } 
} 

Dies kann wie so instanziiert werden:

 private readonly ServiceHosting<LoginService, ILoginService> _serviceHostLogin = new ServiceHosting<LoginService, ILoginService>(LoginUrl, true); 

Und gestartet/gestoppt etwa so:

  _serviceHostLogin.StartService(); 
      _serviceHostLogin.StopService(); 

Um sicherzustellen, dass Sie Wird beim Hosten mehrerer Dienste kein Fehler angezeigt, sollten Sie die URIs für Dienste anders konfigurieren, z

Answer 2

Sie können beide Schnittstellen in derselben Serviceklasse implementieren und einen Endpunkt haben, aber mit getrennten Verträgen:

[ServiceBehavior] 
public partial class IntegratedService 
{ 
    // You can implement "base" methods here 
} 

Dann wird jede Schnittstelle implementieren:

public partial class IntegratedService : IFoo 
{ 
    // Implement IFoo interface 
} 

public partial class IntegratedService : IBar 
{ 
    // Implement IBar interface 
} 

Hoffe, es hilft.