web-dev-qa-db-fra.com

WCF nommé pipe minimal exemple

Je recherche un exemple minimal de canaux nommés WCF (j'attends deux applications minimales, serveur et client, pouvant communiquer via un canal nommé.)

Microsoft a le brillant article didacticiel de mise en route qui décrit la WCF via HTTP et je recherche quelque chose de similaire à propos de WCF et tuyaux nommés.

J'ai trouvé plusieurs articles sur Internet, mais ils sont un peu "avancés". J'ai besoin de quelque chose de minime, seulement des fonctionnalités obligatoires, pour pouvoir ajouter mon code et faire fonctionner l'application.

Comment puis-je remplacer cela pour utiliser un tuyau nommé?

<endpoint address="http://localhost:8000/ServiceModelSamples/Service/CalculatorService"
    binding="wsHttpBinding" bindingConfiguration="WSHttpBinding_ICalculator"
    contract="ICalculator" name="WSHttpBinding_ICalculator">
    <identity>
        <userPrincipalName value="OlegPc\Oleg" />
    </identity>
</endpoint>

Comment puis-je remplacer cela pour utiliser un tuyau nommé?

// Step 1 of the address configuration procedure: Create a URI to serve as the base address.
Uri baseAddress = new Uri("http://localhost:8000/ServiceModelSamples/Service");

// Step 2 of the hosting procedure: Create ServiceHost
ServiceHost selfHost = new ServiceHost(typeof(CalculatorService), baseAddress);

try
{
    // Step 3 of the hosting procedure: Add a service endpoint.
    selfHost.AddServiceEndpoint(
        typeof(ICalculator),
        new WSHttpBinding(),
        "CalculatorService");

    // Step 4 of the hosting procedure: Enable metadata exchange.
    ServiceMetadataBehavior smb = new ServiceMetadataBehavior();
    smb.HttpGetEnabled = true;
    selfHost.Description.Behaviors.Add(smb);

    // Step 5 of the hosting procedure: Start (and then stop) the service.
    selfHost.Open();
    Console.WriteLine("The service is ready.");
    Console.WriteLine("Press <ENTER> to terminate service.");
    Console.WriteLine();
    Console.ReadLine();

    // Close the ServiceHostBase to shutdown the service.
    selfHost.Close();
}
catch (CommunicationException ce)
{
    Console.WriteLine("An exception occurred: {0}", ce.Message);
    selfHost.Abort();
}

Comment générer un client pour utiliser un canal nommé?

c#wcfnamed-pipes
89
javapowered

Je viens de trouver cet excellent petit tutoriel .  lien brisé ( Version en cache )

J'ai également suivi le tutoriel de Microsoft, Nice, mais je n'avais besoin que de pipes.

Comme vous pouvez le constater, vous n’avez pas besoin des fichiers de configuration et de tout ce fouillis.

À propos, il utilise à la fois HTTP et les tubes. Supprimez simplement toutes les lignes de code liées à HTTP et vous obtiendrez un exemple pur.

80
Juan

Essaye ça.

Voici la partie service.

[ServiceContract]
public interface IService
{
    [OperationContract]
    void  HelloWorld();
}

public class Service : IService
{
    public void HelloWorld()
    {
        //Hello World
    }
}

Voici le proxy

public class ServiceProxy : ClientBase<IService>
{
    public ServiceProxy()
        : base(new ServiceEndpoint(ContractDescription.GetContract(typeof(IService)),
            new NetNamedPipeBinding(), new EndpointAddress("net.pipe://localhost/MyAppNameThatNobodyElseWillUse/helloservice")))
    {

    }
    public void InvokeHelloWorld()
    {
        Channel.HelloWorld();
    }
}

Et voici la partie hébergement de service.

var serviceHost = new ServiceHost
        (typeof(Service), new Uri[] { new Uri("net.pipe://localhost/MyAppNameThatNobodyElseWillUse") });
    serviceHost.AddServiceEndpoint(typeof(IService), new NetNamedPipeBinding(), "helloservice");
    serviceHost.Open();

    Console.WriteLine("Service started. Available in following endpoints");
    foreach (var serviceEndpoint in serviceHost.Description.Endpoints)
    {
        Console.WriteLine(serviceEndpoint.ListenUri.AbsoluteUri);
    }
58
Anuraj

Découvrez mon exemple très simplifié avec Echo : Il est conçu pour utiliser une communication HTTP de base, mais il peut facilement être modifié pour utiliser des canaux nommés en modifiant le app.config fichiers pour le client et le serveur. Apportez les modifications suivantes:

Editez le fichier app.config du serveur, en supprimant ou en commentant l'entrée http baseAddress et en ajoutant un nouveau baseAddress entrée du canal nommé (appelé net.pipe ). De plus, si vous n’avez pas l’intention d’utiliser HTTP pour un protocole de communication, assurez-vous que serviceMetadata et serviceDebug est commenté ou supprimé:

<configuration>
    <system.serviceModel>
        <services>
            <service name="com.aschneider.examples.wcf.services.EchoService">
                <Host>
                    <baseAddresses>
                        <add baseAddress="net.pipe://localhost/EchoService"/>
                    </baseAddresses>
                </Host>
            </service>
        </services>
        <behaviors>
            <serviceBehaviors></serviceBehaviors>
        </behaviors>
    </system.serviceModel>
</configuration>

Editez le fichier app.config du client afin que le basicHttpBinding soit soit commenté, soit supprimé, et un netNamedPipeBinding l'entrée est ajoutée. Vous devrez également modifier l’entrée endpoint == pour utiliser le canal:

<configuration>
    <system.serviceModel>
        <bindings>
            <netNamedPipeBinding>
                <binding name="NetNamedPipeBinding_IEchoService"/>
            </netNamedPipeBinding>
        </bindings>
        <client>
            <endpoint address              = "net.pipe://localhost/EchoService"
                      binding              = "netNamedPipeBinding"
                      bindingConfiguration = "NetNamedPipeBinding_IEchoService"
                      contract             = "EchoServiceReference.IEchoService"
                      name                 = "NetNamedPipeBinding_IEchoService"/>
        </client>
    </system.serviceModel>
</configuration>

L'exemple ci-dessus ne fonctionnera qu'avec des canaux nommés, mais rien ne vous empêche d'utiliser plusieurs protocoles pour exécuter votre service. Autant que je sache, un serveur devrait pouvoir exécuter un service utilisant à la fois des canaux nommés et HTTP (ainsi que d'autres protocoles).

En outre, la liaison dans le fichier app.config ] == du client est extrêmement simplifiée. Il y a beaucoup de paramètres différents que vous pouvez ajuster, en plus de spécifier juste le baseAddress ... == ...

14
Alan S

J'ai créé cet exemple simple à partir de différents résultats de recherche sur Internet.

public static ServiceHost CreateServiceHost(Type serviceInterface, Type implementation)
{
  //Create base address
  string baseAddress = "net.pipe://localhost/MyService";

  ServiceHost serviceHost = new ServiceHost(implementation, new Uri(baseAddress));

  //Net named pipe
  NetNamedPipeBinding binding = new NetNamedPipeBinding { MaxReceivedMessageSize = 2147483647 };
  serviceHost.AddServiceEndpoint(serviceInterface, binding, baseAddress);

  //MEX - Meta data exchange
  ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();
  serviceHost.Description.Behaviors.Add(behavior);
  serviceHost.AddServiceEndpoint(typeof(IMetadataExchange), MetadataExchangeBindings.CreateMexNamedPipeBinding(), baseAddress + "/mex/");

  return serviceHost;
}

En utilisant l'URI ci-dessus, je peux ajouter une référence dans mon client au service Web.

1
Rahbek