Übersicht über den WCF-ClientWCF Client Overview

In diesem Abschnitt wird beschrieben, was Clientanwendungen ausgeführten Aktionen, wie Sie konfigurieren, erstellen und Verwenden eines Windows Communication Foundation (WCF)-Clients und zum Sichern von Clientanwendungen.This section describes what client applications do, how to configure, create, and use a Windows Communication Foundation (WCF) client, and how to secure client applications.

Verwenden von WCF-ClientobjektenUsing WCF Client Objects

Eine Clientanwendung ist eine verwaltete Anwendung, die einen WCF-Client verwendet, um die Kommunikation mit einer anderen Anwendung.A client application is a managed application that uses a WCF client to communicate with another application. Zum Erstellen von eines Clients erfordert die Anwendung für einen WCF-Dienst die folgenden Schritte aus:To create a client application for a WCF service requires the following steps:

  1. Abrufen des Dienstvertrags, der Bindungen und der Adressinformationen für einen Dienstendpunkt.Obtain the service contract, bindings, and address information for a service endpoint.

  2. Erstellen Sie einen WCF-Clients, die mithilfe dieser Informationen.Create a WCF client using that information.

  3. Aufrufen von Vorgängen.Call operations.

  4. Schließen Sie den WCF-Clientobjekts.Close the WCF client object.

In den folgenden Abschnitten finden Sie eine Erläuterung dieser Schritte und kurze Einführungen in die folgenden Probleme:The following sections discuss these steps and provide brief introductions to the following issues:

  • Behandeln von Fehlern.Handling errors.

  • Konfigurieren und Sichern von Clients.Configuring and securing clients.

  • Erstellen von Rückrufobjekten für DuplexdiensteCreating callback objects for duplex services.

  • Asynchrones Aufrufen von Diensten.Calling services asynchronously.

  • Aufrufen von Diensten mithilfe von Clientkanälen.Calling services using client channels.

Abrufen von Dienstvertrag, Bindungen und AdressenObtain the Service Contract, Bindings, and Addresses

In WCF modellieren Dienste und Clients Verträge mit verwalteten Attributen, Schnittstellen und Methoden.In WCF, services and clients model contracts using managed attributes, interfaces, and methods. Soll eine Verbindung zu einem Dienst in einer Clientanwendung hergestellt werden, muss der Informationstyp für den Dienstvertrag abgerufen werden.To connect to a service in a client application, you need to obtain the type information for the service contract. In der Regel wird Sie zu diesem Zweck die ServiceModel Metadata Utility Tool (Svcutil.exe), konvertiert es in eine verwaltete Quellcodedatei in der Sprache Ihrer Wahl der Metadaten vom Dienst heruntergeladen, und erstellt einen Client Anwendungskonfigurationsdatei, die Sie zum Konfigurieren des WCF-Clientobjekts verwenden können.Typically, you do this by using the ServiceModel Metadata Utility Tool (Svcutil.exe), which downloads metadata from the service, converts it to a managed source code file in the language of your choice, and creates a client application configuration file that you can use to configure your WCF client object. Z. B., wenn Sie beabsichtigen, erstellen Sie einen WCF-Clientobjekts zum Aufrufen einer MyCalculatorService, und Sie wissen, dass die Metadaten für diesen Dienst an veröffentlicht wird http://computerName/MyCalculatorService/Service.svc?wsdl, und dann das folgende Codebeispiel zeigt, wie von Svcutil.exe zum Abrufen einer ClientCode.vb -Datei mit enthält den Dienstvertrag in verwaltetem Code.For example, if you are going to create an WCF client object to invoke a MyCalculatorService, and you know that the metadata for that service is published at http://computerName/MyCalculatorService/Service.svc?wsdl, then the following code example shows how to use Svcutil.exe to obtain a ClientCode.vb file that contains the service contract in managed code.

svcutil /language:vb /out:ClientCode.vb /config:app.config http://computerName/MyCalculatorService/Service.svc?wsdl  

