DiscoveryExceptionDictionary Classe

Definição

Namespace:

System.Web.Services.Discovery

Assembly:

System.Web.Services.dll

Coleta as exceções que ocorreram durante a descoberta de serviços Web em XML. Essa classe não pode ser herdada.

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

Herança

Object

DictionaryBase

DiscoveryExceptionDictionary

Exemplos

#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

Comentários

A Errors propriedade é DiscoveryClientProtocol do tipo DiscoveryExceptionDictionary.

Construtores

DiscoveryExceptionDictionary()

Inicializa uma nova instância da classe DiscoveryExceptionDictionary.

Propriedades

Count	Obtém o número de elementos contidos na instância de DictionaryBase. (Herdado de DictionaryBase)
Dictionary	Obtém a lista de elementos contidos na instância DictionaryBase. (Herdado de DictionaryBase)
InnerHashtable	Obtém a lista de elementos contidos na instância DictionaryBase. (Herdado de DictionaryBase)
Item[String]	Obtém ou define o Exception que ocorreu ao descobrir a URL especificada do DiscoveryExceptionDictionary.
Keys	Obtém um objeto ICollection com todas as chaves na DiscoveryExceptionDictionary.
Values	Obtém um objeto ICollection que contém todos os valores no DiscoveryExceptionDictionary.

Métodos

Add(String, Exception)	Adiciona uma Exception com uma chave de url à DiscoveryExceptionDictionary.
Clear()	Limpa o conteúdo da instância DictionaryBase. (Herdado de DictionaryBase)
Contains(String)	Determina se o DiscoveryExceptionDictionary atual contém um Exception com a URL especificada.
CopyTo(Array, Int32)	Copia os elementos DictionaryBase para um objeto Array unidimensional no índice especificado. (Herdado de DictionaryBase)
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetEnumerator()	Retorna um IDictionaryEnumerator que itera pela instância de DictionaryBase. (Herdado de DictionaryBase)
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetType()	Obtém o Type da instância atual. (Herdado de Object)
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
OnClear()	Executa processos adicionais personalizados antes de limpar o conteúdo da instância de DictionaryBase. (Herdado de DictionaryBase)
OnClearComplete()	Executa processos adicionais personalizados após limpar o conteúdo da instância DictionaryBase. (Herdado de DictionaryBase)
OnGet(Object, Object)	Obtém o elemento com a chave e o valor especificados à instância de DictionaryBase. (Herdado de DictionaryBase)
OnInsert(Object, Object)	Executa os processos personalizados adicionais antes de inserir um novo elemento na instância DictionaryBase. (Herdado de DictionaryBase)
OnInsertComplete(Object, Object)	Executa processos personalizados adicionais após inserir um novo elemento na instância de DictionaryBase. (Herdado de DictionaryBase)
OnRemove(Object, Object)	Executa processos personalizados adicionais antes de remover um elemento da instância de DictionaryBase. (Herdado de DictionaryBase)
OnRemoveComplete(Object, Object)	Executa processos personalizados adicionais após remover um elemento da instância de DictionaryBase. (Herdado de DictionaryBase)
OnSet(Object, Object, Object)	Executa processos personalizados adicionais antes de definir um valor na instância DictionaryBase. (Herdado de DictionaryBase)
OnSetComplete(Object, Object, Object)	Executa processos personalizados adicionais após configurar um valor na instância de DictionaryBase. (Herdado de DictionaryBase)
OnValidate(Object, Object)	Executa processos personalizados adicionais ao validar o elemento com a chave e o valor especificados. (Herdado de DictionaryBase)
Remove(String)	Remove uma Exception com a URL especificada do DiscoveryExceptionDictionary.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Implantações explícitas de interface

ICollection.IsSynchronized	Obtém um valor que indica se o acesso a um objeto DictionaryBase é sincronizado (thread-safe). (Herdado de DictionaryBase)
ICollection.SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso a um objeto DictionaryBase. (Herdado de DictionaryBase)
IDictionary.Add(Object, Object)	Adiciona um elemento com a chave e o valor especificados ao DictionaryBase. (Herdado de DictionaryBase)
IDictionary.Contains(Object)	Determina se a DictionaryBase contém uma chave específica. (Herdado de DictionaryBase)
IDictionary.IsFixedSize	Obtém um valor que indica se o objeto DictionaryBase tem um tamanho fixo. (Herdado de DictionaryBase)
IDictionary.IsReadOnly	Obtém um valor que indica se um objeto DictionaryBase é somente leitura. (Herdado de DictionaryBase)
IDictionary.Item[Object]	Obtém ou define o valor associado à chave especificada. (Herdado de DictionaryBase)
IDictionary.Keys	Obtém um objeto ICollection que contém as chaves no objeto DictionaryBase. (Herdado de DictionaryBase)
IDictionary.Remove(Object)	Remove o elemento com a chave especificada do DictionaryBase. (Herdado de DictionaryBase)
IDictionary.Values	Obtém um objeto ICollection que contém os valores no objeto DictionaryBase. (Herdado de DictionaryBase)
IEnumerable.GetEnumerator()	Retorna um IEnumerator que itera pelo DictionaryBase. (Herdado de DictionaryBase)

Métodos de Extensão

Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.

Confira também

• Errors
• DiscoveryClientProtocol
• IDictionary
• DictionaryBase