WCF Client - Meilleure pratique

Question

Je voulais juste entendre votre opinion sur la mise en œuvre d'un client WCF.

J'ai un serveur qui fournit plusieurs services comme SecurityManager. Ce service est défini dans l'interface ISecurityManager et implémenté dans la classe SecurityManager.

Jusqu'à présent, tout va bien. Du côté du client, je veux mettre en œuvre les appels de services via une classe distincte. Ma question est de savoir si je dois le faire également dans une classe SecurityManager qui implémente la même interface ISecurityManager ?

Quelle est ici la meilleure pratique ?

Answer 1

Je suggère d'utiliser un Wrapper générique pour faire des appels WCF. Ainsi chaque fois que vous devez faire un appel WCF vous pouvez le faire comme ceci :

var invoker = new ServiceInvoker();
        var result = invoker.InvokeService<ISecurityManager, MyObjectReturnType>(
            proxy => proxy.DoSomething(myParameters));
        return result;

J'utilise ServiceInvoker pour créer le canal et gérer toutes les exceptions qui se produiraient à l'intérieur. Il crée un canal avec le contrat ISecurityManager, avec le type de retour MyObjectReturnType et avec l'action DoSomething (méthode du contrat ISecurityManager). Vous pouvez utiliser cette solution avec toutes vos interfaces, sans aucune implémentation de classe supplémentaire !

InvokeService serait quelque chose comme ceci :

public TResult InvokeService<TServiceContract, TResult>(Func<TServiceContract, TResult> invokeHandler) where TServiceContract : class
    {
        ICommunicationObject communicationObject;
        var arg = CreateCommunicationObject<TServiceContract>(out communicationObject);
        var result = default(TResult);
        try
        {
            result = invokeHandler(arg);
        }
        catch (Exception ex)
        {
            Logger.Log(ex);
            throw;
        }

        finally
        {
            try
            {
                if (communicationObject.State != CommunicationState.Faulted)
                    communicationObject.Close();
            }
            catch
            {
                communicationObject.Abort();
            }
        }
        return result;
    }

private TServiceContract CreateCommunicationObject<TServiceContract>(out ICommunicationObject communicationObject)
        where TServiceContract : class
    {
        //Create the Channel
        // ICommunicationObject is an out parameter for disposing purposes 
        return channel;
    }

Answer 2

Générateur Visual Studio

Vous pouvez demander à Visual Studio de construire un client pour vous, en faisant un clic droit sur votre projet client et en ajoutant un fichier Service Reference . Il y a une boîte de dialogue où vous pouvez soit taper l'url de votre service, soit le découvrir à partir de la solution.

Créer un client

Vous pouvez construire la classe client en héritant de ClientBase<ISecurityManager>, ISecurityManager . Étant un exemple d'opération sur cette classe de client :

public void ExampleMethod(int id)
{
   Channel.ExampleMethod(id);
}

Comme un vrai homme le fait

Ou sans classe client, en l'appelant simplement :

ServiceInvokerinvoker invoker = new ServiceInvoker(); 
var result = invoker.InvokeService<ISecurityManager, ReturnType>(     proxy => proxy.ExampleMethod(1) ); 

Les deux dernières options supposent que vous avez déjà configuré l'option ISecurityManager client :

<client>     
<endpoint name="ServiceName" 
address="http://ServiceName.test/Service" 
binding="basicHttpBinding"   
contract="ISecurityManager" /> 
</client>

Answer 3

Pour implémenter les appels de service "via une classe séparée", vous pouvez simplement générer une référence de service en utilisant svcutil.exe ou visual studio à partir d'une instance de votre service en cours d'exécution.

Cela générera un ensemble de types pour votre contrat de service qui sera complètement "séparé" des assemblages contenant votre contrat de service et son implémentation.