Dieser Vertragscode kann entweder kompiliert werden, in der Clientanwendung oder einer anderen Assembly, die die Clientanwendung anschließend zum Erstellen eines WCF-Client-Objekts verwenden können.You can either compile this contract code into the client application or into another assembly that the client application can then use to create an WCF client object. Sie können die Konfigurationsdatei zum Konfigurieren des Clientobjekts verwenden, um eine ordnungsgemäße Verbindung zum Dienst herzustellen.You can use the configuration file to configure the client object to properly connect to the service .

Ein Beispiel dieses Prozesses finden Sie unter Vorgehensweise: Erstellen eines Clients.For an example of this process, see How to: Create a Client. Weitere Informationen zu Verträgen, finden Sie unter Verträge.For more complete information about contracts, see Contracts.

Erstellen eines WCF-ClientobjektsCreate a WCF Client Object

Ein WCF-Client ist ein lokales Objekt, das einen WCF-Dienst in einer Form darstellt, die der Client zur Kommunikation mit dem Remotedienst verwenden können.A WCF client is a local object that represents a WCF service in a form that the client can use to communicate with the remote service. WCF-Clienttypen implementieren den Vertrag, damit beim Erstellen und konfigurieren Sie dann das Clientobjekt verwenden können direkt, um Dienstvorgänge aufzurufen.WCF client types implement the target service contract, so when you create one and configure it, you can then use the client object directly to invoke service operations. Der WCF-Laufzeit konvertiert die Methodenaufrufe in Nachrichten, sendet diese an den Dienst, hört die Antwort und gibt diese Werte mit dem WCF-Client-Objekt als Rückgabewerte oder out oder ref Parameter.The WCF run time converts the method calls into messages, sends them to the service, listens for the reply, and returns those values to the WCF client object as return values or out or ref parameters.

Sie können auch WCF-clientkanalobjekten herstellen und diese Dienste verwenden.You can also use WCF client channel objects to connect with and use services. Weitere Informationen finden Sie unter WCF-Clientarchitektur.For details, see WCF Client Architecture.

Erstellen eines neuen WCF-ObjektsCreating a New WCF Object

Wenn Sie die Verwendung einer ClientBase<TChannel>-Klasse darstellen möchten, nehmen Sie an, dass der folgende einfache Dienstvertrag von einer Dienstanwendung generiert wurde.To illustrate the use of a ClientBase<TChannel> class, assume the following simple service contract has been generated from a service application.

Hinweis

Wenn Sie Visual Studio zum Erstellen von WCF-Client verwenden, werden Objekte beim Hinzufügen eines Dienstverweises zum Projekt automatisch in den Objektkatalog geladen.If you are using Visual Studio to create your WCF client, objects are loaded automatically into the object browser when you add a service reference to your project.

[System.ServiceModel.ServiceContractAttribute(
  Namespace = "http://microsoft.wcf.documentation"
)]
public interface ISampleService
{
    [System.ServiceModel.OperationContractAttribute(
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethod",
      ReplyAction = "http://microsoft.wcf.documentation/ISampleService/SampleMethodResponse"
    )]
    [System.ServiceModel.FaultContractAttribute(
      typeof(microsoft.wcf.documentation.SampleFault),
      Action = "http://microsoft.wcf.documentation/ISampleService/SampleMethodSampleFaultFault"
    )]
    string SampleMethod(string msg);
}

Wenn Sie Visual Studio nicht verwenden, überprüfen Sie den generierten Vertragscode, um den Typ zu suchen, die erweitert ClientBase<TChannel> und die dienstvertragsschnittstelle ISampleService.If you are not using Visual Studio, examine the generated contract code to find the type that extends ClientBase<TChannel> and the service contract interface ISampleService. In diesem Fall entspricht der Typ dem folgenden Code:In this case, that type looks like the following code:

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public partial class SampleServiceClient : System.ServiceModel.ClientBase<ISampleService>, ISampleService
{

    public SampleServiceClient()
    {
    }

    public SampleServiceClient(string endpointConfigurationName)
        :
            base(endpointConfigurationName)
    {
    }

    public SampleServiceClient(string endpointConfigurationName, string remoteAddress)
        :
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public SampleServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress)
        :
            base(endpointConfigurationName, remoteAddress)
    {
    }

    public SampleServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress)
        :
            base(binding, remoteAddress)
    {
    }
    public string SampleMethod(string msg)
    {
        return base.Channel.SampleMethod(msg);
    }
}

