Behandeln von Ausnahmen und FehlernHandling Exceptions and Faults

Mit Ausnahmen werden Fehlfunktionen lokal in der Dienst- oder der Clientimplementierung übermittelt.Exceptions are used to communicate errors locally within the service or the client implementation. Fehler übermitteln hingegen Fehlfunktionen über die Grenzen eines Dienstes hinaus, z. B. vom Server zum Client und umgekehrt.Faults, on the other hand, are used to communicate errors across service boundaries, such as from the server to the client or vice versa. Darüber hinaus verwenden Transportkanäle häufig transportspezifische Mechanismen, um Fehlfunktionen auf Transportebene zu übermitteln.In addition to faults, transport channels often use transport-specific mechanisms to communicate transport-level errors. Der HTTP-Transport verwendet z. B. Statuscodes wie 404 zur Übermittlung einer nicht vorhandenen Endpunkt-URL (es gibt keinen Endpunkt, an den der Fehler zurückgegeben werden kann).For example, HTTP transport uses status codes such as 404 to communicate a non-existing endpoint URL (there is no endpoint to send back a fault). Dieses Dokument besteht aus drei Abschnitten mit Hinweisen für Autoren benutzerdefinierter Kanäle.This document consists of three sections that provide guidance to custom channel authors. Der erste Abschnitt enthält Hinweise dazu, wann und wie Ausnahmen definiert und ausgelöst werden.The first section provides guidance on when and how to define and throw exceptions. Der zweite Abschnitt enthält Hinweise zum Auslösen und Behandeln von Fehlern.The second section provides guidance around generating and consuming faults. Im dritten Abschnitt wird das Bereitstellen von Ablaufinformationen erklärt, mit deren Hilfe die Benutzer Ihres benutzerdefinierten Kanals Probleme in laufenden Anwendungen behandeln können.The third section explains how to provide trace information to aid the user of your custom channel in troubleshooting running applications.

AusnahmenExceptions

Beim Auslösen einer Ausnahme müssen zwei Punkte beachtet werden: Erstens muss es sich dabei um einen Typ handeln, bei dem Benutzern den richtigen Code schreiben können, um auf die Ausnahme angemessen zu reagieren.There are two things to keep in mind when throwing an exception: First it has to be of a type that allows users to write correct code that can react appropriately to the exception. Zweiten müssen dabei ausreichend Informationen angegeben werden, damit der Benutzer die Fehlerursache, die Auswirkung des Fehlers und dessen Behebung erkennen kann.Second, it has to provide enough information for the user to understand what went wrong, the failure impact, and how to fix it. Die folgenden Abschnitte enthalten Hinweise zu den Ausnahmetypen und Meldungen für Windows Communication Foundation (WCF)-Kanäle.The following sections give guidance around exception types and messages for Windows Communication Foundation (WCF) channels. Allgemeine Hinweise zu Ausnahmen in .NET finden Sie außerdem in den Entwurfsrichtlinien für Ausnahmen.There is also general guidance around exceptions in .NET in the Design Guidelines for Exceptions document.

AusnahmetypenException Types

Bei allen von Kanälen ausgelösten Ausnahmen muss es sich entweder um System.TimeoutException, System.ServiceModel.CommunicationException oder einen Typ handeln, der von CommunicationException abgeleitet wird.All exceptions thrown by channels must be either a System.TimeoutException, System.ServiceModel.CommunicationException, or a type derived from CommunicationException. (Auch Ausnahmen wie ObjectDisposedException können ausgelöst werden, jedoch nur um anzugeben, dass der aufrufende Code den Kanal missbräuchlich verwendet hat.(Exceptions such as ObjectDisposedException may also be thrown, but only to indicate that the calling code has misused the channel. Wenn ein Kanal ordnungsgemäß verwendet wird, darf er nur die angegebenen Ausnahmen auslösen.) WCF bietet sieben Ausnahmetypen, die davon Herleiten CommunicationException und dienen zum von Kanälen verwendet werden.If a channel is used correctly, it must only throw the given exceptions.) WCF provides seven exception types that derive from CommunicationException and are designed to be used by channels. Es gibt noch weitere von CommunicationException abgeleitete Ausnahmen, die der Verwendung durch andere Teile des Systems dienen.There are other CommunicationException-derived exceptions that are designed to be used by other parts of the system. Dazu gehören die folgenden Ausnahmetypen:These exception types are:

