De runtime configureren en uitbreiden met gedrag

Met gedrag kunt u het standaardgedrag wijzigen en aangepaste extensies toevoegen die de serviceconfiguratie inspecteren en valideren of runtimegedrag wijzigen in WCF-client- en servicetoepassingen (Windows Communication Foundation). In dit onderwerp worden de gedragsinterfaces beschreven, hoe u deze implementeert en hoe u deze toevoegt aan de servicebeschrijving (in een servicetoepassing) of eindpunt (in een clienttoepassing) programmatisch of in een configuratiebestand. Voor meer informatie over het gebruik van door het systeem geleverd gedrag, zie Servicegedrag specificeren Run-Time en Clientgedrag specificeren Run-Time.

Gedrag

Gedragstypen worden toegevoegd aan de service- of service-eindpuntbeschrijvingsobjecten (respectievelijk op de service of client) voordat deze objecten worden gebruikt door Windows Communication Foundation (WCF) om een runtime te maken waarmee een WCF-service of een WCF-client wordt uitgevoerd. Wanneer dit gedrag wordt aangeroepen tijdens het runtime-bouwproces, hebben ze vervolgens toegang tot runtime-eigenschappen en -methoden die de runtime wijzigen die is samengesteld door het contract, bindingen en adressen.

Gedragsmethoden

Alle gedragingen hebben een AddBindingParameters methode, een ApplyDispatchBehavior methode, een Validate methode en een ApplyClientBehavior methode met één uitzondering: Omdat IServiceBehavior het niet kan worden uitgevoerd in een client, wordt deze niet geïmplementeerd ApplyClientBehavior.

• Gebruik de AddBindingParameters methode om aangepaste objecten te wijzigen of toe te voegen aan een verzameling waartoe aangepaste bindingen toegang hebben voor hun gebruik wanneer de runtime wordt samengesteld. Dit is bijvoorbeeld de manier waarop beveiligingsvereisten worden opgegeven die van invloed zijn op de manier waarop het kanaal wordt gebouwd, maar die niet bekend zijn door de kanaalontwikkelaar.

• Gebruik de Validate methode om de beschrijvingsstructuur en het bijbehorende runtimeobject te onderzoeken om ervoor te zorgen dat het voldoet aan een aantal criteria.

• Gebruik de ApplyDispatchBehavior en ApplyClientBehavior methoden om de beschrijvingsstructuur te onderzoeken en de runtime te wijzigen voor een bepaald bereik op de service of de client. U kunt ook extensieobjecten invoegen.

  Opmerking

  Hoewel een beschrijvingsstructuur in deze methoden wordt verstrekt, is het alleen bedoeld voor onderzoek. Als een beschrijvingsstructuur wordt gewijzigd, is het gedrag niet gedefinieerd.

De eigenschappen die u kunt wijzigen en de aanpassingsinterfaces die u kunt implementeren, worden geopend via de service- en clientruntimeklassen. De servicetypen zijn de DispatchRuntime en DispatchOperation klassen. De clienttypen zijn de ClientRuntime en ClientOperation klassen. De ClientRuntime en DispatchRuntime klassen zijn de uitbreidbaarheidsinvoerpunten voor respectievelijk toegang tot clientbrede en servicebrede runtime-eigenschappen en extensieverzamelingen. Op dezelfde manier stellen de ClientOperation en DispatchOperation klassen respectievelijk de runtime-eigenschappen van clientbewerkingen en servicebewerkingen bloot, evenals extensieverzamelingen. U kunt echter indien nodig het ruimer gedefinieerde runtime-object openen vanuit het runtime-object van de operatie en vice versa.

De meeste WCF-gebruikers communiceren niet rechtstreeks met de runtime; In plaats daarvan gebruiken ze kernprogrammeermodelconstructies zoals eindpunten, contracten, bindingen, adressen en gedragskenmerken voor klassen of gedrag in configuratiebestanden. Deze constructies vormen de beschrijvingsstructuur. Dit is de volledige specificatie voor het bouwen van een runtime ter ondersteuning van een service of client die wordt beschreven door de beschrijvingsstructuur.

Er zijn vier soorten gedrag in WCF:

• Servicegedrag (IServiceBehavior typen) maken het aanpassen van de volledige serviceruntime mogelijk, waaronder ServiceHostBase.

• Eindpuntgedrag (IEndpointBehavior typen) maken het aanpassen van service-eindpunten en de bijbehorende EndpointDispatcher objecten mogelijk.

• Contractgedrag (IContractBehavior typen) maken de aanpassing van respectievelijk de ClientRuntime en DispatchRuntime klassen in client- en servicetoepassingen mogelijk.

