DiscoveryExceptionDictionary Classe

Définition

Collecte les exceptions qui se sont produites pendant la découverte des services web XML.Collects exceptions that occurred during XML Web services discovery. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class DiscoveryExceptionDictionary sealed : System::Collections::DictionaryBase
public sealed class DiscoveryExceptionDictionary : System.Collections.DictionaryBase
type DiscoveryExceptionDictionary = class
    inherit DictionaryBase
Public NotInheritable Class DiscoveryExceptionDictionary
Inherits DictionaryBase
Héritage
DiscoveryExceptionDictionary

Exemples

#using <System.Xml.dll>
#using <System.Web.Services.dll>
#using <System.dll>

using namespace System;
using namespace System::Web::Services::Discovery;
using namespace System::Xml;
using namespace System::Collections;
using namespace System::Runtime::Remoting;
using namespace System::Net;

int main()
{
   String^ myDiscoFile = "http://localhost/MathService_cs.disco";
   String^ myUrlKey = "http://localhost/MathService_cs.asmx?wsdl";
   DiscoveryClientProtocol^ myDiscoveryClientProtocol1 = gcnew DiscoveryClientProtocol;
   DiscoveryDocument^ myDiscoveryDocument = myDiscoveryClientProtocol1->Discover( myDiscoFile );
   IEnumerator^ myEnumerator = myDiscoveryDocument->References->GetEnumerator();
   while ( myEnumerator->MoveNext() )
   {
      ContractReference^ myContractReference = dynamic_cast<ContractReference^>(myEnumerator->Current);
      DiscoveryClientProtocol^ myDiscoveryClientProtocol2 = myContractReference->ClientProtocol;
      myDiscoveryClientProtocol2->ResolveAll();
      
      DiscoveryExceptionDictionary^ myExceptionDictionary = myDiscoveryClientProtocol2->Errors;
      if ( myExceptionDictionary->Contains( myUrlKey ) == true )
      {
         Console::WriteLine( "'myExceptionDictionary' contains a discovery exception for the key '{0}'", myUrlKey );
      }
      else
      {
         Console::WriteLine( "'myExceptionDictionary' does not contain a discovery exception for the key '{0}'", myUrlKey );
      }
      if ( myExceptionDictionary->Contains( myUrlKey ) == true )
      {
         Console::WriteLine( "System generated exceptions." );
         
         Exception^ myException = myExceptionDictionary[ myUrlKey ];
         Console::WriteLine( " Source : {0}", myException->Source );
         Console::WriteLine( " Exception : {0}", myException->Message );

         Console::WriteLine();
         
         // Remove the discovery exception.for the key 'myUrlKey'.
         myExceptionDictionary->Remove( myUrlKey );

         DiscoveryExceptionDictionary^ myNewExceptionDictionary = gcnew DiscoveryExceptionDictionary;
         
         // Add an exception with the custom error message.
         Exception^ myNewException = gcnew Exception( "The requested service is not available." );
         myNewExceptionDictionary->Add( myUrlKey, myNewException );
         myExceptionDictionary = myNewExceptionDictionary;

         Console::WriteLine( "Added exceptions." );
         
         array<Object^>^myArray = gcnew array<Object^>(myExceptionDictionary->Count);
         myExceptionDictionary->Keys->CopyTo( (Array^)myArray, 0 );
         Console::WriteLine( " Keys are :" );

         for each(Object^ myObj in myArray)
         {
            Console::WriteLine(" " + myObj->ToString());
         }

         Console::WriteLine();
         
         array<Object^>^myCollectionArray = gcnew array<Object^>(myExceptionDictionary->Count);
         myExceptionDictionary->Values->CopyTo( (Array^)myCollectionArray, 0 );
         Console::WriteLine( " Values are :" );
         for each(Object^ myObj in myCollectionArray)
         {
            Console::WriteLine(" " + myObj->ToString());
         }
      }
   }
}
using System;
using System.Web.Services.Discovery;
using System.Xml;
using System.Collections;
using System.Runtime.Remoting;
using System.Net;