Diese Klasse kann als lokales Objekt mithilfe eines der Konstruktoren erstellt, konfiguriert und anschließend zum Herstellen einer Verbindung zu einem Dienst vom Typ ISampleService verwendet werden.This class can be created as a local object using one of the constructors, configured, and then used to connect to a service of the type ISampleService.

Es wird empfohlen, dass Sie Ihre WCF-Clientobjekts zunächst erstellen, und klicken Sie dann verwenden, und in einem einzelnen Try/Catch-Block zu schließen.It is recommended that you create your WCF client object first, and then use it and close it inside a single try/catch block. Verwenden Sie nicht die using Anweisung (Using in Visual Basic) da Ausnahmen in bestimmten Fehlermodi möglicherweise.You should not use the using statement (Using in Visual Basic) because it may mask exceptions in certain failure modes. Weitere Informationen finden Sie unter den folgenden Abschnitten sowie Vermeiden von Problemen mit der Using-Anweisung.For more information, see the following sections as well as Avoiding Problems with the Using Statement.

Verträge, Bindungen und AdressenContracts, Bindings, and Addresses

Bevor Sie einen WCF-Clientobjekts erstellen können, müssen Sie das Clientobjekt konfigurieren.Before you can create a WCF client object, you must configure the client object. Insbesondere benötigen sie einen Dienst Endpunkt verwenden.Specifically, it must have a service endpoint to use. Ein Endpunkt ist die Kombination eines Dienstvertrags, einer Bindung und einer Adresse.An endpoint is the combination of a service contract, a binding, and an address. (Weitere Informationen über Endpunkte finden Sie unter Endpunkte: Adressen, Bindungen und Verträge.) In der Regel befindet sich diese Informationen den <Endpunkt > Element in einer Konfigurationsdatei der Clientanwendung, beispielsweise das Tool "Svcutil.exe" generiert und wird automatisch geladen, wenn Sie Ihren Client erstellen -Objekt.(For more information about endpoints, see Endpoints: Addresses, Bindings, and Contracts.) Typically, this information is located in the <endpoint> element in a client application configuration file, such as the one the Svcutil.exe tool generates, and is loaded automatically when you create your client object. Beide WCF-Clienttypen verfügen auch Überladungen, die Ihnen ermöglichen, das programmgesteuerte angeben dieser Informationen.Both WCF client types also have overloads that enable you to programmatically specify this information.

Beispielsweise beinhaltet eine generierte Konfigurationsdatei für einen in den vorherigen Beispielen verwendeten ISampleService die folgenden Endpunktinformationen.For example, a generated configuration file for an ISampleService used in the preceding examples contains the following endpoint information.

<configuration>
    <system.serviceModel>
        <bindings>
            <wsHttpBinding>
                <binding name="WSHttpBinding_ISampleService" closeTimeout="00:01:00"
                    openTimeout="00:01:00" receiveTimeout="00:01:00" sendTimeout="00:01:00"
                    bypassProxyOnLocal="false" transactionFlow="false" hostNameComparisonMode="StrongWildcard"
                    maxBufferPoolSize="524288" maxReceivedMessageSize="65536"
                    messageEncoding="Text" textEncoding="utf-8" useDefaultWebProxy="true"
                    allowCookies="false">
                    <readerQuotas maxDepth="32" maxStringContentLength="8192" maxArrayLength="16384"
                        maxBytesPerRead="4096" maxNameTableCharCount="16384" />
                    <reliableSession ordered="true" inactivityTimeout="00:10:00"
                        enabled="false" />
                    <security mode="Message">
                        <transport clientCredentialType="None" proxyCredentialType="None"
                            realm="" />
                        <message clientCredentialType="Windows" negotiateServiceCredential="true"
                            algorithmSuite="Default" establishSecurityContext="true" />
                    </security>
                </binding>
            </wsHttpBinding>
        </bindings>
        <client>
            <endpoint address="http://localhost:8080/SampleService" binding="wsHttpBinding"
                bindingConfiguration="WSHttpBinding_ISampleService" contract="ISampleService"
                name="WSHttpBinding_ISampleService">
            </endpoint>
        </client>
    </system.serviceModel>
