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 uitvoeringstijd 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 worden ingekapseld en gedelegeerd aan een clientkanaal-implementatie die dynamisch wordt samengesteld door een ChannelFactory. Daarom zijn het clientkanaal en de kanaalfactory die ze produceert het middelpunt van deze discussie.
Clientobjecten en clientkanalen
De basisinterface van WCF-clients is de System.ServiceModel.IClientChannel interface, waarmee de kernclientfunctionaliteit en de basisfunctionaliteit van communicatieobjecten van System.ServiceModel.ICommunicationObject, de contextfunctionaliteit van System.ServiceModel.IContextChannelen het uitbreidbare gedrag van System.ServiceModel.IExtensibleObject<T>.
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. Het maken van een WCF-client biedt 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 wcf-clientoverzicht voor een eenvoudig overzicht van ClientBase<TChannel> objecten.
Het tweede type wordt gegenereerd tijdens runtime van een aanroep naar de CreateChannel methode. Toepassingen die betrekking hebben op strikte controle over de communicatiedetails, gebruiken doorgaans dit clienttype, een clientkanaalobject genoemd, omdat het meer directe interactie mogelijk maakt dan het onderliggende clientruntime- en kanaalsysteem.
Kanaalfactory's
De klasse die verantwoordelijk is voor het maken van de onderliggende uitvoeringstijd 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 eigenschap aan te ClientBase<TChannel>.ChannelFactory roepen.
Het belangrijkste om te onthouden over kanaalfactory's is dat ze nieuwe exemplaren van clientkanalen maken voor de configuratie die aan hen wordt verstrekt voordat ze worden aangeroepen ChannelFactory<TChannel>.CreateChannel. Zodra u de kanaalfactory hebt aangeroepen CreateChannel (of ClientBase<TChannel>.Open, ClientBase<TChannel>.CreateChannelof een bewerking op een WCF-clientobject), kunt u de kanaalfactory niet wijzigen en verwachten dat er kanalen naar verschillende service-exemplaren worden opgehaald, zelfs als u alleen het doeleindpuntadres 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);
}
Als u verbinding wilt maken met een ISampleService service, gebruikt u de gegenereerde contractinterface rechtstreeks met een kanaalfactory (ChannelFactory<TChannel>). Zodra u een kanaalfactory voor een bepaald contract hebt gemaakt en geconfigureerd, kunt u de CreateChannel methode aanroepen om clientkanaalobjecten te retourneren die u kunt gebruiken om te communiceren 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 kanaalfactory 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 te communiceren met een ISampleService service.
Wanneer de clientkanaalobjecten zijn gemaakt, worden deze geïmplementeerd 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.