AusnahmetypException Type BedeutungMeaning Inhalt der internen AusnahmeInner Exception Content WiederherstellungsstrategieRecovery Strategy
AddressAlreadyInUseException Die zur Überwachung angegebene Endpunktadresse wird bereits verwendet.The endpoint address specified for listening is already in use. Gibt, sofern vorhanden, weitere Details zum Transportfehler an, der diese Ausnahme verursacht hat.If present, provides more details about the transport error that caused this exception. Beispiel:For example. PipeException, HttpListenerException oder SocketException.PipeException, HttpListenerException, or SocketException. Versuchen Sie es mit einer anderen Adresse.Try a different address.
AddressAccessDeniedException Der Prozess darf nicht auf die zur Überwachung angegebene Endpunktadresse zugreifen.The process is not allowed access to the endpoint address specified for listening. Gibt, sofern vorhanden, weitere Details zum Transportfehler an, der diese Ausnahme verursacht hat.If present, provides more details about the transport error that caused this exception. Beispielsweise PipeException oder HttpListenerException.For example, PipeException, or HttpListenerException. Versuchen Sie es mit anderen Anmeldeinformationen.Try with different credentials.
CommunicationObjectFaultedException Die ICommunicationObject verwendeten befindet sich im Zustand "Faulted" (Weitere Informationen finden Sie unter Grundlegendes zu Zustandsänderungen).The ICommunicationObject being used is in the Faulted state (for more information, see Understanding State Changes). Wenn ein Objekt mit mehreren ausstehenden Aufrufen in den Faulted-Status wechselt, löst nur ein Aufruf eine Ausnahme aus, die sich auf den Fehler bezieht. Die übrigen Aufrufe lösen CommunicationObjectFaultedException aus.Note that when an object with multiple pending calls transitions to the Faulted state, only one call throws an exception that is related to the failure and the rest of the calls throw a CommunicationObjectFaultedException. Diese Ausnahme wird in der Regel ausgelöst, weil eine Anwendung eine Ausnahme übersieht und ein bereits fehlerhaftes Objekt verwenden will, möglicherweise in einem anderen Thread als dem, der die ursprüngliche Ausnahme abfing.This exception is typically thrown because an application overlooks some exception and tries to use an already faulted object, possibly on a thread other than the one that caught the original exception. Gibt, sofern vorhanden, Details zur inneren Ausnahme an.If present provides details about the inner exception. Erstellen Sie ein neues Objekt.Create a new object. Beachten Sie, dass je nachdem, was den Fehler von ICommunicationObject ursprünglich verursacht hat, weitere Maßnahmen zur Problembehandlung erforderlich sein können.Note that depending on what caused the ICommunicationObject to fault in the first place, there may be other work required to recover.
CommunicationObjectAbortedException Die ICommunicationObject verwendeten abgebrochen wurde (Weitere Informationen finden Sie unter Grundlegendes zu Zustandsänderungen).The ICommunicationObject being used has been Aborted (for more information, see Understanding State Changes). Ähnlich wie bei CommunicationObjectFaultedException gibt diese Ausnahme an, dass die Anwendung Abort für ein Objekt aufgerufen hat, möglicherweise aus einem anderen Thread, und das Objekt deshalb nicht mehr verwendet werden kann.Similar to CommunicationObjectFaultedException, his exception indicates the application has called Abort on the object, possibly from another thread, and the object is no longer usable for that reason. Gibt, sofern vorhanden, Details zur inneren Ausnahme an.If present provides details about the inner exception. Erstellen Sie ein neues Objekt.Create a new object. Beachten Sie, dass je nachdem, was den Abbruch von ICommunicationObject ursprünglich verursacht hat, weitere Maßnahmen zur Problembehandlung erforderlich sein können.Note that depending on what caused the ICommunicationObject to abort in the first place, there may be other work required to recover.
EndpointNotFoundException Der Remotezielendpunkt führt keine Überwachung aus.The target remote endpoint is not listening. Möglicherweise ist ein Teil der Endpunktadresse falsch oder kann nicht ausgelöst werden, oder der Endpunkt ist deaktiviert.This can result from any part of the endpoint address being incorrect, irresolvable, or the endpoint being down. Beispiele hierfür sind DNS-Fehler, der Warteschlangen-Manager ist nicht verfügbar oder der Dienst wird nicht ausgeführt.Examples include DNS error, Queue Manager not available, and service not running. Die innere Ausnahme stellt Details bereit, in der Regel aus dem zugrunde liegenden Transport.The inner exception provides details, typically from the underlying transport. Versuchen Sie es mit einer anderen Adresse.Try a different address. Stattdessen kann der Absender auch eine Weile warten und es noch einmal versuchen, für den Fall, dass der Dienst ausgefallen war.Alternatively, the sender may wait a while and try again in case the service was down
ProtocolException Die Kommunikationsprotokolle, die von der Richtlinie des Endpunkts beschrieben werden, stimmen zwischen den Endpunkten nicht überein.The communication protocols, as described by the endpoint’s policy, are mismatched between endpoints. Beispiele: Rahmeninhaltstypenkonflikt oder die maximale Nachrichtengröße wurde überschritten.For example, framing content type mismatch or max message size exceeded. Gibt, sofern vorhanden, Informationen zum speziellen Protokollfehler an.If present provides more information about the specific protocol error. Beispielsweise ist QuotaExceededException die innere Ausnahme, wenn die Fehlerursache eine Überschreitung von MaxReceivedMessageSize ist.For example, QuotaExceededException is the inner exception when the error cause is exceeding MaxReceivedMessageSize. Wiederherstellung: Stellen sicher, dass die Einstellungen für das Absender- und das Empfängerprotokoll übereinstimmen.Recovery: Ensure sender and received protocol settings match. Eine Möglichkeit hierfür besteht darin, die Metadaten (Richtlinie) des Dienstendpunkts neu zu importieren und mit der generierten Bindung den Kanal neu zu erstellen.One way to do this is to re-import the service endpoint’s metadata (policy) and use the generated binding to recreate the channel.
ServerTooBusyException Der Remoteendpunkt führt eine Überwachung aus, ist jedoch noch nicht zur Verarbeitung von Nachrichten bereit.The remote endpoint is listening but is not prepared to process messages. Sofern vorhanden, gibt die innere Ausnahme die Details des SOAP- oder Tansportfehlers an.If present, the inner Exception provides the SOAP fault or transport-level error details. Wiederherstellung: Warten Sie, und wiederholen Sie den Vorgang später.Recovery: Wait and retry the operation later.
TimeoutException Der Vorgang konnte innerhalb des angegebenen Timeouts nicht abgeschlossen werden.The operation failed to complete within the timeout period. Stellt möglicherweise Details über das Timeout bereit.May provide details about the timeout. Warten Sie, und wiederholen Sie den Vorgang später.Wait and retry the operation later.

Definieren Sie nur dann einen neuen Ausnahmetyp, wenn dieser Typ einer bestimmten Wiederherstellungsstrategie entspricht, die sich von allen vorhandenen Ausnahmetypen unterscheidet.Define a new exception type only if that type corresponds to a specific recovery strategy different from all of the existing exception types. Wenn Sie einen neuen Ausnahmetyp definieren, muss er von CommunicationException oder einer der davon abgeleiteten Klassen abgeleitet werden.If you do define a new exception type, it must derive from CommunicationException or one of its derived classes.

AusnahmemeldungenException Messages

Ausnahmemeldungen richten sich an den Benutzer, nicht an das Programm. Deshalb sollten sie ausreichend Informationen enthalten, mit denen der Benutzer das Problem verstehen und beheben kann.Exception messages are targeted at the user not the program so they should provide sufficient information to help the user understand and solve the problem. Eine gute Ausnahmemeldung besteht im Wesentlichen aus den folgenden drei Teilen:The three essential parts of a good exception message are:

Was ist passiert.What happened. Beschreiben Sie das Problem eindeutig und mit Begriffen, die dem Benutzer vertraut sind.Provide a clear description of the problem using terms that relate to the user’s experience. Eine schlechte Ausnahmemeldung wäre z. B. "Ungültiger Konfigurationsabschnitt".For example, a bad exception message would be "Invalid configuration section". Dabei bleibt der Benutzer im Unklaren, welcher Konfigurationsabschnitt falsch ist und warum er falsch ist.This leaves the user wondering which configuration section is incorrect and why it is incorrect. Eine bessere Meldung wäre "Ungültige Konfigurationsabschnitt <CustomBinding >".An improved message would be "Invalid configuration section <customBinding>". Und eine noch bessere Meldung wäre „Der Transport mit der Bezeichnung ,meinTransport‘ kann der Bindung ,meineBindung‘ nicht hinzugefügt werden, da die Bindung bereits einen Transport mit dem Namen ,meinTransport‘ besitzt“.An even better message would be "Cannot add the transport named myTransport to the binding named myBinding because the binding already has a transport named myTransport". Diese Meldung ist sehr genau und verwendet Begriffe und Namen, die der Benutzer schnell in der Konfigurationsdatei der Anwendung findet.This is a very specific message using terms and names that the user can easily identify in the application’s configuration file. Es fehlen jedoch noch immer einige entscheidende Komponenten.However, there are still a few key components missing.

Die Relevanz des Fehlers.The significance of the error. Wenn die Meldung nicht klar angibt, was der Fehler bedeutet, weiß der Benutzer nicht, ob der Fehler schwerwiegend ist oder ignoriert werden kann.Unless the message states clearly what the error means, the user is likely to wonder whether it is a fatal error or if it can be ignored. Im Allgemeinen sollten Fehlermeldungen mit der Bedeutung oder der Relevanz des Fehlers eingeleitet werden.In general, messages should lead with the meaning or significance of the error. Um das vorherige Beispiel zu verbessern, könnte die Meldung lauten "ServiceHost konnte aufgrund eines Konfigurationsfehlers nicht geöffnet werden: Der Transport mit der Bezeichnung meinTransport kann der Bindung meineBindung nicht hinzugefügt werden, da die Bindung bereits einen Transport mit dem Namen meinTransport besitzt".To improve the previous example, the message could be "ServiceHost failed to Open due to a configuration error: Cannot add the transport named myTransport to the binding named myBinding because the binding already has a transport named myTransport".

Vorgehensweise zum Beheben des Problems.How the user should correct the problem. Der wichtigste Teil der Meldung besteht darin, dem Benutzer beim Beheben des Problem zu helfen.The most important part of the message is helping the user fix the problem. Die Meldung sollte einige Anweisungen und Hinweise enthalten, was zu überprüfen oder zu korrigieren ist.The message should include some guidance or hints about what to check or fix to remedy the problem. Beispiel: "ServiceHost konnte aufgrund eines Konfigurationsfehlers nicht geöffnet werden: Der Transport mit der Bezeichnung meinTransport kann der Bindung meineBindung nicht hinzugefügt werden, da die Bindung bereits einen Transport mit dem Namen meinTransport besitzt.For example, "ServiceHost failed to Open due to a configuration error: Cannot add the transport named myTransport to the binding named myBinding because the binding already has a transport named myTransport. Stellen Sie sicher, dass die Bindung nur einen Transport enthält.“Please ensure there is only one transport in the binding".

Übermitteln von FehlernCommunicating Faults

SOAP 1.1 und SOAP 1.2 definieren jeweils eine spezielle Struktur für Fehler.SOAP 1.1 and SOAP 1.2 both define a specific structure for faults. Es gibt einige Unterschiede zwischen den beiden Spezifikationen. Im Allgemeinen werden jedoch die Typen Message und MessageFault zum Erstellen und Behandeln von Fehlern verwendet.There are some differences between the two specifications but in general, the Message and MessageFault types are used to create and consume faults.

Behandeln von Ausnahmen und FehlernHandling exceptions and faults
Fehler in SOAP 1.2 (links) und Fehler in SOAP 1.1 (rechts).SOAP 1.2 Fault (left) and SOAP 1.1 Fault (right). In SOAP 1.1 ist nur das Fault-Element namespacequalifiziert.Note that in SOAP 1.1 only the Fault element is namespace qualified.

SOAP definiert eine Fehlermeldung als Meldung, die nur ein Fehlerelement (ein Element, dessen Name <env:Fault>) als untergeordnetes Element von<env:Body> enthält.SOAP defines a fault message as a message that contains only a fault element (an element whose name is <env:Fault>) as a child of <env:Body>. Der Inhalt des Fehlerelements unterscheidet sich ein wenig zwischen SOAP 1.1 und SOAP 1.2 (siehe Abbildung 1).The contents of the fault element differ slightly between SOAP 1.1 and SOAP 1.2 as shown in figure 1. Die System.ServiceModel.Channels.MessageFault-Klasse normalisiert diese Unterschiede jedoch in ein Objektmodell:However, the System.ServiceModel.Channels.MessageFault class normalizes these differences into one object model:

public abstract class MessageFault  
{  
    protected MessageFault();  

    public virtual string Actor { get; }  
    public virtual string Node { get; }  
    public static string DefaultAction { get; }  
    public abstract FaultCode Code { get; }  
    public abstract bool HasDetail { get; }  
    public abstract FaultReason Reason { get; }  

    public T GetDetail<T>();  
    public T GetDetail<T>( XmlObjectSerializer serializer);  
    public System.Xml.XmlDictionaryReader GetReaderAtDetailContents();  

    // other methods omitted  
}  

Die Code-Eigenschaft entspricht env:Code (oder faultCode in SOAP 1.1) und identifiziert den Typ des Fehlers.The Code property corresponds to the env:Code (or faultCode in SOAP 1.1) and identifies the type of the fault. SOAP 1.2 definiert fünf zulässige Werte für faultCode (z. B. Sender und Receiver) und definiert ein Subcode-Element, das einen beliebigen Subcodewert enthalten kann.SOAP 1.2 defines five allowable values for faultCode (for example, Sender and Receiver) and defines a Subcode element which can contain any subcode value. (Siehe die SOAP 1.2-Spezifikation für die Liste der zulässigen Fehlercodes und ihre Bedeutung beschrieben.) Der Mechanismus in SOAP 1.1 unterscheidet sich ein wenig: Er definiert vier faultCode-Werte (z. B. Client und Server), die erweitert werden können. Die Erweiterung kann entweder durch Definieren völlig neuer Werte erfolgen, oder indem mit der Punktnotation speziellere faultCodes erstellt werden (z. B. Client.Authentication).(See the SOAP 1.2 specification for the list of allowable fault codes and their meaning.) SOAP 1.1 has a slightly different mechanism: It defines four faultCode values (for example, Client and Server) that can be extended either by defining entirely new ones or by using the dot notation to create more specific faultCodes, for example, Client.Authentication.