• Bewerkingsgedrag (IOperationBehavior typen) maken het aanpassen van de ClientOperation en DispatchOperation klassen mogelijk, opnieuw, op de client en service.

U kunt dit gedrag toevoegen aan de verschillende beschrijvingsobjecten door aangepaste kenmerken te implementeren, toepassingsconfiguratiebestanden te gebruiken of rechtstreeks door ze toe te voegen aan de gedragverzameling op het juiste beschrijvingsobject. Het moet echter worden toegevoegd aan een servicebeschrijving of een service-eindpuntbeschrijving object voordat ICommunicationObject.Open wordt aangeroepen op het ServiceHost of een ChannelFactory<TChannel>.

Gedragsbereiken

Er zijn vier gedragstypen, die elk overeenkomen met een bepaald bereik van runtime-toegang.

Servicegedrag

Servicegedrag, dat implementeert IServiceBehavior, is het primaire mechanisme waarmee u de volledige serviceruntime wijzigt. Er zijn drie mechanismen voor het toevoegen van servicegedrag aan een service.

1. Een kenmerk in de serviceklasse gebruiken. Wanneer een ServiceHost constructie wordt gemaakt, gebruikt de ServiceHost implementatie weerspiegeling om de set kenmerken van het type service te detecteren. Als een van deze kenmerken implementaties IServiceBehaviorvan zijn, worden ze toegevoegd aan de gedragverzameling op ServiceDescription. Hierdoor kunnen deze gedragingen bijdragen aan de ontwikkeling van de service-runtime.

2. Programmatisch het gedrag toevoegen aan de gedragverzameling op ServiceDescription. Dit kan worden bereikt met de volgende coderegels.

   ServiceHost host = new ServiceHost(/* Parameters */);  
   host.Description.Behaviors.Add(/* Service Behavior */);  
   

3. Het implementeren van een aangepaste BehaviorExtensionElement configuratie die de configuratie uitbreidt. Dit maakt het gebruik van het servicegedrag van toepassingsconfiguratiebestanden mogelijk.

Voorbeelden van servicegedrag in WCF zijn het ServiceBehaviorAttribute kenmerk, het ServiceThrottlingBehavioren het ServiceMetadataBehavior gedrag.

Contractgedrag

Contractgedrag, waarmee de IContractBehavior interface wordt geïmplementeerd, wordt gebruikt om zowel de client- als serviceruntime voor een contract uit te breiden.

Er zijn twee mechanismen voor het toevoegen van contractgedrag aan een contract. Het eerste mechanisme is het maken van een aangepast kenmerk dat moet worden gebruikt op de contractinterface. Wanneer een contractinterface wordt doorgegeven aan een ServiceHost of een ChannelFactory<TChannel>, onderzoekt WCF de kenmerken op de interface. Als er kenmerken zijn die implementaties van IContractBehavior zijn, worden deze toegevoegd aan de collectie gedragingen die is aangemaakt voor die interface binnen System.ServiceModel.Description.ContractDescription.

U kunt ook het gedragskenmerk van het System.ServiceModel.Description.IContractBehaviorAttribute aangepaste contract implementeren. In dit geval is het gedrag als volgt wanneer dit wordt toegepast op:

•Een contractinterface. In dit geval wordt het gedrag toegepast op alle contracten van dat type in elk eindpunt en negeert WCF de waarde van de IContractBehaviorAttribute.TargetContract eigenschap.

•Een serviceklasse. In dit geval wordt het gedrag alleen toegepast op eindpunten waarvan het contract de waarde van de TargetContract eigenschap is.

•Een callback-klasse. In dit geval wordt het gedrag toegepast op het eindpunt van de duplex-client en negeert WCF de waarde van de TargetContract eigenschap.

Het tweede mechanisme is om het gedrag toe te voegen aan de gedragverzameling op een ContractDescription.

Voorbeelden van contractgedrag in WCF omvatten het System.ServiceModel.DeliveryRequirementsAttribute kenmerk. Zie het naslagonderwerp voor meer informatie en een voorbeeld.

Eindpunt gedrag

Eindpuntgedrag, dat implementeert IEndpointBehavior, is het primaire mechanisme waarmee u de volledige service- of clientruntime voor een specifiek eindpunt wijzigt.

Er zijn twee mechanismen voor het toevoegen van eindpuntgedrag aan een service.

1. Voeg het gedrag toe aan de Behaviors eigenschap.

2. Implementeer een aangepaste BehaviorExtensionElement configuratie die de configuratie uitbreidt.

