AmbiguousMatchException Konstruktory

Definicja

Przestrzeń nazw:

System.Reflection

Zestaw:

System.Reflection.dll

Zestaw:

System.Runtime.dll

Zestaw:

mscorlib.dll

Zestaw:

netstandard.dll

Inicjuje nowe wystąpienie klasy AmbiguousMatchException.

Przeciążenia

AmbiguousMatchException()	Inicjuje nowe wystąpienie AmbiguousMatchException klasy z pustym ciągiem komunikatu i główną przyczyną wyjątku ustawionego na null.
AmbiguousMatchException(String)	Inicjuje AmbiguousMatchException nowe wystąpienie klasy z ciągiem komunikatu ustawionym na daną wiadomość i główną przyczyną wyjątku ustawionego na nullwartość .
AmbiguousMatchException(String, Exception)	Inicjuje nowe wystąpienie AmbiguousMatchException klasy z określonym komunikatem o błędzie i odwołaniem do wewnętrznego wyjątku, który jest przyczyną tego wyjątku.

AmbiguousMatchException()

Inicjuje nowe wystąpienie AmbiguousMatchException klasy z pustym ciągiem komunikatu i główną przyczyną wyjątku ustawionego na null.

public:
 AmbiguousMatchException();

public AmbiguousMatchException ();

Public Sub New ()

Uwagi

AmbiguousMatchException dziedziczy z Exceptionelementu . Ten konstruktor ustawia właściwości Exception obiektu, jak pokazano w poniższej tabeli.

Właściwość	Wartość
InnerException	null
Message	Pusty ciąg ("").

Zobacz też

• Exception
• SystemException

AmbiguousMatchException(String)

Inicjuje AmbiguousMatchException nowe wystąpienie klasy z ciągiem komunikatu ustawionym na daną wiadomość i główną przyczyną wyjątku ustawionego na nullwartość .

public:
 AmbiguousMatchException(System::String ^ message);

public AmbiguousMatchException (string message);

public AmbiguousMatchException (string? message);

new System.Reflection.AmbiguousMatchException : string -> System.Reflection.AmbiguousMatchException

Public Sub New (message As String)

Parametry

message

String

Ciąg wskazujący przyczynę, dla którego został zgłoszony ten wyjątek.

Uwagi

AmbiguousMatchException dziedziczy z Exceptionelementu . Ten konstruktor ustawia właściwości Exception obiektu, jak pokazano w poniższej tabeli.

Właściwość	Wartość
InnerException	null
Message	Ciąg message .

AmbiguousMatchException(String, Exception)

Inicjuje nowe wystąpienie AmbiguousMatchException klasy z określonym komunikatem o błędzie i odwołaniem do wewnętrznego wyjątku, który jest przyczyną tego wyjątku.

public:
 AmbiguousMatchException(System::String ^ message, Exception ^ inner);

public AmbiguousMatchException (string message, Exception inner);

public AmbiguousMatchException (string? message, Exception? inner);

new System.Reflection.AmbiguousMatchException : string * Exception -> System.Reflection.AmbiguousMatchException

Public Sub New (message As String, inner As Exception)

Parametry

message

String

Komunikat o błędzie wyjaśniający przyczynę wyjątku.

inner

Exception

Wyjątek będący przyczyną bieżącego wyjątku. inner Jeśli parametr nie nulljest , bieżący wyjątek jest zgłaszany w catch bloku, który obsługuje wyjątek wewnętrzny.

Przykłady

W poniższym przykładzie przedstawiono dwie metody o nazwie Mymethod. Jedna metoda przyjmuje liczbę całkowitą, a druga przyjmuje ciąg. Jeśli liczba całkowita zostanie przekazana do Mymethodmetody , zostanie użyta pierwsza metoda. Jeśli ciąg zostanie przekazany, zostanie użyta druga metoda. Jeśli nie można określić, który Mymethod z nich ma być używany, AmbiguousMatchException jest zgłaszany.

using namespace System;
using namespace System::Reflection;

namespace Ambiguity
{
    ref class Myambiguous
    {
    public:

        //The first overload is typed to an Int32
        static void Mymethod(Int32 number)
        {
            Console::WriteLine("I am from 'Int32' method");
        }

        //The second overload is typed to a String^
        static void Mymethod(String^ alpha)
        {
            Console::WriteLine("I am from 'String^' method.");
        }

        static void Main()
        {
            try
            {
                //The following does not cause as exception
                Mymethod(2);    // goes to Mymethod (Int32)
                Mymethod("3");  // goes to Mymethod (String*)
                Type^ Mytype = Type::GetType("Ambiguity.Myambiguous");
                array<Type^>^temp0 = {Int32::typeid};
                MethodInfo^ Mymethodinfo32 = Mytype->GetMethod("Mymethod", temp0);
                array<Type^>^temp1 = {System::String::typeid};
                MethodInfo^ Mymethodinfostr = Mytype->GetMethod("Mymethod", temp1);

                //Invoke a method, utilizing a Int32 integer
                array<Object^>^temp2 = {2};
                Mymethodinfo32->Invoke(nullptr, temp2);

                //Invoke the method utilizing a String^
                array<Object^>^temp3 = {"1"};
                Mymethodinfostr->Invoke(nullptr, temp3);

                //The following line causes an ambiguous exception
                MethodInfo^ Mymethodinfo = Mytype->GetMethod("Mymethod");
            }
            catch (AmbiguousMatchException^ ex)
            {
                Console::WriteLine("\n{0}\n{1}", ex->GetType()->FullName, ex->Message);
            }
            catch (...)
            {
                Console::WriteLine("\nSome other exception.");
            }

            return;
        }
    };
}