</configuration>

Mit dieser Konfigurationsdatei wird ein Zielendpunkt im <client>-Element angegeben.This configuration file specifies a target endpoint in the <client> element. Weitere Informationen zum Verwenden mehrerer Zielendpunkte finden Sie unter der ClientBase<TChannel>.ClientBase<TChannel> oder ChannelFactory<TChannel>.ChannelFactory<TChannel> Konstruktoren.For more information about using multiple target endpoints, see the ClientBase<TChannel>.ClientBase<TChannel> or the ChannelFactory<TChannel>.ChannelFactory<TChannel> constructors.

Aufrufen von VorgängenCalling Operations

Nach Sie verfügen über eine Clientobjekt erstellt und konfiguriert ist, erstellen Sie einen Try/Catch-Block, Aufrufen von Vorgängen auf die gleiche Weise, die Sie auch, wenn das Objekt lokal wären und schließen Sie die WCF-Clientobjekts.Once you have a client object created and configured, create a try/catch block, call operations in the same way that you would if the object were local, and close the WCF client object. Wenn die Clientanwendung den ersten Vorgang aufgerufen wird, WCF öffnet automatisch den zugrunde liegenden Kanal und der zugrunde liegenden Kanal wird geschlossen, wenn das Objekt wiederverwendet wird.When the client application calls the first operation, WCF automatically opens the underlying channel, and the underlying channel is closed when the object is recycled. (Es besteht auch die Möglichkeit, den Kanal vor oder nach dem Aufruf anderer Vorgänge explizit zu öffnen und zu schließen.)(Alternatively, you can also explicitly open and close the channel prior to or subsequent to calling other operations.)

Beispiel: Sie verfügen über den folgenden Dienstvertrag:For example, if you have the following service contract:

namespace Microsoft.ServiceModel.Samples  
{  
    using System;  
    using System.ServiceModel;  

    [ServiceContract(Namespace = "http://Microsoft.ServiceModel.Samples")]  
    public interface ICalculator  
   {  
        [OperationContract]  
        double Add(double n1, double n2);  
        [OperationContract]  
        double Subtract(double n1, double n2);  
        [OperationContract]  
        double Multiply(double n1, double n2);  
        [OperationContract]  
        double Divide(double n1, double n2);  
    }  
}  
Namespace Microsoft.ServiceModel.Samples  

    Imports System  
    Imports System.ServiceModel  

    <ServiceContract(Namespace:= _  
    "http://Microsoft.ServiceModel.Samples")> _   
   Public Interface ICalculator  
        <OperationContract> _   
        Function Add(n1 As Double, n2 As Double) As Double  
        <OperationContract> _   
        Function Subtract(n1 As Double, n2 As Double) As Double  
        <OperationContract> _   
        Function Multiply(n1 As Double, n2 As Double) As Double  
        <OperationContract> _   
     Function Divide(n1 As Double, n2 As Double) As Double  
End Interface  