Zie het naslagonderwerp voor meer informatie en een voorbeeld.

Werkingsgedrag

Bewerkingsgedrag, waarmee de IOperationBehavior interface wordt geïmplementeerd, wordt gebruikt om zowel de client- als serviceruntime voor elke bewerking uit te breiden.

Er zijn twee mechanismen voor het toevoegen van bewerkingsgedrag aan een bewerking. Het eerste mechanisme is het maken van een aangepast kenmerk dat moet worden gebruikt voor de methode die de bewerking modelleert. Wanneer een bewerking wordt toegevoegd aan een ServiceHost of een ChannelFactory, voegt WCF IOperationBehavior-kenmerken toe aan de gedragsverzameling op de OperationDescription die voor die bewerking is gemaakt.

Het tweede mechanisme is door het gedrag rechtstreeks toe te voegen aan de gedragverzameling op een geconstrueerde OperationDescription.

Voorbeelden van werkingsgedrag in WCF zijn de OperationBehaviorAttribute en de TransactionFlowAttribute.

Zie het naslagonderwerp voor meer informatie en een voorbeeld.

Configuratie gebruiken om gedrag te maken

Service- en eindpunt- en contractgedrag kunnen worden ontworpen om te worden opgegeven in code of met behulp van kenmerken; alleen service- en eindpuntgedrag kunnen worden geconfigureerd met behulp van toepassings- of webconfiguratiebestanden. Door gedrag beschikbaar te maken met behulp van kenmerken, kunnen ontwikkelaars een gedrag opgeven op compilatietijd dat niet kan worden toegevoegd, verwijderd of gewijzigd tijdens runtime. Dit is vaak geschikt voor gedrag dat altijd vereist is voor de juiste werking van een service (bijvoorbeeld de transactiegerelateerde parameters voor het System.ServiceModel.ServiceBehaviorAttribute kenmerk). Door gedrag met behulp van configuratie beschikbaar te maken, kunnen ontwikkelaars de specificatie en configuratie van dit gedrag achterlaten aan degenen die de service implementeren. Dit is geschikt voor gedrag dat optionele onderdelen of andere implementatiespecifieke configuraties zijn, zoals of metagegevens beschikbaar worden gesteld voor de service of de specifieke autorisatieconfiguratie voor een service.

Om een gedrag beschikbaar te maken met behulp van configuratie, moet een ontwikkelaar een afgeleide klasse van BehaviorExtensionElement maken en die extensie vervolgens registreren bij de configuratie.

In het volgende codevoorbeeld toont hoe een IEndpointBehavior een BehaviorExtensionElement implementeert:

// BehaviorExtensionElement members  
public override Type BehaviorType  
{  
  get { return typeof(EndpointBehaviorMessageInspector); }  
}  
  
protected override object CreateBehavior()  
{  
  return new EndpointBehaviorMessageInspector();  
}  

Om ervoor te zorgen dat het configuratiesysteem een aangepaste BehaviorExtensionElement laadt, moet het worden geregistreerd als een uitbreiding. In het volgende codevoorbeeld ziet u het configuratiebestand voor het voorgaande eindpuntgedrag:

<configuration>  
  <system.serviceModel>  
    <services>  
      <service
        name="Microsoft.WCF.Documentation.SampleService"  
        behaviorConfiguration="metadataSupport"  
      >  
        <host>  
          <baseAddresses>  
            <add baseAddress="http://localhost:8080/ServiceMetadata" />  
          </baseAddresses>  
        </host>  
        <endpoint  
          address="/SampleService"  
          binding="wsHttpBinding"  
          behaviorConfiguration="withMessageInspector"
          contract="Microsoft.WCF.Documentation.ISampleService"  
        />  
        <endpoint  
           address="mex"  
           binding="mexHttpBinding"  
           contract="IMetadataExchange"  
        />  
      </service>  
    </services>  
    <behaviors>  
      <serviceBehaviors>  
      <behavior name="metadataSupport">  
        <serviceMetadata httpGetEnabled="true" httpGetUrl=""/>  
      </behavior>  
      </serviceBehaviors>  
      <endpointBehaviors>  
        <behavior name="withMessageInspector">  
          <endpointMessageInspector />  
        </behavior>  
      </endpointBehaviors>  
    </behaviors>  
    <extensions>  
      <behaviorExtensions>  
        <add
          name="endpointMessageInspector"  
          type="Microsoft.WCF.Documentation.EndpointBehaviorMessageInspector, HostApplication, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null"  
        />  
      </behaviorExtensions>  
    </extensions>  
  </system.serviceModel>  
</configuration>  