int main()
{
    Ambiguity::Myambiguous::Main();
}

//This code produces the following output:
//
// I am from 'Int32' method
// I am from 'String^' method.
// I am from 'Int32' method
// I am from 'String^' method.
//
// System.Reflection.AmbiguousMatchException
// Ambiguous match found.

using System;
using System.Reflection;

namespace Ambiguity
{
    class Myambiguous
    {
        //The first overload is typed to an int
        public static void Mymethod(int number)
        {
           Console.WriteLine("I am from 'int' method");
        }

        //The second overload is typed to a string
        public static void Mymethod(string alpha)
        {
            Console.WriteLine("I am from 'string' method.");
        }

        public static void Main()
        {
            try
            {
                //The following does not cause as exception
                Mymethod(2);    // goes to Mymethod(int)
                Mymethod("3");  // goes to Mymethod(string)

                Type Mytype = Type.GetType("Ambiguity.Myambiguous");

                MethodInfo Mymethodinfo32 = Mytype.GetMethod("Mymethod", new Type[]{typeof(int)});
                MethodInfo Mymethodinfostr = Mytype.GetMethod("Mymethod", new Type[]{typeof(System.String)});

                //Invoke a method, utilizing a int integer
                Mymethodinfo32.Invoke(null, new Object[]{2});

                //Invoke the method utilizing a string
                Mymethodinfostr.Invoke(null, new Object[]{"1"});

                //The following line causes an ambiguious exception
                MethodInfo Mymethodinfo = Mytype.GetMethod("Mymethod");
            }   // end of try block
            catch (AmbiguousMatchException ex)
            {
                Console.WriteLine("\n{0}\n{1}", ex.GetType().FullName, ex.Message);
            }
            catch
            {
                Console.WriteLine("\nSome other exception.");
            }
            return;
        }
    }
}

//This code produces the following output:
//
// I am from 'int' method
// I am from 'string' method.
// I am from 'int' method
// I am from 'string' method.

// System.Reflection.AmbiguousMatchException
// Ambiguous match found.

Imports System.Reflection

Namespace Ambiguity
    Class Myambiguous

        'The first overload is typed to an Int32
        Overloads Public Shared Sub Mymethod(number As Int32)
            Console.WriteLine("I am from 'Int32' method")
        End Sub

        'The second overload is typed to a string
        Overloads Public Shared Sub Mymethod(alpha As String)
            Console.WriteLine("I am from 'string' method.")
        End Sub

        Public Shared Sub Main()
            Try
                'The following does not cause as exception
                Mymethod(2) ' goes to Mymethod Int32)
                Mymethod("3") ' goes to Mymethod(string)
                Dim Mytype As Type = Type.GetType("Ambiguity.Myambiguous")

                Dim Mymethodinfo32 As MethodInfo = Mytype.GetMethod("Mymethod", New Type() {GetType(Int32)})
                Dim Mymethodinfostr As MethodInfo = Mytype.GetMethod("Mymethod", New Type() {GetType(System.String)})

                'Invoke a method, utilizing a Int32 integer
                Mymethodinfo32.Invoke(Nothing, New Object() {2})

                'Invoke the method utilizing a string
                Mymethodinfostr.Invoke(Nothing, New Object() {"1"})

                'The following line causes an ambiguious exception
                Dim Mymethodinfo As MethodInfo = Mytype.GetMethod("Mymethod")
                ' end of try block
            Catch ex As AmbiguousMatchException
                Console.WriteLine(Environment.NewLine + "{0}" + Environment.NewLine + "{1}", ex.GetType().FullName, ex.Message)
            Catch
                Console.WriteLine(Environment.NewLine + "Some other exception.")
            End Try
            Return
        End Sub
    End Class
End Namespace
' This code produces the following output:
'
' I am from 'Int32' method
' I am from 'string' method.
' I am from 'Int32' method
' I am from 'string' method.
'
' System.Reflection.AmbiguousMatchException
' Ambiguous match found.

Uwagi

Wyjątek zgłaszany bezpośrednio w wyniku poprzedniego wyjątku powinien zawierać odwołanie do poprzedniego wyjątku we właściwości InnerException. Właściwość InnerException zwraca tę samą wartość, która została przekazana do konstruktora, lub wartość null, jeśli właściwość InnerException nie przekazuje do konstruktora wartości wyjątku wewnętrznego.

Poniższa tabela prezentuje początkowe wartości właściwości dla wystąpienia klasy AmbiguousMatchException.

Właściwość	Wartość
InnerException	Odwołanie do wewnętrznego wyjątku.
Message	Ciąg komunikatu o błędzie.

Zobacz też

• Exception
• Obsługa i zgłaszanie wyjątków na platformie .NET