DiscoveryExceptionDictionary Klasse

Referenz

Definition

Namespace:: System.Web.Services.Discovery

Assembly:: System.Web.Services.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Erfasst Ausnahmen, die während der XML-Webdienstsuche aufgetreten sind. Diese Klasse kann nicht vererbt werden.

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

Vererbung: Object

DictionaryBase
DiscoveryExceptionDictionary

Beispiele

#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

Hinweise

Die Errors Eigenschaft von DiscoveryClientProtocol ist vom Typ DiscoveryExceptionDictionary.

Konstruktoren

DiscoveryExceptionDictionary()

Initialisiert eine neue Instanz der DiscoveryExceptionDictionary-Klasse.

Eigenschaften

Count	Ruft die Anzahl der in der DictionaryBase-Instanz enthaltenen Elemente ab. (Geerbt von DictionaryBase)
Dictionary	Ruft die Liste der in der DictionaryBase-Instanz enthaltenen Elemente ab. (Geerbt von DictionaryBase)
InnerHashtable	Ruft die Liste der in der DictionaryBase-Instanz enthaltenen Elemente ab. (Geerbt von DictionaryBase)
Item[String]	Ruft die Exception ab, die beim Ermitteln der angegebenen URL aus dem DiscoveryExceptionDictionary aufgetreten ist, oder legt diese fest.
Keys	Ruft ein ICollection-Objekt mit allen Schlüsseln aus der DiscoveryExceptionDictionary ab.
Values	Ruft ein ICollection-Objekt mit allen Werten aus dem DiscoveryExceptionDictionary ab.

Methoden

Add(String, Exception)	Fügt dem Exception eine DiscoveryExceptionDictionary mit einem Schlüssel von `url` hinzu.
Clear()	Löscht den Inhalt der DictionaryBase-Instanz. (Geerbt von DictionaryBase)
Contains(String)	Bestimmt, ob das DiscoveryExceptionDictionary eine Exception mit der angegebenen URL enthält.
CopyTo(Array, Int32)	Kopiert die DictionaryBase-Elemente am angegebenen Index in ein eindimensionales Array. (Geerbt von DictionaryBase)
Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetEnumerator()	Gibt einen IDictionaryEnumerator zurück, der die DictionaryBase-Instanz durchläuft. (Geerbt von DictionaryBase)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnClear()	Führt vor dem Löschen des Inhalts der DictionaryBase-Instanz zusätzliche benutzerdefinierte Prozesse aus. (Geerbt von DictionaryBase)
OnClearComplete()	Führt nach dem Löschen des Inhalts der DictionaryBase-Instanz zusätzliche benutzerdefinierte Prozesse aus. (Geerbt von DictionaryBase)
OnGet(Object, Object)	Ruft das Element mit dem angegebenen Schlüssel und Wert aus der DictionaryBase-Instanz ab. (Geerbt von DictionaryBase)
OnInsert(Object, Object)	Führt zusätzliche benutzerdefinierte Prozesse vor dem Einfügen eines neuen Elements in die DictionaryBase-Instanz aus. (Geerbt von DictionaryBase)
OnInsertComplete(Object, Object)	Führt zusätzliche benutzerdefinierte Prozesse nach dem Einfügen eines neuen Elements in die DictionaryBase-Instanz aus. (Geerbt von DictionaryBase)
OnRemove(Object, Object)	Führt zusätzliche benutzerdefinierte Prozesse vor dem Entfernen eines Elements aus der DictionaryBase-Instanz aus. (Geerbt von DictionaryBase)
OnRemoveComplete(Object, Object)	Führt zusätzliche benutzerdefinierte Prozesse nach dem Entfernen eines Elements aus der DictionaryBase-Instanz aus. (Geerbt von DictionaryBase)
OnSet(Object, Object, Object)	Führt zusätzliche benutzerdefinierte Prozesse vor dem Festlegen eines Werts in der DictionaryBase-Instanz aus. (Geerbt von DictionaryBase)
OnSetComplete(Object, Object, Object)	Führt zusätzliche benutzerdefinierte Prozesse nach dem Festlegen eines Werts in der DictionaryBase-Instanz aus. (Geerbt von DictionaryBase)
OnValidate(Object, Object)	Führt bei der Überprüfung des Elements mit dem angegebenen Schlüssel und Wert zusätzliche benutzerdefinierte Aktionen aus. (Geerbt von DictionaryBase)
Remove(String)	Entfernt eine Exception mit der angegebenen URL aus dem DiscoveryExceptionDictionary.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

ICollection.IsSynchronized	Ruft einen Wert ab, der angibt, ob der Zugriff auf ein DictionaryBase-Objekt synchronisiert (threadsicher) ist. (Geerbt von DictionaryBase)
ICollection.SyncRoot	Ruft ein Objekt ab, mit dem der Zugriff auf ein DictionaryBase-Objekt synchronisiert werden kann. (Geerbt von DictionaryBase)
IDictionary.Add(Object, Object)	Fügt dem DictionaryBase ein Element mit dem angegebenen Schlüssel und Wert hinzu. (Geerbt von DictionaryBase)
IDictionary.Contains(Object)	Stellt fest, ob der DictionaryBase einen bestimmten Schlüssel enthält. (Geerbt von DictionaryBase)
IDictionary.IsFixedSize	Ruft einen Wert ab, der angibt, ob ein DictionaryBase-Objekt eine feste Größe hat. (Geerbt von DictionaryBase)
IDictionary.IsReadOnly	Ruft einen Wert ab, der angibt, ob ein DictionaryBase-Objekt schreibgeschützt ist. (Geerbt von DictionaryBase)
IDictionary.Item[Object]	Ruft den Wert ab, der dem angegebenen Schlüssel zugeordnet ist, oder legt diesen fest. (Geerbt von DictionaryBase)
IDictionary.Keys	Ruft ein ICollection-Objekt ab, das die Schlüssel im DictionaryBase-Objekt enthält. (Geerbt von DictionaryBase)
IDictionary.Remove(Object)	Entfernt das Element mit dem angegebenen Schlüssel aus dem DictionaryBase. (Geerbt von DictionaryBase)
IDictionary.Values	Ruft ein ICollection-Objekt ab, das die Werte des DictionaryBase-Objekts enthält. (Geerbt von DictionaryBase)
IEnumerable.GetEnumerator()	Gibt einen IEnumerator zurück, der DictionaryBase durchläuft. (Geerbt von DictionaryBase)

Erweiterungsmethoden

Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um
OfType<TResult>(IEnumerable)	Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs
AsParallel(IEnumerable)	Ermöglicht die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Konvertiert einen IEnumerable in einen IQueryable.

Gilt für: