Compréhension de WCF - implémentation de la fonction de calculatrice-Tutoriel C#.Net-php.cn

WCF fournit essentiellement un appel de service inter-processus, inter-machines et même inter-réseaux. Dans cet exemple, il implémente principalement la fonction d'une calculatrice. La plupart des fonctions proviennent de publications d'autres personnes sur Internet. appelé debout sur les épaules de géants. , O(∩_∩)O haha~, mais afin d'approfondir ma compréhension de wcf, j'ai décidé d'écrire moi-même une démo similaire pour montrer les problèmes rencontrés lors de l'écriture de la démo. pour ceux qui sont nouveaux dans le programme wcf En tant qu'employé, vous rencontrerez également divers problèmes. Bon, venons-en au fait.

WCF est divisé en quatre parties 1. Contrat (Interface) 2. Contrat de service (Service) 3. Programme hôte WCF (console ou IIS) 4. Client (Client)

Moi lors de l'écriture wcf, j'aime diviser les quatre parties en différentes bibliothèques de classes pour la gestion.

1. Contrat

Le contrat est une interface ouverte sur le monde extérieur. Le nom de la fonction exposé au client. Tout d'abord, créez une nouvelle bibliothèque de services wcf nommée Interface, comme indiqué dans la figure. :

Supprimez les fichiers par défaut dans le programme (App.config, IService1.cs, Service1.cs), et créez un nouveau ICalculator

namespace Interface
{
    [ServiceContract(Name = "CalculatorService", Namespace = "")]public interface ICalculator
    {
        [OperationContract]double Add(double x, double y);

        [OperationContract]double Subtract(double x, double y);

        [OperationContract]double Multiply(double x, double y);

        [OperationContract]double Divide(double x, double y);

    }
}

Copier après la connexion

2. La création d'un nouveau contrat de service est en fait la classe qui implémente le contrat. Ajouter "Nouveau projet"->WCF->"Bibliothèque de services WCF" (la première étape est la même que la création d'un nouveau contrat. nouveau contrat). Le nom de la bibliothèque de classes est Service,

Une fois la création réussie, supprimez les fichiers par défaut (App.config, IService1.cs, Service1.cs ), ajoutez une référence à la bibliothèque de classes "Interface", créez un nouveau CalculatorService et implémentez ICalculator

namespace Service
{
    [ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall, ConcurrencyMode = ConcurrencyMode.Multiple)]public class CalculatorService : ICalculator
    {public double Add(double x, double y)
        {return x + y;
        }public double Subtract(double x, double y)
        {return x - y;
        }public double Multiply(double x, double y)
        {return x * y;
        }public double Divide(double x, double y)
        {return x / y;
        }
    }

Copier après la connexion

3 Créez un nouveau programme hôte WCF et un contrat de service. ont été terminés, mais un programme est encore nécessaire pour héberger ces interfaces pour que les programmes externes puissent les appeler, c'est pourquoi on l'appelle programme hôte, le programme hôte peut être déployé sur IIS ou il peut être exécuté en tant que programme console pour un débogage facile. . Ci-dessous, je présenterai l'utilisation du programme console comme programme hôte. Faites un clic droit sur le nom de la solution et ajoutez « Programme de console » avec le nom Hébergement, et ajoutez des références à l'interface et au service

Il existe deux façons d'ouvrir WCF au monde extérieur. L'une consiste à configurer. le fichier pour combiner toutes les informations WCF. Toutes sont écrites dans le fichier de configuration

Le premier type : les informations liées à WCF sont écrites dans le fichier de configuration (App.config)

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <startup>
    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1"/>
  </startup>
  <system.serviceModel>
    <services>
      <service name="Service.CalculatorService" behaviorConfiguration="WCFService.WCFServiceBehavior">
        <endpoint address="http://127.0.0.1:8888/CalculatorService" binding="wsHttpBinding" contract="Service.Interface.ICalculator">          
        </endpoint>
        <endpoint address="net.tcp://127.0.0.1:9999/CalculatorService"  binding="netTcpBinding"  contract="Service.Interface.ICalculator">
        </endpoint>
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
        <endpoint address="mex" binding="mexTcpBinding" contract="IMetadataExchange" />
        <host>
          <baseAddresses>
            <add baseAddress="http://127.0.0.1:8888/"/>
            <add baseAddress="net.tcp://127.0.0.1:9999/"/>
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="WCFService.WCFServiceBehavior">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="false" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
  </system.serviceModel>
