Exécuter un ServiceHost WCF avec plusieurs contrats

Question

L'exécution d'un ServiceHost avec un seul contrat fonctionne bien comme ça :

servicehost = new ServiceHost(typeof(MyService1));
servicehost.AddServiceEndpoint(typeof(IMyService1), new NetTcpBinding(), "net.tcp://127.0.0.1:800/MyApp/MyService1");
servicehost.Open();

J'aimerais maintenant ajouter un deuxième (troisième, quatrième, ...) contrat. Ma première idée serait d'ajouter d'autres points d'extrémité comme ceci :

servicehost = new ServiceHost(typeof(MyService1));
servicehost.AddServiceEndpoint(typeof(IMyService1), new NetTcpBinding(), "net.tcp://127.0.0.1:800/MyApp/MyService1");
servicehost.AddServiceEndpoint(typeof(IMyService2), new NetTcpBinding(), "net.tcp://127.0.0.1:800/MyApp/MyService2");
servicehost.Open();

Mais bien sûr, cela ne fonctionne pas, puisque lors de la création du ServiceHost, je peux passer soit MyService1 comme paramètre, soit MyService2. Je peux donc ajouter beaucoup de points de terminaison à mon service, mais tous doivent utiliser le même contrat, puisque je ne peux fournir qu'une seule implémentation ?
J'ai l'impression de passer à côté de l'essentiel, ici. Il doit bien y avoir un moyen de fournir une implémentation pour chaque contrat d'extrémité que j'ajoute, ou pas ?

Answer 1

Vous devez implémenter les deux services (interfaces) dans la même classe.

servicehost = new ServiceHost(typeof(WcfEntryPoint));
servicehost.Open(); 

public class WcfEntryPoint : IMyService1, IMyService2
{
    #region IMyService1
    #endregion

    #region IMyService2
    #endregion
}

---

Pour info : j'utilise fréquemment des classes partielles pour rendre le code de ma classe hôte plus facile à lire :

// WcfEntryPoint.IMyService1.cs
public partial class WcfEntryPoint : IMyService1
{
    // IMyService1 methods
}

// WcfEntryPoint.IMyService2.cs
public partial class WcfEntryPoint : IMyService2
{
    // IMyService2 methods
}

Answer 2

Je suis actuellement confronté au même problème, et j'ai décidé d'opter pour l'implémentation ci-dessous. Je ne sais pas si le fait d'avoir autant de contrats de service pose des problèmes de performance, mais dans mon implémentation finale, j'aurai probablement 10 à 15 contrats de service, et donc 10 à 15 ServiceHosts.

J'héberge tous mes services WCF dans un seul service Windows.

private void PublishWcfEndpoints()
{
    var mappings = new Dictionary<Type, Type>
    {
       {typeof (IAuthenticationService), typeof (AuthenticationService)},
       {typeof(IUserService), typeof(UserService)},
       {typeof(IClientService), typeof(ClientService)}
    };

    foreach (var type in mappings)
    {
        Type contractType = type.Key;
        Type implementationType = type.Value;

        ServiceHost serviceHost = new ServiceHost(implementationType);
        ServiceEndpoint endpoint = serviceHost.AddServiceEndpoint(contractType, ServiceHelper.GetDefaultBinding(),
                                                                  Properties.Settings.Default.ServiceUrl  + "/" + contractType.Name);
        endpoint.Behaviors.Add(new ServerSessionBehavior());

        ServiceDebugBehavior serviceDebugBehaviour =
            serviceHost.Description.Behaviors.Find<ServiceDebugBehavior>();
        serviceDebugBehaviour.IncludeExceptionDetailInFaults = true;

        log.DebugFormat("Published Service endpoint: {0}", Properties.Settings.Default.ServiceUrl);

        serviceHost.Open();
        serviceHosts.Add(serviceHost);
    }

}

N'hésitez pas à nous faire part de vos commentaires sur ce type d'installation, et si vous rencontrez des problèmes, notamment en matière de performances.

Answer 3

Cette réponse est une réponse supplémentaire au commentaire de la réponse acceptée de chilltemp.

Sam, vous devriez vraiment déterminer pourquoi vous avez besoin de 10-50 contrats et essayer de trouver une autre solution. J'ai regardé sur les normes de codage WCF de Juval Lowy (trouvé sur http://www.idesign.net/ ) et a trouvé les références suivantes :

3 Contrats de service ... 4. Éviter les contrats avec un seul membre. 5. S'efforcer d'avoir trois à cinq membres par contrat de service. 6. Ne pas avoir plus de vingt membres par contrat de service. Douze est probablement la limite pratique.

Il ne mentionne pas de limite sur les implémentations de contrats (que je puisse trouver) mais je ne peux pas imaginer qu'il considère 50 contrats sur un service comme quelque chose qui ressemble à une meilleure pratique. Une solution que j'ai trouvée et qui fonctionne bien est d'utiliser le partage de membres pour des fonctions similaires.

Par exemple, si vous utilisez le service WCF pour effectuer des mathématiques sur 2 valeurs, vous pouvez avoir 4 membres du côté du service : Add(x,y), Subtract(x,y), Multiply(x,y), Divide(x,y). Si vous les combinez en un membre plus générique et utilisez un objet pour transmettre les données nécessaires, vous pouvez facilement réduire le nombre de membres et augmenter l'évolutivité. Exemple : PeformCalculation(obj) où obj a les propriétés x, y et action (ajouter, soustraire, multiplier, diviser).

J'espère que cela vous aidera.

Answer 4

J'ai trouvé une autre solution pour ce problème en utilisant une méthode d'évaluation de l'impact sur l'environnement. RoutingService classe. Chaque contrat doit toujours être hébergé dans son propre fichier ServiceHost mais il peut y avoir un RoutingService qui se trouve au-dessus de tous les autres - et les présente sur un "point final" unifié. J'ai également écrit un article de codeprojet à ce sujet. Le code d'exemple est également disponible sur Bitbucket .

Answer 5

La réponse de chili fonctionnera si vous êtes d'accord pour que les contrats soient partagés par le service. Si vous voulez qu'ils soient séparés, essayez ceci :

host1 = new ServiceHost(typeof(MyService1));
host2 = new ServiceHost(typeof(MyService2));

host1.Open();
host2.Open();

public class MyService1 : IMyService1
{
    #region IMyService1
    #endregion
}

public class MyService2 : IMyService2
{
    #region IMyService2
    #endregion
}

Edit : Comme Matt l'a indiqué, cela nécessiterait plusieurs points de terminaison pour chaque service/contrat.