AmbiguousMatchException Konstruktory

Definice

Obor názvů:

System.Reflection

Sestavení:

System.Runtime.dll

Inicializuje novou instanci AmbiguousMatchException třídy .

Přetížení

AmbiguousMatchException()	Inicializuje novou instanci AmbiguousMatchException třídy s prázdným řetězcem zprávy a původní příčinou nastavenou výjimkou na nullhodnotu .
AmbiguousMatchException(String)	Inicializuje novou instanci AmbiguousMatchException třídy s jejím řetězcem zprávy nastaveným na danou zprávu a původní příčinou výjimky nastavenou na null.
AmbiguousMatchException(String, Exception)	Inicializuje novou instanci AmbiguousMatchException třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.

AmbiguousMatchException()

Zdroj:

AmbiguousMatchException.cs

Inicializuje novou instanci AmbiguousMatchException třídy s prázdným řetězcem zprávy a původní příčinou nastavenou výjimkou na nullhodnotu .

public:
 AmbiguousMatchException();

public AmbiguousMatchException ();

Public Sub New ()

Poznámky

AmbiguousMatchException dědí z Exception. Tento konstruktor nastavuje vlastnosti objektu Exception , jak je znázorněno v následující tabulce.

Vlastnost	Hodnota
InnerException	null
Message	Prázdný řetězec ("").

Viz také

• Exception
• SystemException

AmbiguousMatchException(String)

Zdroj:

AmbiguousMatchException.cs

Inicializuje novou instanci AmbiguousMatchException třídy s jejím řetězcem zprávy nastaveným na danou zprávu a původní příčinou výjimky nastavenou na null.

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

public AmbiguousMatchException (string? message);

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

Public Sub New (message As String)

Parametry

message

String

Řetězec označující důvod, proč byla tato výjimka vyvolán.

Poznámky

AmbiguousMatchException dědí z Exception. Tento konstruktor nastavuje vlastnosti objektu Exception , jak je znázorněno v následující tabulce.

Vlastnost	Hodnota
InnerException	null
Message	Řetězec message .

AmbiguousMatchException(String, Exception)

Zdroj:

AmbiguousMatchException.cs

Inicializuje novou instanci AmbiguousMatchException třídy se zadanou chybovou zprávou a odkazem na vnitřní výjimku, která je příčinou této výjimky.

public:
 AmbiguousMatchException(System::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

Chybová zpráva, která vysvětluje důvod výjimky.

inner

Exception

Výjimka, která je příčinou aktuální výjimky inner Pokud parametr není null, aktuální výjimka je vyvolána v catch bloku, který zpracovává vnitřní výjimku.

Příklady

Následující příklad ukazuje dvě metody, každou s názvem Mymethod. Jedna metoda přebírá celé číslo a druhá řetězec. Pokud je celé číslo předáno do Mymethod, použije se první metoda. Pokud se předá řetězec, použije se druhá metoda. Pokud nelze určit, který Mymethod použít, AmbiguousMatchException je vyvolán.

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.

Poznámky

Výjimka, která je vyvolána jako přímý výsledek předchozí výjimky by měla obsahovat odkaz na předchozí výjimku ve vlastnosti InnerException. Vlastnost InnerException vrací stejnou hodnotu, která je předána do konstruktoru, nebo hodnotu null, pokud vlastnost InnerException neposkytne hodnotu vnitřní výjimky konstruktoru.

Následující tabulka ukazuje počáteční hodnoty vlastnosti instance AmbiguousMatchException.

Vlastnost	Hodnota
InnerException	Odkaz na vnitřní výjimku.
Message	Řetězec chybové zprávy.

Viz také

• Exception
• Zpracování a vyvolávání výjimek v .NET