Wenn Sie MessageFault zum Programmieren von Fehlern verwenden, wird FaultCode.Name und FaultCode.Namespace jeweils dem Namen und dem Namespace von env:Code in SOAP 1.2 oder faultCode in SOAP 1.1 zugeordnet.When you use MessageFault to program faults, the FaultCode.Name and FaultCode.Namespace maps to the name and namespace of the SOAP 1.2 env:Code or the SOAP 1.1 faultCode. FaultCode.SubCode wird env:Subcode für SOAP 1.2 zugeordnet und ist für SOAP 1.1 NULL.The FaultCode.SubCode maps to env:Subcode for SOAP 1.2 and is null for SOAP 1.1.

Erstellen Sie neue Fehlersubcodes (oder bei SOAP 1.1 neue Fehlercodes), wenn eine programmgesteuerte Unterscheidung eines Fehlers von Interesse ist.You should create new fault subcodes (or new fault codes if using SOAP 1.1) if it is interesting to programmatically distinguish a fault. Diese Vorgehensweise entspricht dem Erstellen eines neuen Ausnahmetyps.This is analogous to creating a new exception type. Vermeiden Sie die Verwendung der Punktnotation mit SOAP 1.1-Fehlercodes.You should avoid using the dot notation with SOAP 1.1 fault codes. (Die WS-I Basic Profile rät auch die Verwendung der Punktnotation der Fault-Code ab.)(The WS-I Basic Profile also discourages the use of the fault code dot notation.)

public class FaultCode  
{  
    public FaultCode(string name);  
    public FaultCode(string name, FaultCode subCode);  
    public FaultCode(string name, string ns);  
    public FaultCode(string name, string ns, FaultCode subCode);  

    public bool IsPredefinedFault { get; }  
    public bool IsReceiverFault { get; }  
    public bool IsSenderFault { get; }  
    public string Name { get; }  
    public string Namespace { get; }  
    public FaultCode SubCode { get; }  

//  methods omitted  

}  

Die Reason-Eigenschaft entspricht env:Reason (oder faultString in SOAP 1.1), einer lesbaren Beschreibung der Fehlerbedingung analog zur Meldung einer Ausnahme.The Reason property corresponds to the env:Reason (or faultString in SOAP 1.1) a human-readable description of the error condition analogous to an exception’s message. In der FaultReason-Klasse (und SOAP env:Reason/faultString) ist eine Unterstützung mehrerer Übersetzungen für Globalisierungszwecke integriert.The FaultReason class (and SOAP env:Reason/faultString) has built-in support for having multiple translations in the interest of globalization.

public class FaultReason  
{  
    public FaultReason(FaultReasonText translation);  
    public FaultReason(IEnumerable<FaultReasonText> translations);  
    public FaultReason(string text);  

    public SynchronizedReadOnlyCollection<FaultReasonText> Translations   
    {   
       get;   
    }  

 }  

Der Inhalt des microservices für MessageFault mit verschiedenen Methoden, einschließlich der GetDetail <T > und GetReaderAtDetailContents().The fault detail contents are exposed on MessageFault using various methods including the GetDetail<T> and GetReaderAtDetailContents(). Das Fehlerdetail ist ein nicht transparentes Element zur Aufnahme zusätzlicher Fehlerdetails.The fault detail is an opaque element for carrying additional detail about the fault. Das ist nützlich, wenn Sie dem Fehler willkürlich strukturierte Details hinzufügen möchten.This is useful if there is some arbitrary structured detail that you want to carry with the fault.

Generieren von FehlernGenerating Faults

In diesem Abschnitt wird das Generieren eines Fehlers als Reaktion auf eine Fehlerbedingung erläutert, die in einem Kanal oder in einer von einem Kanal erstellten Nachrichteneigenschaft festgestellt wird.This section explains the process of generating a fault in response to an error condition detected in a channel or in a message property created by the channel. Ein typisches Beispiel ist die Rückgabe eines Fehlers als Antwort auf eine Anforderungsnachricht, die ungültige Daten enthält.A typical example is sending back a fault in response to a request message that contains invalid data.

Beim Generieren eines Fehlers sollte der benutzerdefinierte Kanal den Fehler nicht direkt senden, sondern eine Ausnahme auslösen, um es der übergeordneten Ebene zu überlassen, ob diese Ausnahme in einen Fehler konvertiert wird und wie der Fehler zu senden ist.When generating a fault, the custom channel should not send the fault directly, rather, it should throw an exception and let the layer above decide whether to convert that exception to a fault and how to send it. Als Hilfestellung bei dieser Konvertierung sollte der Kanal eine FaultConverter-Implementierung bereitstellen, die die vom benutzerdefinierten Kanal ausgelöste Ausnahme in den geeigneten Fehler konvertieren kann.To aid in this conversion, the channel should provide a FaultConverter implementation that can convert the exception thrown by the custom channel to the appropriate fault. FaultConverter wird folgendermaßen definiert:FaultConverter is defined as:

public class FaultConverter  
{  
    public static FaultConverter GetDefaultFaultConverter(  
                                   MessageVersion version);  
    protected abstract bool OnTryCreateFaultMessage(  
                                   Exception exception,   
                                   out Message message);  
    public bool TryCreateFaultMessage(  
                                   Exception exception,   
                                   out Message message);  
}  

Jeder Kanal, der benutzerdefinierte Fehler generiert, muss FaultConverter implementieren und nach einem Aufruf von GetProperty<FaultConverter> zurückgeben.Each channel that generates custom faults must implement FaultConverter and return it from a call to GetProperty<FaultConverter>. Die benutzerdefinierte OnTryCreateFaultMessage-Implementierung muss die Ausnahme in einen Fehler konvertieren oder an den FaultConverter des inneren Kanals delegieren.The custom OnTryCreateFaultMessage implementation must either convert the exception to a fault or delegate to the inner channel’s FaultConverter. Wenn der Kanal einen Transport wird er muss die Ausnahme konvertieren oder an des Encoders Delegieren FaultConverter oder den Standardwert FaultConverter in WCF bereitgestellt.If the channel is a transport it must either convert the exception or delegate to the encoder’s FaultConverter or the default FaultConverter provided in WCF . Der standardmäßige FaultConverter konvertiert Fehler entsprechend der in der WS-Adressierung und SOAP angegebenen Fehlermeldungen.The default FaultConverter converts errors corresponding to fault messages specified by WS-Addressing and SOAP. Im Folgenden sehen Sie ein Beispiel für eine OnTryCreateFaultMessage-Implementierung.Here is an example OnTryCreateFaultMessage implementation.

public override bool OnTryCreateFaultMessage(Exception exception,   
                                             out Message message)  
{  
    if (exception is ...)  
    {  
        message = ...;  
        return true;  
    }  

#if IMPLEMENTING_TRANSPORT_CHANNEL  
    FaultConverter encoderConverter =   
                    this.encoder.GetProperty<FaultConverter>();  
    if ((encoderConverter != null) &&               
        (encoderConverter.TryCreateFaultMessage(  
         exception, out message)))  
    {  
        return true;  
    }  

    FaultConverter defaultConverter =   
                   FaultConverter.GetDefaultFaultConverter(  
                   this.channel.messageVersion);  
    return defaultConverter.TryCreateFaultMessage(  
                   exception,   
                   out message);  
#else  
    FaultConverter inner =   
                   this.innerChannel.GetProperty<FaultConverter>();  
    if (inner != null)  
    {  
        return inner.TryCreateFaultMessage(exception, out message);  
    }  
    else  
    {  
        message = null;  
        return false;  
    }  
#endif  
}  

Eine Folge dieses Musters ist, dass die zwischen Schichten für Fehlerbedingungen ausgelösten Ausnahmen, die Fehler erfordern, genügend Informationen enthalten müssen, damit der entsprechende Fehlergenerator den richtigen Fehler erstellen kann.An implication of this pattern is that exceptions thrown between layers for error conditions that require faults must contain enough information for the corresponding fault generator to create the correct fault. Als Autor eines benutzerdefinierten Kanals definieren Sie möglicherweise Ausnahmetypen, die verschiedenen Fehlerbedingungen entsprechen, falls solche Ausnahmen nicht bereits vorhanden sind.As a custom channel author, you may define exception types that correspond to different fault conditions if such exceptions do not already exist. Beachten Sie, dass Ausnahmen, die Kanalschichten durchlaufen, eher die Fehlerbedingung statt der nicht transparenten Fehlerdaten übermitteln sollten.Note that exceptions traversing channel layers should communicate the error condition rather than opaque fault data.

FehlerkategorienFault Categories

Es gibt im Allgemeinen drei Kategorien von Fehlern:There are generally three categories of faults:

  1. Fehler, die den ganzen Stapel durchdringen.Faults that are pervasive throughout the entire stack. Diese Fehler können in jeder Schicht des Kanalstapels auftreten, z. B. InvalidCardinalityAddressingException.These faults could be encountered at any layer in the channel stack, for example InvalidCardinalityAddressingException.

  2. Fehler, die an jeder beliebigen Stelle über einer bestimmten Schicht im Stapel auftreten können. Hierzu gehören z. B. Fehler, die einen Transaktionsfluss oder Sicherheitsrollen betreffen.Faults that can be encountered anywhere above a certain layer in the stack for example some errors that pertain to a flowed transaction or to security roles.

  3. Fehler, die sich auf eine einzelne Schicht im Stapel beziehen. Hierzu zählen z. B. Fehler wie WS-RM-Sequenznummernfehler.Faults that are directed at a single layer in the stack, for example errors like WS-RM sequence number faults.

Kategorie 1.Category 1. Fehler sind im Allgemeinen WS-Adressierungs- und SOAP-Fehler.Faults are generally WS-Addressing and SOAP faults. Die Basis FaultConverter -Klasse bereitgestellten von WCF konvertiert Fehler, die entsprechend der in Fehlermeldungen gemäß WS-Adressierung und SOAP, sodass Sie keine Konvertierung dieser Ausnahmen behandeln selbst.The base FaultConverter class provided by WCF converts errors corresponding to fault messages specified by WS-Addressing and SOAP so you do not have to handle conversion of these exceptions yourself.