</configuration>

Copier après la connexion

Le code principal de la méthode Main est le suivant,

    public class Program
    {internal static ServiceHost host = null;static void Main(string[] args)
        {using (ServiceHost host = new ServiceHost(typeof(CalculatorService)))
            {

                host.Opened += delegate{
                    Console.WriteLine("CalculaorService已经启动，按任意键终止服务！");
                };
                host.Open();
                Console.ReadLine();
            }
        }
    }

Copier après la connexion

Exécutez le programme console, comme indiqué dans la figure ci-dessous :

Deuxième type : écrivez une classe WCFHelper Lors de l'ajout de la classe d'assistance, assurez-vous de référencer System.Runtime.Serialization et supprimez la configuration wcf dans App. config. Sinon, le code d'erreur sera signalé comme suit :

 public static class WCFHelper
    {public static string IP { get; set; }public static int Port { get; set; }static WCFHelper()
        {try{
                IP = System.Environment.MachineName;// ConfigurationManager.AppSettings["ServiceIP"];//                Port = int.Parse(ConfigurationManager.AppSettings["ServicePort"]);
            }catch{

            }

            EndpointAddress.Add(BindingProtocol.Http, "http://{0}:{1}/{2}/{3}");
            EndpointAddress.Add(BindingProtocol.NetTcp, "net.tcp://{0}:{1}/{2}/{3}");//EndpointAddress.Add(BindingProtocol.NetMsmq, "net.msmq://{0}:{1}/" + schema + "/{2}");//EndpointAddress.Add(BindingProtocol.NetPipe, "net.pipe://{0}:{1}/" + schema + "/{2}");try{
                httpBinding = new BasicHttpBinding();
                httpBinding.MaxBufferSize = 200065536;
                httpBinding.MaxReceivedMessageSize = 200065536;
                httpBinding.CloseTimeout = new TimeSpan(0, 10, 0);
                httpBinding.OpenTimeout = new TimeSpan(0, 10, 0);
                httpBinding.ReceiveTimeout = new TimeSpan(0, 10, 0);
                httpBinding.SendTimeout = new TimeSpan(0, 1, 0);

                httpBinding.Security.Mode = BasicHttpSecurityMode.None;

                httpBinding.ReaderQuotas.MaxDepth = 64;
                httpBinding.ReaderQuotas.MaxStringContentLength = 2147483647;
                httpBinding.ReaderQuotas.MaxArrayLength = 16384;
                httpBinding.ReaderQuotas.MaxBytesPerRead = 4096;
                httpBinding.ReaderQuotas.MaxNameTableCharCount = 16384;
            }catch{
                httpBinding = new BasicHttpBinding();
            }try{
                tcpBinding = new NetTcpBinding();
                tcpBinding.CloseTimeout = new TimeSpan(0, 1, 0);
                tcpBinding.OpenTimeout = new TimeSpan(0, 1, 0);
                tcpBinding.ReceiveTimeout = new TimeSpan(0, 10, 0);
                tcpBinding.SendTimeout = new TimeSpan(0, 1, 0);
                tcpBinding.TransactionFlow = false;
                tcpBinding.TransferMode = TransferMode.Buffered;
                tcpBinding.TransactionProtocol = TransactionProtocol.OleTransactions;
                tcpBinding.HostNameComparisonMode = HostNameComparisonMode.StrongWildcard;
                tcpBinding.ListenBacklog = 100000;
                tcpBinding.MaxBufferPoolSize = 524288;
                tcpBinding.MaxBufferSize = 200065536;
                tcpBinding.MaxConnections = 2000;
                tcpBinding.MaxReceivedMessageSize = 200065536;
                tcpBinding.PortSharingEnabled = true;

                tcpBinding.Security.Mode = SecurityMode.None;

                tcpBinding.ReaderQuotas.MaxDepth = 64;
                tcpBinding.ReaderQuotas.MaxStringContentLength = 2147483647;
                tcpBinding.ReaderQuotas.MaxArrayLength = 163840000;
                tcpBinding.ReaderQuotas.MaxBytesPerRead = 4096;
                tcpBinding.ReaderQuotas.MaxNameTableCharCount = 16384;

                tcpBinding.ReliableSession.Ordered = true;
                tcpBinding.ReliableSession.InactivityTimeout = new TimeSpan(0, 10, 0);
                tcpBinding.ReliableSession.Enabled = false;
            }catch{
                tcpBinding = new NetTcpBinding();
            }
        }private static BasicHttpBinding httpBinding;public static BasicHttpBinding HttpBinding
        {get{return httpBinding;
            }
        }private static NetTcpBinding tcpBinding;public static NetTcpBinding TcpBinding
        {get{return tcpBinding;
            }
        }public static EndpointAddress GetEndpointAddress(string ip, int port, string serviceSchema, string serviceName, BindingProtocol protocol)
        {string address = EndpointAddress[protocol];
            address = string.Format(address, ip, port, serviceSchema, serviceName);return new EndpointAddress(address);
        }public static EndpointAddress GetEndpointAddress(string serviceSchema, string serviceName, BindingProtocol protocol)
        {string address = EndpointAddress[protocol];
            address = string.Format(address, IP, Port, serviceSchema, serviceName);return new EndpointAddress(address);
        }public static Uri GetBaseAddress(string ip, int port, string serviceSchema, string serviceName, BindingProtocol protocol)
        {string address = EndpointAddress[protocol];

            address = string.Format(address, ip, port + 1, serviceSchema, serviceName);return new Uri(address);
        }public static Uri GetBaseAddress(string serviceSchema, string serviceName, BindingProtocol protocol)
        {string address = EndpointAddress[protocol];

            address = string.Format(address, IP, Port + 1, serviceSchema, serviceName);return new Uri(address);
        }private readonly static Dictionary<BindingProtocol, string> EndpointAddress = new Dictionary<BindingProtocol, string>();public enum BindingProtocol
        {
            Http = 1,
            NetTcp = 2,//NetPipe = 3,//NetMsmq = 4        }
    }