Sie können Vorgänge durch Erstellen eines WCF-Client-Objekts aufrufen, und ihre Methoden aufrufen, wie im folgenden Codebeispiel wird veranschaulicht.You can call operations by creating a WCF client object and calling its methods, as the following code example demonstrates. Beachten Sie, dass das Öffnen, aufrufen, und Schließen des WCF-Clientobjekts erfolgt innerhalb eines einzelnen Try/Catch-Blocks.Note that the opening, calling, and closing of the WCF client object occurs within a single try/catch block. Weitere Informationen finden Sie unter beim Zugriff auf Dienste, die mithilfe eines WCF-Clients und Vermeiden von Problemen mit der Using-Anweisung.For more information, see Accessing Services Using a WCF Client and Avoiding Problems with the Using Statement.

CalculatorClient wcfClient = new CalculatorClient();
try
{
    Console.WriteLine(wcfClient.Add(4, 6));
    wcfClient.Close();
}
catch (TimeoutException timeout)
{
    // Handle the timeout exception.
    wcfClient.Abort();
}
catch (CommunicationException commException)
{
    // Handle the communication exception.
    wcfClient.Abort();
}

Behandeln von FehlernHandling Errors

Ausnahmen können in einer Clientanwendung unter folgenden Bedingungen auftreten: beim Öffnen des zugrunde liegenden Kanals (entweder explizit oder automatisch durch Aufrufen eines Vorgangs), beim Aufrufen von Vorgängen mit dem Client- oder Kanalobjekt oder beim Schließen des zugrunde liegenden Clientkanals.Exceptions can occur in a client application when opening the underlying client channel (whether explicitly or automatically by calling an operation), using the client or channel object to call operations, or when closing the underlying client channel. Anwendungen sollten zumindest erwarten, mögliche System.TimeoutException-Ausnahmen und System.ServiceModel.CommunicationException-Ausnahmen sowie jegliche System.ServiceModel.FaultException-Objekte zu behandeln, die infolge von durch Vorgänge zurückgegebenen SOAP-Fehlern ausgelöst werden.It is recommended at a minimum that applications expect to handle possible System.TimeoutException and System.ServiceModel.CommunicationException exceptions in addition to any System.ServiceModel.FaultException objects thrown as a result of SOAP faults returned by operations. Im Vorgangsvertrag angegebene SOAP-Fehler werden als System.ServiceModel.FaultException<TDetail> zu Clientanwendungen heraufgestuft, wobei der Typparameter der Detailtyp des SOAP-Fehlers ist.SOAP faults specified in the operation contract are raised to client applications as a System.ServiceModel.FaultException<TDetail> where the type parameter is the detail type of the SOAP fault. Weitere Informationen zur Behandlung von fehlerbedingungen in einer Clientanwendung finden Sie unter senden und Empfangen von Fehlern.For more information about handling error conditions in a client application, see Sending and Receiving Faults. Ein vollständiges Beispiel für das Behandeln von Fehlern in einem Client, finden Sie unter Ausnahmen erwartet.For a complete sample the shows how to handle errors in a client, see Expected Exceptions.

Konfigurieren und Sichern von ClientsConfiguring and Securing Clients

Das Konfigurieren eines Clients beginnt mit dem erforderlichen Laden von Zielendpunktinformationen für das Client- oder Kanalobjekt (in der Regel von einer Konfigurationsdatei), obwohl diese Informationen auch programmgesteuert mithilfe der Clientkonstruktoren und -eigenschaften geladen werden können.Configuring a client starts with the required loading of target endpoint information for the client or channel object, usually from a configuration file, although you can also load this information programmatically using the client constructors and properties. Allerdings sind zusätzliche Konfigurationsschritte erforderlich, um ein bestimmtes Clientverhalten zu ermöglichen und zahlreichen Sicherheitsszenarien gerecht zu werden.However, additional configuration steps are required to enable certain client behavior and for many security scenarios.

