Clientarchitectuur

Toepassingen gebruiken WCF-clientobjecten (Windows Communication Foundation) om servicebewerkingen aan te roepen. In dit onderwerp worden WCF-clientobjecten, WCF-clientkanalen en hun relaties met de onderliggende kanaalarchitectuur besproken. Zie wcf-clientoverzicht voor een eenvoudig overzicht van WCF-clientobjecten. Zie De kanaallaag uitbreiden voor meer informatie over de kanaallaag.

Overzicht

De runtime van het servicemodel maakt WCF-clients, die bestaan uit het volgende:

• Een automatisch gegenereerde client-implementatie van een servicecontract, waarmee aanroepen van uw toepassingscode worden omgezet in uitgaande berichten, en antwoordberichten worden omgezet in uitvoerparameters en retourwaarden die uw toepassing kan ophalen.

• Een implementatie van een besturingsinterface (System.ServiceModel.IClientChannel) die verschillende interfaces groeperen en toegang biedt tot beheerfunctionaliteit, met name de mogelijkheid om de clientsessie te sluiten en het kanaal te verwijderen.

• Een clientkanaal dat is gebouwd op basis van de configuratie-instellingen die zijn opgegeven door de gebruikte binding.

Toepassingen kunnen dergelijke clients op aanvraag maken, hetzij via een System.ServiceModel.ChannelFactory of door een exemplaar van een ClientBase<TChannel> afgeleide klasse te maken omdat deze wordt gegenereerd door het Hulpprogramma voor metagegevens van ServiceModel (Svcutil.exe). Deze kant-en-klare clientklassen omvatten en delegeren naar een clientkanaal-implementatie die dynamisch wordt samengesteld door een ChannelFactory. Daarom zijn het klantkanaal en de kanalenfabriek die deze produceert het middelpunt van deze discussie.

Clientobjecten en Clientkanalen

De basisinterface van WCF-clients is de System.ServiceModel.IClientChannel interface, waarmee de kernfunctionaliteit van de client en de basisfunctionaliteit van het communicatieobject System.ServiceModel.ICommunicationObject, de contextfunctionaliteit van System.ServiceModel.IContextChannel, en het uitbreidbare gedrag van System.ServiceModel.IExtensibleObject<T> worden blootgelegd.

De IClientChannel interface definieert echter geen servicecontract zelf. Deze worden gedeclareerd door de servicecontractinterface (meestal gegenereerd op basis van servicemetagegevens met behulp van een hulpprogramma zoals het Hulpprogramma voor metagegevens van ServiceModel (Svcutil.exe)). WCF-clienttypen breiden zowel IClientChannel als de interface van het doelservicecontract uit, zodat toepassingen bewerkingen rechtstreeks kunnen aanroepen en ook toegang hebben tot runtimefunctionaliteit aan de clientzijde. Als u een WCF-client maakt, beschikt u over WCF-objectenSystem.ServiceModel.ChannelFactory met de informatie die nodig is om een runtime te maken die verbinding kan maken met het geconfigureerde service-eindpunt en deze kan gebruiken.

Zoals eerder vermeld, moeten de twee WCF-clienttypen worden geconfigureerd voordat u ze kunt gebruiken. De eenvoudigste WCF-clienttypen zijn objecten die zijn afgeleid van ClientBase<TChannel> (of DuplexClientBase<TChannel> als het servicecontract een dubbelzijdig contract is). U kunt deze typen maken met behulp van een constructor, programmatisch geconfigureerd of met behulp van een configuratiebestand en vervolgens rechtstreeks aangeroepen om servicebewerkingen aan te roepen. Zie ClientBase<TChannel> voor een eenvoudig overzicht van objecten.

Het tweede type wordt tijdens runtime gegenereerd vanuit een aanroep naar de CreateChannel methode. Toepassingen met betrekking tot nauw beheer van de communicatiespecifieken gebruiken doorgaans dit clienttype, een clientkanaalobject genoemd, omdat het meer directe interactie mogelijk maakt dan de onderliggende clientruntime en het kanaalsysteem.

Zenderfabrieken