public class MySample
{
   static void Main()
   {
      string myDiscoFile = "http://localhost/MathService_cs.disco";
      string myUrlKey = "http://localhost/MathService_cs.asmx?wsdl";
      DiscoveryClientProtocol myDiscoveryClientProtocol1 = 
                                            new DiscoveryClientProtocol();
      DiscoveryDocument myDiscoveryDocument = 
                         myDiscoveryClientProtocol1.Discover(myDiscoFile);
      IEnumerator myEnumerator = 
                           myDiscoveryDocument.References.GetEnumerator();
      while ( myEnumerator.MoveNext() )
      {
         ContractReference myContractReference =
                                  (ContractReference)myEnumerator.Current;
         DiscoveryClientProtocol myDiscoveryClientProtocol2 = 
                                       myContractReference.ClientProtocol;
         myDiscoveryClientProtocol2.ResolveAll();
         DiscoveryExceptionDictionary myExceptionDictionary 
                                      = myDiscoveryClientProtocol2.Errors;
         if ( myExceptionDictionary.Contains(myUrlKey) == true )
         {
            Console.WriteLine("'myExceptionDictionary' contains " +
                      " a discovery exception for the key '" + myUrlKey + "'");
         }
         else
         {
            Console.WriteLine("'myExceptionDictionary' does not contain" +
                      " a discovery exception for the key '" + myUrlKey + "'");
         }
         if (myExceptionDictionary.Contains(myUrlKey) == true )
         {
            Console.WriteLine("System generated exceptions.");

            Exception myException = myExceptionDictionary[myUrlKey];
            Console.WriteLine(" Source : " + myException.Source);
            Console.WriteLine(" Exception : " + myException.Message);

            Console.WriteLine();

            // Remove the discovery exception.for the key 'myUrlKey'.
            myExceptionDictionary.Remove(myUrlKey);

            DiscoveryExceptionDictionary myNewExceptionDictionary =
                                       new DiscoveryExceptionDictionary();
            // Add an exception with the custom error message.
            Exception myNewException = 
                 new Exception("The requested service is not available.");
            myNewExceptionDictionary.Add(myUrlKey, myNewException);
            myExceptionDictionary = myNewExceptionDictionary;

            Console.WriteLine("Added exceptions.");

            object[] myArray = new object[myExceptionDictionary.Count];
            myExceptionDictionary.Keys.CopyTo((Array)myArray,0);
            Console.WriteLine(" Keys are :");
            foreach(object myObj in myArray)
            {
               Console.WriteLine(" " + myObj.ToString());
            }

            Console.WriteLine();

            object[] myCollectionArray = new object[myExceptionDictionary.Count];
            myExceptionDictionary.Values.CopyTo((Array)myCollectionArray,0);
            Console.WriteLine(" Values are :");
            foreach(object myObj in myCollectionArray)
            {
               Console.WriteLine(" " + myObj.ToString());
            }
         }
      }
   }
}
Imports System.Web.Services.Discovery
Imports System.Xml
Imports System.Collections
Imports System.Runtime.Remoting
Imports System.Net

Public Class MySample
   
   Shared Sub Main()
      Dim myDiscoFile As String = "http://localhost/MathService_vb.disco"
      Dim myUrlKey As String = "http://localhost/MathService_vb.asmx?wsdl"
      Dim myDiscoveryClientProtocol1 As New DiscoveryClientProtocol()
      Dim myDiscoveryDocument As DiscoveryDocument = myDiscoveryClientProtocol1.Discover(myDiscoFile)
      Dim myEnumerator As IEnumerator = myDiscoveryDocument.References.GetEnumerator()
      While myEnumerator.MoveNext()
         Dim myContractReference As ContractReference = CType(myEnumerator.Current, ContractReference)
         Dim myDiscoveryClientProtocol2 As DiscoveryClientProtocol = myContractReference.ClientProtocol
         myDiscoveryClientProtocol2.ResolveAll()
         Dim myExceptionDictionary As DiscoveryExceptionDictionary = myDiscoveryClientProtocol2.Errors
         If myExceptionDictionary.Contains(myUrlKey) = True Then
            Console.WriteLine("'myExceptionDictionary' contains " + _
                 "a discovery exception for the key '" + myUrlKey + "'")
         Else
            Console.WriteLine("'myExceptionDictionary' does not contain" + _
                 " a discovery exception for the key '" + myUrlKey + "'")
         End If
         If myExceptionDictionary.Contains(myUrlKey) = True Then
            Console.WriteLine("System generated exceptions.")
            
            Dim myException As Exception = myExceptionDictionary(myUrlKey)
            Console.WriteLine(" Source : " + myException.Source)
            Console.WriteLine(" Exception : " + myException.Message)
            Console.WriteLine()
            
            ' Remove the discovery exception.for the key 'myUrlKey'.
            myExceptionDictionary.Remove(myUrlKey)
            Dim myNewExceptionDictionary As New DiscoveryExceptionDictionary()
            ' Add an exception with the custom error message.
            Dim myNewException As New Exception("The requested service is not available.")
            myNewExceptionDictionary.Add(myUrlKey, myNewException)
            myExceptionDictionary = myNewExceptionDictionary
            Console.WriteLine("Added exceptions.")
            
            Dim myArray(myExceptionDictionary.Count -1 ) As Object
            myExceptionDictionary.Keys.CopyTo(CType(myArray, Array), 0)
            Console.WriteLine(" Keys are :")
            Dim myObj As Object
            For Each myObj In  myArray
               Console.WriteLine(" " + myObj.ToString())
            Next myObj
            Console.WriteLine()
            
            Dim myCollectionArray(myExceptionDictionary.Count -1 ) As Object
            myExceptionDictionary.Values.CopyTo(CType(myCollectionArray, Array), 0)
            Console.WriteLine(" Values are :")
            For Each myObj In  myCollectionArray
               Console.WriteLine(" " + myObj.ToString())
            Next myObj
         End If 
      End While
   End Sub