Kategorie 2.Category 2. Fehler treten auf, wenn der Nachricht von einer Schicht eine Eigenschaft hinzugefügt wird und diese Eigenschaft Nachrichteninformationen, die diese Schicht betreffen, nicht vollständig behandelt.Faults occur when a layer adds a property to the message that does not completely consume message information that pertains to that layer. Fehler werden möglicherweise später erkannt, wenn eine höhere Schicht von der Eigenschaft eine weitere Verarbeitung von Nachrichteninformationen verlangt.Errors may be detected later when a higher layer asks the message property to process message information further. Solche Kanäle sollten wie erwähnt GetProperty implementieren, um der höheren Schicht, die Rückgabe des richtigen Fehlers zu ermöglichen.Such channels should implement the GetProperty specified previously to enable the higher layer to send back the correct fault. TransactionMessageProperty ist hierfür ein Beispiel.An example of this is the TransactionMessageProperty. Diese Eigenschaft wird der Nachricht hinzugefügt, ohne dass alle Daten im Header vollständig überprüft werden (dadurch wird möglicherweise eine Verbindung mit dem Distributed Transaction Coordinator (DTC) hergestellt).This property is added to the message without fully validating all the data in the header (doing so may involve contacting the distributed transaction coordinator (DTC).

Kategorie 3.Category 3. Fehler werden nur von einer einzelnen Schicht im Prozessor generiert und gesendet.Faults are only generated and sent by a single layer in the processor. Deshalb sind alle Ausnahmen innerhalb der Schicht enthalten.Therefore all the exceptions are contained within the layer. Um die Einheitlichkeit zwischen den Kanälen zu verbessern und die Wartung zu erleichtern, sollte der benutzerdefinierte Kanal oben beschriebene Muster verwenden, um auch für interne Fehler Fehlermeldungen zu generieren.To improve consistency among channels and ease maintenance, your custom channel should use the pattern specified previously to generate fault messages even for internal faults.

Interpretieren empfangener FehlerInterpreting Received Faults

Dieser Abschnitt enthält Hinweise zum Generieren der richtigen Ausnahme beim Empfang einer Fehlermeldung.This section provides guidance for generating the appropriate exception when receiving a fault message. Die Entscheidungsstruktur zur Verarbeitung einer Meldung in den einzelnen Schichten eines Stapels lautet wie folgt:The decision tree for processing a message at every layer in the stack is as follows:

  1. Wenn die Meldung von der Schicht als ungültig angesehen wird, sollte deren Verarbeitung für ungültige Nachrichten erfolgen.If the layer considers the message to be invalid, the layer should do its ‘invalid message’ processing. Diese Verarbeitung hängt von der jeweiligen Schicht ab, kann jedoch das Verwerfen der Meldung, eine Ablaufverfolgung oder das Auslösen einer Ausnahme beinhalten, die in einen Fehler konvertiert wird.Such processing is specific to the layer but could include dropping the message, tracing, or throwing an exception that gets converted to a fault. Zu den Beispielen hierfür zählen, dass die Sicherheit eine nicht ordnungsgemäß gesicherte Nachricht erhält oder dass RM eine Nachricht mit einer falschen Sequenznummer empfängt.Examples include security receiving a message that is not secured properly, or RM receiving a message with a bad sequence number.

  2. Andernfalls sollte die Schicht die Fehlerbedingung behandeln, wenn die Meldung eine Fehlermeldung ist, die sich speziell auf die Schicht bezieht und die Meldung außerhalb der Schicht keine Bedeutung hat.Otherwise, if the message is a fault message that applies specifically to the layer, and the message is not meaningful outside the layer’s interaction, the layer should handle the error condition. Ein Beispiel hierfür ist ein Fehler aufgrund einer abgelehnten RM-Sequenz. Dieser Fehler ist für die Schichten über dem RM-Kanal bedeutungslos und impliziert, dass der RM-Kanal einen Fehler ausgibt und ausstehende Vorgänge eine Ausnahme auslösen.An example of this is an RM Sequence Refused fault that is meaningless to layers above the RM channel and that implies faulting the RM channel and throwing from pending operations.

  3. Andernfalls sollte die Meldung von Request() oder Receive() zurückgegeben werden.Otherwise, the message should be returned from Request() or Receive(). Dazu gehören Fälle, in denen die Schicht den Fehler erkennt, der Fehler jedoch nur angibt, dass eine Anforderung fehlgeschlagen ist. Dabei impliziert der Fehler nicht, dass der RM-Kanal einen Fehler ausgibt und ausstehende Vorgänge eine Ausnahme auslösen.This includes cases where the layer recognizes the fault, but the fault just indicates that a request failed and does not imply faulting the channel and throwing from pending operations. Um die Verwendbarkeit in einem solchen Fall zu verbessern, sollte die Schicht GetProperty<FaultConverter> implementieren und eine von FaultConverter abgeleitete Klasse zurückgeben, die den Fehler durch Außerkraftsetzen von OnTryCreateException konvertieren kann.To improve usability in such a case, the layer should implement GetProperty<FaultConverter> and return a FaultConverter derived class that can convert the fault to an exception by overriding OnTryCreateException.

Das folgende Objektmodell unterstützt das Konvertieren von Meldungen in Ausnahmen:The following object model supports converting messages to exceptions:

public class FaultConverter  
{  
    public static FaultConverter GetDefaultFaultConverter(  
                                  MessageVersion version);  
    protected abstract bool OnTryCreateException(  
                                 Message message,   
                                 MessageFault fault,   
                                 out Exception exception);  
    public bool TryCreateException(  
                                 Message message,   
                                 MessageFault fault,   
                                 out Exception exception);  
}  

Eine Kanalschicht kann GetProperty<FaultConverter> implementieren, um das Konvertieren von Fehlermeldungen in Ausnahmen zu unterstützen.A channel layer can implement GetProperty<FaultConverter> to support converting fault messages to exceptions. Setzen Sie dazu OnTryCreateException außer Kraft, und überprüfen Sie die Fehlermeldung.To do so, override OnTryCreateException and inspect the fault message. Wenn sie erkannt wird, führen Sie die Konvertierung aus, überlassen Sie andernfalls den Kanal die Konvertierung.If recognized, do the conversion, otherwise ask the inner channel to convert it. Transportkanäle sollten eine Delegierung an FaultConverter.GetDefaultFaultConverter ausführen, um den standardmäßigen FaultConverter der SOAP/WS-Adressierung abzurufen.Transport channels should delegate to FaultConverter.GetDefaultFaultConverter to get the default SOAP/WS-Addressing FaultConverter.

Eine typische Implementierung sieht folgendermaßen aus:A typical implementation looks like this:

public override bool OnTryCreateException(  
                            Message message,   
                            MessageFault fault,   
                            out Exception exception)  
{  
    if (message.Action == "...")  
    {  
        exception = ...;  
        return true;  
    }  
    // OR  
    if ((fault.Code.Name == "...") && (fault.Code.Namespace == "..."))  
    {  
        exception = ...;  
        return true;  
    }  

    if (fault.IsMustUnderstand)  
    {  
        if (fault.WasHeaderNotUnderstood(  
                   message.Headers, "...", "..."))  
        {  
            exception = new ProtocolException(...);  
            return true;  
        }  
    }  

#if IMPLEMENTING_TRANSPORT_CHANNEL  
    FaultConverter encoderConverter =   
              this.encoder.GetProperty<FaultConverter>();  
    if ((encoderConverter != null) &&   
        (encoderConverter.TryCreateException(  
                              message, fault, out exception)))  
    {  
        return true;  
    }  

    FaultConverter defaultConverter =  
             FaultConverter.GetDefaultFaultConverter(  
                             this.channel.messageVersion);  
    return defaultConverter.TryCreateException(  
                             message, fault, out exception);  
#else  
    FaultConverter inner =   
                    this.innerChannel.GetProperty<FaultConverter>();  
    if (inner != null)  
    {  
        return inner.TryCreateException(message, fault, out exception);  
    }  
    else  
    {  
        exception = null;  
        return false;  
    }  
#endif  
}  

Definieren Sie gegebenenfalls für spezielle Fehlerbedingungen mit besonderen Wiederherstellungszenarien eine abgeleitete Klasse von ProtocolException.For specific fault conditions that have distinct recovery scenarios, consider defining a derived class of ProtocolException.

Verarbeitung von MustUnderstandMustUnderstand Processing

SOAP definiert einen allgemeinen Fehler, wenn ein erforderlicher Header vom Empfänger nicht interpretiert werden konnte.SOAP defines a general fault for signaling that a required header was not understood by the receiver. Dieser Fehler wird mustUnderstand genannt.This fault is known as the mustUnderstand fault. In WCF generieren benutzerdefinierte Kanäle keine mustUnderstand Fehler.In WCF, custom channels never generate mustUnderstand faults. Stattdessen der WCF-Verteiler, das sich am oberen Rand der WCF-Kommunikationsstapel, überprüft, ob alle Header, die als MustUndestand markiert wurden = "true", die von der zugrunde liegenden Stapel verstanden wurden.Instead, the WCF Dispatcher, which is located at the top of the WCF communication stack, checks to see that all headers that were marked as MustUndestand=true were understood by the underlying stack. Sind Header dabei, die nicht interpretiert werden konnten, wird an dieser Stelle ein mustUnderstand-Fehler generiert.If any were not understood, a mustUnderstand fault is generated at that point. (Der Benutzer kann diese mustUnderstand-Verarbeitung deaktivieren und die Anwendung alle Nachrichtenheader empfangen lassen.(The user can choose to turn off this mustUnderstand processing and have the application receive all message headers. In diesem Fall wird die mustUnderstand-Verarbeitung der Anwendung überlassen. Der generierte Fehler schließt einen NotUnderstood-Header ein, der die Namen aller nicht interpretierten Header mit MustUnderstand=true enthält.In that case the application is responsible for performing mustUnderstand processing.) The generated fault includes a NotUnderstood header that contains the names of all headers with MustUnderstand=true that were not understood.

Wenn Ihr Protokollkanal einen benutzerdefinierten Header mit MustUnderstand=true sendet und einen mustUnderstand-Fehler empfängt, muss er überprüfen, ob dieser Fehler durch einen von ihm gesendeten Header verursacht wurde.If your protocol channel sends a custom header with MustUnderstand=true and receives a mustUnderstand fault, it must figure out whether that fault is due to the header it sent. Die MessageFault-Klasse besitzt zwei Member, die für diesen Zweck nützlich sind:There are two members on the MessageFault class that are useful for this:

public class MessageFault  
{  
    ...  
    public bool IsMustUnderstandFault { get; }  
    public static bool WasHeaderNotUnderstood(MessageHeaders headers,   
        string name, string ns) { }  
    ...  

}  

IsMustUnderstandFault gibt true zurück, wenn der Fehler ein mustUnderstand-Fehler ist.IsMustUnderstandFault returns true if the fault is a mustUnderstand fault. WasHeaderNotUnderstood gibt true zurück, wenn der Header mit dem angegebenen Namen und Namespace im Fehler als NotUnderstood-Header enthalten ist.WasHeaderNotUnderstood returns true if the header with the specified name and namespace is included in the fault as a NotUnderstood header. Andernfalls wird zurückgegeben false.Otherwise, it returns false.

Wenn dieser Kanal einen Header ausgibt, der mit MustUnderstand = true gekennzeichnet ist, sollte diese Schicht auch das Exception Generation API-Muster implementieren. Außerdem sollte sie mustUnderstand-Fehler, die durch diesen Fehler verursacht wurden, wie weiter oben beschrieben in eine nützlichere Ausnahme konvertieren.If a channel emits a header that is marked MustUnderstand = true, then that layer should also implement the Exception Generation API pattern and should convert mustUnderstand faults caused by that header to a more useful exception as described previously.

AblaufverfolgungTracing

.NET Framework stellt einen Mechanismus bereit, mit dem die Programmausführung verfolgt werden kann. Damit wird die Diagnose von Produktionsanwendungen oder von zeitweiligen Problemen unterstützt, bei denen es nicht möglich ist, einfach ein Debugger hinzuzufügen und den Code zu durchlaufen.The .NET Framework provides a mechanism to trace program execution as a way to aid diagnosing production applications or intermittent problems where it is not possible to just attach a debugger and step through the code. Die folgenden Kernkomponenten dieses Mechanismus befinden sich im System.Diagnostics-Namespace:The core components of this mechanism are in the System.Diagnostics namespace and consist of:

Behandeln von Ausnahmen und FehlernHandling exceptions and faults

Ablaufverfolgung durch einen benutzerdefinierten KanalTracing from a Custom Channel

Als Hilfestellung bei der Diagnose von Problemen, bei denen es nicht möglich ist, der laufenden Anwendung einen Debugger hinzuzufügen, sollten benutzerdefinierte Kanäle Ablaufverfolgungsmeldungen ausgeben.Custom channels should write out trace messages to assist in diagnosing problems when it is not possible to attach a debugger to the running application. Das schließt zwei komplexe Aufgaben ein: Instanziieren einer TraceSource und Aufrufen ihrer Methoden zu Schreiben von Ablaufverfolgungen.This involves two high level tasks: Instantiating a TraceSource and calling its methods to write traces.

Bei der Instanziierung einer TraceSource dient die von Ihnen angegebene Zeichenfolge als Name dieser Quelle.When instantiating a TraceSource, the string you specify becomes the name of that source. Mit diesem Namen wird die Ablaufverfolgungsquelle konfiguriert (Aktivieren/Deaktivieren/Festlegen der Ablaufverfolgungsebene).This name is used to configure (enable/disable/set tracing level) the trace source. Der Name wird außerdem direkt in der Ausgabe der Ablaufverfolgung angegeben.It also appears in the trace output itself. Benutzerdefinierte Kanäle sollten einen eindeutigen Quellennamen verwenden, damit Leser der Ablaufverfolgungsausgabe erkennen können, woher die Ablaufverfolgungsinformationen stammen.Custom channels should use a unique source name to help readers of the trace output understand where the trace information comes from. Im Allgemeinen wird als Name der Ablaufverfolgungsquelle der Name der Assembly verwendet, die diese Informationen schreibt.Using the name of the assembly that is writing the information as the name of the trace source is the common practice. WCF verwendet z. B. System.ServiceModel als Ablaufverfolgungsquelle für Informationen, die von der System.ServiceModel-Assembly geschrieben.For example, WCF uses System.ServiceModel as the trace source for information written from the System.ServiceModel assembly.

Sobald eine Ablaufverfolgungsquelle vorhanden ist, rufen Sie ihre Methoden TraceDataTraceEvent oder TraceInformation auf, um Ablaufverfolgungseinträge für den Ablaufverfolgungslistener zu schreiben.Once you have a trace source, you call its TraceData, TraceEvent, or TraceInformation methods to write trace entries to the trace listeners. Für jeden geschriebenen Ablaufverfolgungseintrag müssen Sie den Typ des Ereignisses als einen der in TraceEventType definierten Ereignistypen klassifizieren.For each trace entry you write, you need to classify the type of event as one of the event types defined in TraceEventType. Diese Klassifikation und die Einstellung der Ablaufverfolgungsebene in der Konfiguration bestimmen, ob der Ablaufverfolgungseintrag an den Listener ausgegeben wird.This classification and the trace level setting in configuration determine whether the trace entry is output to the listener. Wenn z. B. die Ablaufverfolgungsebene in der Konfiguration auf Warning festgelegt wird, können Warning- Error- und Critical-Ablaufverfolgungsereignisse geschrieben werden, Information- und Verbose-Einträge werden jedoch blockiert.For example, setting the trace level in configuration to Warning allows Warning, Error and Critical trace entries to be written but blocks Information and Verbose entries. Das folgende Beispiel veranschaulicht die Instanziierung einer Ablaufverfolgungsquelle und das Schreiben eines Eintrags auf Information-Ebene:Here is an example of instantiating a trace source and writing out an entry at Information level:

using System.Diagnostics;  
//...  
TraceSource udpSource=new TraceSource("Microsoft.Samples.Udp");  
//...  
udpsource.TraceInformation("UdpInputChannel received a message");  

Wichtig

Geben Sie unbedingt einen Namen für die Ablaufverfolgungsquellen an, der in Ihren benutzerdefinierten Kanal eindeutig ist, damit Leser der Ablaufverfolgungsausgabe erkennen können, woher die Ausgabe stammt.It is highly recommended that you specify a trace source name that is unique to your custom channel to help trace output readers understand where the output came from.

Integration des Ablaufverfolgungs-ViewersIntegrating with the Trace Viewer

Von Ihrem Channel generierte ablaufverfolgungen können in einem von lesbaren Format ausgegeben werden die Service Trace Viewer-Tool (SvcTraceViewer.exe) mit System.Diagnostics.XmlWriterTraceListener als der Ablaufverfolgungslistener.Traces generated by your channel can be output in a format readable by the Service Trace Viewer Tool (SvcTraceViewer.exe) by using System.Diagnostics.XmlWriterTraceListener as the trace listener. Allerdings ist das kein Schritt, den Sie als Kanalentwickler vornehmen müssen.This is not something you, as the channel developer, need to do. Dieser Ablaufverfolgungslistener muss eher vom Benutzer der Anwendung (oder demjenigen, der Anwendungsprobleme behandelt) in der Konfigurationsdatei der Anwendung konfiguriert werden.Rather, it is the application user (or the person troubleshooting the application) that needs to configure this trace listener in the application’s configuration file. Beispielsweise werden mit der folgenden Konfiguration Ablaufverfolgungsinformationen von System.ServiceModel und von Microsoft.Samples.Udp an die Datei TraceEventsFile.e2e ausgegeben:For example, the following configuration outputs trace information from both System.ServiceModel and Microsoft.Samples.Udp to the file named TraceEventsFile.e2e:

<configuration>  
  <system.diagnostics>  
    <sources>  
      <!-- configure System.ServiceModel trace source -->  
      <source name="System.ServiceModel" switchValue="Verbose"   
              propagateActivity="true">  
        <listeners>  
          <add name="e2e" />  
        </listeners>  
      </source>  
      <!-- configure Microsoft.Samples.Udp trace source -->  
      <source name="Microsoft.Samples.Udp" switchValue="Verbose" >  
        <listeners>  
          <add name="e2e" />  
        </listeners>  
      </source>  
    </sources>  
    <!--   
    Define a shared trace listener that outputs to TraceFile.e2e  
    The listener name is e2e   
    -->  
    <sharedListeners>  
      <add name="e2e" type="System.Diagnostics.XmlWriterTraceListener"  
        initializeData=".\TraceFile.e2e"/>  
    </sharedListeners>  
    <trace autoflush="true" />  
  </system.diagnostics>  
</configuration>  

Verfolgen strukturierter DatenTracing Structured Data

System.Diagnostics.TraceSource besitzt eine TraceData-Methode, die ein oder mehrere Objekte in den Ablaufverfolgungseintrag aufnimmt.System.Diagnostics.TraceSource has a TraceData method that takes one or more objects that are to be included in the trace entry. Im Allgemeinen wird die Object.ToString-Methode für jedes Objekt aufgerufen, und die resultierende Zeichenfolge wird als Teil des Ablaufverfolgungseintrags geschrieben.In general, the Object.ToString method is called on each object and the resulting string is written as part of the trace entry. Wenn mit System.Diagnostics.XmlWriterTraceListener Ablaufverfolgungen ausgegeben werden, können Sie System.Xml.XPath.IXPathNavigable als Datenobjekt an TraceData übergeben.When using System.Diagnostics.XmlWriterTraceListener to output traces, you can pass an System.Xml.XPath.IXPathNavigable as the data object to TraceData. Der resultierende Ablaufverfolgungseintrag schließt die von System.Xml.XPath.XPathNavigator bereitgestellten XML-Daten ein.The resulting trace entry includes the XML provided by the System.Xml.XPath.XPathNavigator. Der folgende Beispieleintrag enthält XML-Anwendungsdaten:Here is an example entry with XML application data:

<E2ETraceEvent xmlns="http://schemas.microsoft.com/2004/06/E2ETraceEvent">  
  <System xmlns="...">  
    <EventID>12</EventID>  
    <Type>3</Type>  
    <SubType Name="Information">0</SubType>  
    <Level>8</Level>  
    <TimeCreated SystemTime="2006-01-13T22:58:03.0654832Z" />  
    <Source Name="Microsoft.ServiceModel.Samples.Udp" />  
    <Correlation ActivityID="{00000000-0000-0000-0000-000000000000}" />  
    <Execution  ProcessName="UdpTestConsole"   
                ProcessID="3348" ThreadID="4" />  
    <Channel />  
    <Computer>COMPUTER-LT01</Computer>  
  </System>  
<!-- XML application data -->  
  <ApplicationData>  
  <TraceData>  
   <DataItem>  
   <TraceRecord   
     Severity="Information"  
     xmlns="…">  
        <TraceIdentifier>some trace id</TraceIdentifier>  
        <Description>EndReceive called</Description>  
        <AppDomain>UdpTestConsole.exe</AppDomain>  
        <Source>UdpInputChannel</Source>  
      </TraceRecord>  
    </DataItem>  
  </TraceData>  
  </ApplicationData>  
</E2ETraceEvent>  

WCF Trace Viewer erkennt das Schema des der TraceRecord zuvor dargestellte-Element und extrahiert die Daten aus der untergeordneten Elemente und zeigt ihn in einem tabellarischen Format.The WCF trace viewer understands the schema of the TraceRecord element shown previously and extracts the data from its child elements and displays it in a tabular format. Ihr Kanal sollte beim Verfolgen strukturierter Anwendungsdaten dieses Schema verwenden, damit Benutzer von Svctraceviewer.exe die Daten lesen können.Your channel should use this schema when tracing structured application data to help Svctraceviewer.exe users read the data.