Copier après la connexion

Modifiez la méthode principale dans le programme hôte comme suit :

    static void Main(string[] args)
        {
            WCFHelper.IP = "127.0.0.10";
            WCFHelper.Port = 9999;

            Uri httpUri = WCFHelper.GetBaseAddress(WCFHelper.IP, WCFHelper.Port, "Calculator", "Inspect", WCFHelper.BindingProtocol.Http);using (ServiceHost host = new ServiceHost(typeof(CalculatorService), httpUri))
            {
                host.AddServiceEndpoint(typeof(ICalculator), WCFHelper.TcpBinding, WCFHelper.GetEndpointAddress(WCFHelper.IP, WCFHelper.Port, "Calculator", "InspectService", WCFHelper.BindingProtocol.NetTcp).Uri.AbsoluteUri);
                ServiceMetadataBehavior behavior = new ServiceMetadataBehavior();#if DEBUGbehavior.HttpGetEnabled = true;#elsebehavior.HttpGetEnabled = false;#endifhost.Description.Behaviors.Add(behavior);
                host.Opened += delegate{
                    Console.WriteLine("CalculaorService已经启动，按任意键终止服务！");
                };
                host.Open();

                Console.ReadLine();
            }
}

Copier après la connexion

4. Hôte Le programme est construit et tous les protocoles WCF sont accessibles au monde extérieur. Vous devez maintenant créer un client pour appeler le programme wcf. 🎜>

Tout d'abord, compilez le programme hôte Host, recherchez bin/debug/Host.exe et cliquez avec le bouton droit sur l'administrateur Ouvrir, si l'image suivante prouve que le service a été installé dans Ning

Deuxièmement, ajoutez le programme Winform dans le nom de la solution -> cliquez avec le bouton droit pour créer un nouveau programme WinForm et ajoutez "Référence de service"

Ajouter une référence de service (cette méthode de référence est basée sur "3. Ajouter un programme hôte" ->"La deuxième méthode de classe d'assistance WCF")

Cliquez sur "Go" et sur le système trouvera le service WCF, comme le montre la figure ci-dessous :

Cliquez sur OK et cela réussira. Après avoir cité wcf, commençons à appeler le service WCF. Programme WCF. Par exemple, en appelant la méthode Add, le code est le suivant :

 ServiceReference1.CalculatorServiceClient client = new ServiceReference1.CalculatorServiceClient();
            textBox3.Text = client.Add(double.Parse(textBox1.Text), double.Parse(textBox2.Text)).ToString();

Copier après la connexion

Jusqu'à présent, le programme wcf est terminé. et le programme client en même temps lors du débogage.

Si vous rencontrez des problèmes, VS prend en charge le démarrage de plusieurs projets en même temps. Vous pouvez démarrer le client et l'hébergeur en même temps

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!