End Class

Remarques

La Errors propriété de DiscoveryClientProtocol est de type DiscoveryExceptionDictionary.The Errors property of DiscoveryClientProtocol is of type DiscoveryExceptionDictionary.

Constructeurs

DiscoveryExceptionDictionary()

Initialise une nouvelle instance de la classe DiscoveryExceptionDictionary.Initializes a new instance of the DiscoveryExceptionDictionary class.

Propriétés

Count

Obtient le nombre d'éléments contenus dans l'instance de DictionaryBase.Gets the number of elements contained in the DictionaryBase instance.

(Hérité de DictionaryBase)
Dictionary

Obtient la liste des éléments contenus dans l'instance de DictionaryBase.Gets the list of elements contained in the DictionaryBase instance.

(Hérité de DictionaryBase)
InnerHashtable

Obtient la liste des éléments contenus dans l'instance de DictionaryBase.Gets the list of elements contained in the DictionaryBase instance.

(Hérité de DictionaryBase)
Item[String]

Obtient ou définit Exception qui s'est produit pendant la découverte de l'URL spécifiée à partir de DiscoveryExceptionDictionary.Gets or sets the Exception that occurred while discovering the specified URL from the DiscoveryExceptionDictionary.

Keys

Obtient un objet ICollection dont toutes les clés sont dans DiscoveryExceptionDictionary.Gets a ICollection object with all the keys in the DiscoveryExceptionDictionary.

Values

Obtient un objet ICollection contenant toutes les valeurs de DiscoveryExceptionDictionary.Gets a ICollection object containing all the values in the DiscoveryExceptionDictionary.

Méthodes

Add(String, Exception)

Ajoute Exception avec la clé url à DiscoveryExceptionDictionary.Adds an Exception with a key of url to the DiscoveryExceptionDictionary.

Clear()

Efface le contenu de l'instance DictionaryBase.Clears the contents of the DictionaryBase instance.

(Hérité de DictionaryBase)
Contains(String)

Détermine si DiscoveryExceptionDictionary contient Exception avec l'URL spécifiée.Determines whether the DiscoveryExceptionDictionary contains an Exception with the specified URL.

CopyTo(Array, Int32)

Copie les entrées des éléments DictionaryBase dans un Array à une dimension à l'index spécifié.Copies the DictionaryBase elements to a one-dimensional Array at the specified index.

(Hérité de DictionaryBase)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetEnumerator()

Retourne IDictionaryEnumerator qui itère au sein de l'instance de DictionaryBase.Returns an IDictionaryEnumerator that iterates through the DictionaryBase instance.

(Hérité de DictionaryBase)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
OnClear()

Effectue des traitements personnalisés supplémentaires avant l'effacement du contenu de l'instance de DictionaryBase.Performs additional custom processes before clearing the contents of the DictionaryBase instance.

(Hérité de DictionaryBase)
OnClearComplete()

Exécute des processus personnalisés supplémentaires après l'effacement du contenu de l'instance de DictionaryBase.Performs additional custom processes after clearing the contents of the DictionaryBase instance.

(Hérité de DictionaryBase)
OnGet(Object, Object)