Beispielsweise werden Sicherheitsanforderungen für Dienstverträge in der Dienstvertragschnittstelle deklariert, und falls mit Svcutil.exe eine Konfigurationsdatei erstellt wurde, beinhaltet diese Datei normalerweise eine Bindung, die den Sicherheitsanforderungen des Diensts entspricht.For example, security requirements for service contracts are declared in the service contract interface, and if Svcutil.exe created a configuration file, that file usually contains a binding that is capable of supporting the security requirements of the service. In einigen Fällen sind jedoch möglicherweise zusätzliche Sicherheitskonfigurationen erforderlich, zum Beispiel die Konfiguration von Clientanmeldeinformationen.In some cases, however, more security configuration may be required, such as configuring client credentials. Vollständige Informationen zur Konfiguration der Sicherheit für WCF-Clients finden Sie unter Sichern von Clients.For complete information about the configuration of security for WCF clients, see Securing Clients.

Zudem können einige benutzerdefinierte Änderungen in Clientanwendungen aktiviert werden, zum Beispiel benutzerdefiniertes Laufzeitverhalten.In addition, some custom modifications can be enabled in client applications, such as custom run-time behaviors. Weitere Informationen zum Konfigurieren eines benutzerdefinierten Clientverhaltens finden Sie unter Konfigurieren von Clientverhalten.For more information about how to configure a custom client behavior, see Configuring Client Behaviors.

Erstellen von Rückrufobjekten für DuplexdiensteCreating Callback Objects for Duplex Services

Mit Duplexdiensten wird ein Rückrufvertrag angegeben, den die Clientanwendung implementieren muss, um gemäß den Vertragsanforderungen ein Rückrufobjekt für den aufzurufenden Dienst bereitzustellen.Duplex services specify a callback contract that the client application must implement in order to provide a callback object for the service to call according to the requirements of the contract. Obgleich es sich bei Rückrufobjekten nicht um vollständige Dienste handelt (beispielsweise kann ein Kanal nicht mit einem Rückrufobjekt initiiert werden), können Sie zu Implementierungs- und Konfigurationszwecken als eine Art Dienst betrachtet werden.Although callback objects are not full services (for example, you cannot initiate a channel with a callback object), for the purposes of implementation and configuration they can be thought of as a kind of service.

Clients von Duplexdiensten müssen folgende Vorgänge ausführen:Clients of duplex services must:

  • Eine Rückrufvertragsklasse implementieren.Implement a callback contract class.

  • Eine Instanz der Implementierungsklasse Rückrufvertrags erstellen und verwenden sie zum Erstellen der System.ServiceModel.InstanceContext -Objekt, das Sie für den WCF-Client-Konstruktor übergeben.Create an instance of the callback contract implementation class and use it to create the System.ServiceModel.InstanceContext object that you pass to the WCF client constructor.

  • Vorgänge aufrufen und Vorgangsrückrufe behandeln.Invoke operations and handle operation callbacks.

Duplex WCF Client Objekte funktionieren wie ihre Gegenstücke, mit der Ausnahme, dass sie die erforderlichen Funktionen zur Unterstützung von Rückrufen, einschließlich der Konfiguration des rückrufdiensts verfügbar machen.Duplex WCF client objects function like their nonduplex counterparts, with the exception that they expose the functionality necessary to support callbacks, including the configuration of the callback service.

Beispielsweise können verschiedene Aspekte des Laufzeitverhaltens des Rückrufobjekts mithilfe der Eigenschaften des System.ServiceModel.CallbackBehaviorAttribute-Attributs in der Rückrufklasse gesteuert werden.For example, you can control various aspects of callback object runtime behavior by using properties of the System.ServiceModel.CallbackBehaviorAttribute attribute on the callback class. Ein weiteres Beispiel ist die Verwendung der System.ServiceModel.Description.CallbackDebugBehavior-Klasse, um die Rückgabe von Ausnahmeinformationen an Dienste, die das Rückrufobjekt aufrufen, zu ermöglichen.Another example is the use of the System.ServiceModel.Description.CallbackDebugBehavior class to enable the return of exception information to services that call the callback object. Weitere Informationen finden Sie unter Duplexdienste.For more information, see Duplex Services. Ein vollständiges Beispiel finden Sie unter Duplex.For a complete sample, see Duplex.

Auf Windows XP-Computern, auf denen Internetinformationsdienste (IIS) 5.1 ausgeführt wird, muss von Duplexclients eine Clientbasisadresse mithilfe der System.ServiceModel.WSDualHttpBinding-Klasse angegeben werden, da andernfalls eine Ausnahme ausgelöst wird.On Windows XP computers running Internet Information Services (IIS) 5.1, duplex clients must specify a client base address using the System.ServiceModel.WSDualHttpBinding class or an exception is thrown. Im folgenden Codebeispiel wird die entsprechende Umsetzung in Code veranschaulicht.The following code example shows how to do this in code.

WSDualHttpBinding dualBinding = new WSDualHttpBinding();
EndpointAddress endptadr = new EndpointAddress("http://localhost:12000/DuplexTestUsingCode/Server");
dualBinding.ClientBaseAddress = new Uri("http://localhost:8000/DuplexTestUsingCode/Client/");

Dim dualBinding As New WSDualHttpBinding()
Dim endptadr As New EndpointAddress("http://localhost:12000/DuplexTestUsingCode/Server")
dualBinding.ClientBaseAddress = New Uri("http://localhost:8000/DuplexTestUsingCode/Client/")

Im folgenden Codebeispiel wird die entsprechende Umsetzung in einer Konfigurationsdatei veranschaulicht.The following code shows how to do this in a configuration file

<client>
  <endpoint 
    name ="ServerEndpoint" 
    address="http://localhost:12000/DuplexUsingConfig/Server"
    bindingConfiguration="WSDualHttpBinding_IDuplex" 
    binding="wsDualHttpBinding"
    contract="IDuplex" 
/>
</client>
<bindings>
  <wsDualHttpBinding>
    <binding 
      name="WSDualHttpBinding_IDuplex"  
      clientBaseAddress="http://localhost:8000/myClient/" 
    />
  </wsDualHttpBinding>
</bindings>

Asynchrones Aufrufen von DienstenCalling Services Asynchronously

Die Art und Weise eines Vorgangsaufrufs ist ausschließlich Angelegenheit des Cliententwicklers.How operations are called is entirely up to the client developer. Dies liegt daran, dass die Nachrichten, aus denen sich ein Vorgang zusammensetzt, bei der Darstellung in verwaltetem Code entweder synchronen oder asynchronen Methoden zugeordnet werden können.This is because the messages that make up an operation can be mapped to either synchronous or asynchronous methods when expressed in managed code. Wenn Sie einen Client erstellen möchten, mit dem Vorgänge asynchron aufgerufen werden, können Sie daher mit Svcutil.exe und der Option /async asynchronen Clientcode generieren.Therefore, if you want to build a client that calls operations asynchronously, you can use Svcutil.exe to generate asynchronous client code using the /async option. Weitere Informationen finden Sie unter Vorgehensweise: Aufrufen Service Vorgänge asynchron.For more information, see How to: Call Service Operations Asynchronously.

Aufrufen von Diensten mithilfe der WCF-Clientkanäle.Calling Services Using WCF Client Channels

WCF-Clienttypen erweitern ClientBase<TChannel>, die selbst leitet sich von System.ServiceModel.IClientChannel Schnittstelle, um die zugrunde liegende kanalsystem verfügbar zu machen.WCF client types extend ClientBase<TChannel>, which itself derives from System.ServiceModel.IClientChannel interface to expose the underlying channel system. Sie können Dienste aufrufen, indem Sie den Zieldienstvertrag mit der System.ServiceModel.ChannelFactory<TChannel>-Klasse verwenden.You can invoke services by using the target service contract with the System.ServiceModel.ChannelFactory<TChannel> class. Weitere Informationen finden Sie unter WCF-Clientarchitektur.For details, see WCF Client Architecture.

Siehe auchSee Also

System.ServiceModel.ClientBase<TChannel>
System.ServiceModel.ChannelFactory<TChannel>