Waar Microsoft.WCF.Documentation.EndpointBehaviorMessageInspector is het type gedragsextensie en HostApplication is de naam van de assembly waarin die klasse is gecompileerd.

Evaluatievolgorde

De System.ServiceModel.ChannelFactory<TChannel> en de System.ServiceModel.ServiceHost zijn verantwoordelijk voor het bouwen van de runtime uit het programmeermodel en de beschrijving. Gedragingen, zoals eerder beschreven is, dragen bij aan dat bouwproces bij de service, het eindpunt, het contract en de bewerking.

Het ServiceHost past gedragingen toe in de volgende volgorde:

1. Dienst

2. Overeenkomst

3. Eindpunt

4. Operatie

Binnen een verzameling gedrag wordt geen order gegarandeerd.

Het ChannelFactory<TChannel> past gedragingen toe in de volgende volgorde:

1. Overeenkomst

2. Eindpunt

3. Operatie

Binnen een verzameling gedragingen, nogmaals, is er geen order gegarandeerd.

Gedrag programmatisch toevoegen

Eigenschappen van de System.ServiceModel.Description.ServiceDescription in de servicetoepassing mogen niet worden gewijzigd na de CommunicationObject.OnOpening methode op System.ServiceModel.ServiceHostBase. Sommige leden, zoals de ServiceHostBase.Credentials eigenschap en de AddServiceEndpoint methoden op ServiceHostBase en System.ServiceModel.ServiceHost, genereren een uitzondering als ze na dat punt worden gewijzigd. Anderen staan toe dat je ze wijzigt, maar het resultaat is onbepaald.

Op dezelfde manier mogen de System.ServiceModel.Description.ServiceEndpoint waarden op de client niet worden gewijzigd na de aanroep naar OnOpening de System.ServiceModel.ChannelFactory. De ChannelFactory.Credentials eigenschap genereert een uitzondering als deze is gewijzigd voorbij dat punt, maar de andere clientbeschrijvingswaarden kunnen zonder fouten worden gewijzigd. Het resultaat is echter niet gedefinieerd.

Of het nu gaat om de service of de client, het wordt aanbevolen om de beschrijving te wijzigen voordat u CommunicationObject.Open oproept.

Overnameregels voor gedragskenmerken

Alle vier de soorten gedrag kunnen worden ingevuld met behulp van kenmerken: servicegedrag en contractgedrag. Omdat kenmerken zijn gedefinieerd voor beheerde objecten en leden en beheerde objecten en leden ondersteuning bieden voor overname, moet u definiëren hoe gedragskenmerken werken in de context van overname.

Op hoog niveau is de regel dat voor een bepaald bereik (bijvoorbeeld service, contract of bewerking) alle gedragskenmerken in de overnamehiërarchie voor dat bereik worden toegepast. Als er twee gedragskenmerken van hetzelfde type zijn, wordt alleen het meest afgeleide type gebruikt.

Servicegedrag

Voor een bepaalde serviceklasse worden alle kenmerken van servicegedrag op die klasse en op bovenouders van die klasse toegepast. Als hetzelfde type kenmerk wordt toegepast op meerdere plaatsen in de overnamehiërarchie, wordt het meest afgeleide type gebruikt.

[ServiceBehavior(ConcurrencyMode = ConcurrencyMode.Multiple)]  
[AspNetCompatibilityRequirementsAttribute(  
    AspNetCompatibilityRequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]  
public class A { /* … */ }  
  
[ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]  
public class B : A { /* … */}  

In het voorgaande geval eindigt de service B bijvoorbeeld met een InstanceContextMode van Single, een AspNetCompatibilityRequirementsMode modus van Allowed, en een ConcurrencyMode van Single. Dit ConcurrencyMode is Single, omdat het ServiceBehaviorAttribute kenmerk van service B "meer afgeleid" is dan dat van service A.

Contractgedrag

Voor een bepaald contract worden alle attributen van het contractgedrag op die interface en op ouders van die interface toegepast. Als hetzelfde type kenmerk wordt toegepast op meerdere plaatsen in de overnamehiërarchie, wordt het meest afgeleide type gebruikt.

Werkingsgedrag

Als een bepaalde bewerking een bestaande abstracte of virtuele bewerking niet overschrijft, zijn er geen overnameregels van toepassing.

Als een bewerking een bestaande bewerking overschrijdt, worden alle gedragskenmerken van die bewerking en op de ouders van die bewerking toegepast. Als hetzelfde type kenmerk wordt toegepast op meerdere plaatsen in de overnamehiërarchie, wordt het meest afgeleide type gebruikt.