Obtient l'élément correspondant à la clé et la valeur spécifiées dans l'instance de DictionaryBase.Gets the element with the specified key and value in the DictionaryBase instance.

(Hérité de DictionaryBase)
OnInsert(Object, Object)

Exécute les processus personnalisés supplémentaires avant l'insertion d'un nouvel élément dans l'instance de DictionaryBase.Performs additional custom processes before inserting a new element into the DictionaryBase instance.

(Hérité de DictionaryBase)
OnInsertComplete(Object, Object)

Exécute les processus personnalisés supplémentaires après l'insertion d'un nouvel élément dans l'instance de DictionaryBase.Performs additional custom processes after inserting a new element into the DictionaryBase instance.

(Hérité de DictionaryBase)
OnRemove(Object, Object)

Effectue des traitements personnalisés supplémentaires avant la suppression d'un élément de l'instance de DictionaryBase.Performs additional custom processes before removing an element from the DictionaryBase instance.

(Hérité de DictionaryBase)
OnRemoveComplete(Object, Object)

Exécute des processus personnalisés supplémentaires après la suppression d'un élément de l'instance de DictionaryBase.Performs additional custom processes after removing an element from the DictionaryBase instance.

(Hérité de DictionaryBase)
OnSet(Object, Object, Object)

Exécute des processus personnalisés supplémentaires avant la définition d'une valeur dans l'instance de DictionaryBase.Performs additional custom processes before setting a value in the DictionaryBase instance.

(Hérité de DictionaryBase)
OnSetComplete(Object, Object, Object)

Exécute des processus personnalisés supplémentaires après la définition d'une valeur dans l'instance de DictionaryBase.Performs additional custom processes after setting a value in the DictionaryBase instance.

(Hérité de DictionaryBase)
OnValidate(Object, Object)

Effectue des traitements personnalisés supplémentaires lors de la validation de l'élément correspondant à la clé et la valeur spécifiées.Performs additional custom processes when validating the element with the specified key and value.

(Hérité de DictionaryBase)
Remove(String)

Supprime Exception de DiscoveryExceptionDictionary avec l'URLspécifiée.Removes an Exception with the specified URL from the DiscoveryExceptionDictionary.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)

Implémentations d’interfaces explicites

ICollection.IsSynchronized

Obtient une valeur indiquant si l'accès à un objet DictionaryBase est synchronisé (thread-safe).Gets a value indicating whether access to a DictionaryBase object is synchronized (thread safe).

(Hérité de DictionaryBase)
ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à un objet DictionaryBase.Gets an object that can be used to synchronize access to a DictionaryBase object.

(Hérité de DictionaryBase)
IDictionary.Add(Object, Object)

Ajoute un élément avec la clé et la valeur spécifiées dans DictionaryBase.Adds an element with the specified key and value into the DictionaryBase.

(Hérité de DictionaryBase)
IDictionary.Contains(Object)

Détermine si DictionaryBase contient une clé spécifique.Determines whether the DictionaryBase contains a specific key.

(Hérité de DictionaryBase)
IDictionary.IsFixedSize

Obtient une valeur indiquant si un objet DictionaryBase est de taille fixe.Gets a value indicating whether a DictionaryBase object has a fixed size.

(Hérité de DictionaryBase)
IDictionary.IsReadOnly

Obtient une valeur indiquant si un objet DictionaryBase est en lecture seule.Gets a value indicating whether a DictionaryBase object is read-only.

(Hérité de DictionaryBase)
IDictionary.Item[Object]

Obtient ou définit la valeur associée à la clé spécifiée.Gets or sets the value associated with the specified key.

(Hérité de DictionaryBase)
IDictionary.Keys

Obtient un objet ICollection contenant les clés de l'objet DictionaryBase.Gets an ICollection object containing the keys in the DictionaryBase object.

(Hérité de DictionaryBase)
IDictionary.Remove(Object)

Supprime de DictionaryBase l'élément ayant la clé spécifiée.Removes the element with the specified key from the DictionaryBase.

(Hérité de DictionaryBase)
IDictionary.Values

Obtient un objet ICollection contenant les valeurs de l'objet DictionaryBase.Gets an ICollection object containing the values in the DictionaryBase object.

(Hérité de DictionaryBase)
IEnumerable.GetEnumerator()

Retourne un IEnumerator qui itère au sein de DictionaryBase.Returns an IEnumerator that iterates through the DictionaryBase.

(Hérité de DictionaryBase)

Méthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Voir aussi