De klasse die verantwoordelijk is voor het maken van de onderliggende runtime die clientinvocations ondersteunt, is de System.ServiceModel.ChannelFactory<TChannel> klasse. Zowel WCF-clientobjecten als WCF-clientkanaalobjecten gebruiken een ChannelFactory<TChannel> object om exemplaren te maken. Het ClientBase<TChannel> afgeleide clientobject omvat de verwerking van de kanaalfactory, maar voor een aantal scenario's is het volkomen redelijk om de kanaalfactory rechtstreeks te gebruiken. Het algemene scenario hiervoor is als u herhaaldelijk nieuwe clientkanalen wilt maken op basis van een bestaande factory. Als u een clientobject gebruikt, kunt u de onderliggende kanaalfactory verkrijgen van een WCF-clientobject door de ClientBase<TChannel>.ChannelFactory-eigenschap aan te roepen.

Het belangrijkste om te onthouden over kanalenfabrieken is dat ze nieuwe exemplaren van clientkanalen aanmaken op basis van de configuratie die aan hen is verstrekt voordat ze worden aangeroepen ChannelFactory<TChannel>.CreateChannel. Zodra u CreateChannel (of ClientBase<TChannel>.Open, ClientBase<TChannel>.CreateChannel of een bewerking op een WCF-clientobject) aanroept, kunt u de kanaalfabriek niet wijzigen en verwachten dat er kanalen naar verschillende service-exemplaren worden opgezet, zelfs niet wanneer u alleen het doel-eindpuntadres wijzigt. Als u een clientobject of clientkanaal met een andere configuratie wilt maken, moet u eerst een nieuwe kanaalfactory maken.

Zie Toegang tot services met behulp van een WCF-client voor meer informatie over verschillende problemen met het gebruik van WCF-clientobjecten en WCF-clientkanalen.

In de volgende twee secties wordt het maken en gebruiken van WCF-clientkanaalobjecten beschreven.

Een nieuw WCF-clientkanaalobject maken

Als u het gebruik van een clientkanaal wilt illustreren, gaat u ervan uit dat het volgende servicecontract is gegenereerd.

[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);
}

Om verbinding te maken met een ISampleService dienst, gebruikt u de gegenereerde contractinterface rechtstreeks met een kanaalfabriek (ChannelFactory<TChannel>). Zodra u een kanaalfabriek voor een bepaald contract heeft gemaakt en geconfigureerd, kunt u de CreateChannel-methode aanroepen om clientkanaalobjecten te verkrijgen die u kunt gebruiken voor communicatie met een ISampleService-service.

Wanneer u de ChannelFactory<TChannel> klasse met een servicecontractinterface gebruikt, moet u naar de IClientChannel interface casten om het kanaal expliciet te openen, te sluiten of af te breken. Om het gemakkelijker te maken om mee te werken, genereert het hulpprogramma Svcutil.exe ook een helperinterface waarmee zowel de interface van het servicecontract wordt geïmplementeerd als IClientChannel waarmee u kunt communiceren met de infrastructuur van het clientkanaal zonder dat u hoeft te casten. De volgende code toont de definitie van een helper-clientkanaal waarmee het voorgaande servicecontract wordt geïmplementeerd.

[System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "3.0.0.0")]
public interface ISampleServiceChannel : ISampleService, System.ServiceModel.IClientChannel
{
}

Een nieuw WCF-clientkanaalobject maken

Als u een clientkanaal wilt gebruiken om verbinding te maken met een ISampleService service, gebruikt u de gegenereerde contractinterface (of de helperversie) rechtstreeks met een kanaalfactory, waarbij het type contractinterface wordt doorgegeven als de typeparameter. Zodra een kanaalfabriek voor een bepaald contract is gemaakt en geconfigureerd, kunt u de ChannelFactory<TChannel>.CreateChannel-methode aanroepen om clientkanaalobjecten te retourneren die u kunt gebruiken om met een ISampleService-service te communiceren.

Wanneer ze worden gemaakt, implementeren de clientkanaalobjecten IClientChannel en de contractinterface. Daarom kunt u ze rechtstreeks gebruiken om bewerkingen aan te roepen die communiceren met een service die dat contract ondersteunt.

Het verschil tussen het gebruik van clientobjecten en clientkanaalobjecten is slechts een van de controle en het gebruiksgemak voor ontwikkelaars. Veel ontwikkelaars die vertrouwd zijn met het werken met klassen en objecten, gebruiken liever het WCF-clientobject in plaats van het WCF-clientkanaal.

Voor een voorbeeld, zie Hoe te gebruiken: de ChannelFactory.