Freigeben über


AmbiguousMatchException Konstruktoren

Definition

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse.

Überlädt

AmbiguousMatchException()

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse mit einer leeren Meldungszeichenfolge und einer auf null festgelegten ursächlichen Ausnahme.

AmbiguousMatchException(String)

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse mit einer auf die angegebene Meldung festgelegten Meldungszeichenfolge und einer auf null festgelegten ursächlichen Ausnahme.

AmbiguousMatchException(String, Exception)

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

AmbiguousMatchException()

Quelle:
AmbiguousMatchException.cs
Quelle:
AmbiguousMatchException.cs
Quelle:
AmbiguousMatchException.cs

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse mit einer leeren Meldungszeichenfolge und einer auf null festgelegten ursächlichen Ausnahme.

public:
 AmbiguousMatchException();
public AmbiguousMatchException ();
Public Sub New ()

Hinweise

AmbiguousMatchException erbt von Exception. Dieser Konstruktor legt die Eigenschaften des Exception Objekts fest, wie in der folgenden Tabelle gezeigt.

Eigenschaft Wert
InnerException null
Message Die leere Zeichenfolge ("").

Weitere Informationen

Gilt für:

AmbiguousMatchException(String)

Quelle:
AmbiguousMatchException.cs
Quelle:
AmbiguousMatchException.cs
Quelle:
AmbiguousMatchException.cs

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse mit einer auf die angegebene Meldung festgelegten Meldungszeichenfolge und einer auf null festgelegten ursächlichen Ausnahme.

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)

Parameter

message
String

Eine Zeichenfolge, die die Ursache für das Auslösen dieser Ausnahme angibt.

Hinweise

AmbiguousMatchException erbt von Exception. Dieser Konstruktor legt die Eigenschaften des Exception Objekts fest, wie in der folgenden Tabelle gezeigt.

Eigenschaft Wert
InnerException null
Message Die message Zeichenfolge.

Gilt für:

AmbiguousMatchException(String, Exception)

Quelle:
AmbiguousMatchException.cs
Quelle:
AmbiguousMatchException.cs
Quelle:
AmbiguousMatchException.cs

Initialisiert eine neue Instanz der AmbiguousMatchException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

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)

Parameter

message
String

Die Fehlermeldung, in der die Ursache der Ausnahme erklärt wird.

inner
Exception

Die Ausnahme, die die Ursache der aktuellen Ausnahme ist. Wenn der inner-Parameter nicht null ist, wird die aktuelle Ausnahme in einem catch-Block ausgelöst, der die innere Ausnahme behandelt.

Beispiele

Das folgende Beispiel zeigt zwei Methoden, jede mit dem Namen Mymethod. Eine Methode akzeptiert eine ganze Zahl und die andere eine Zeichenfolge. Wenn eine ganze Zahl an Mymethodübergeben wird, wird die erste Methode verwendet. Wenn eine Zeichenfolge übergeben wird, wird die zweite Methode verwendet. Wenn nicht bestimmt werden kann, welche Mymethod verwendet werden soll, AmbiguousMatchException wird ausgelöst.

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.

Hinweise

Eine Ausnahme, die als direktes Ergebnis einer vorhergehenden Ausnahme ausgelöst wird, muss in der InnerException-Eigenschaft über einen Verweis auf die vorhergehende Ausnahme verfügen. Die InnerException-Eigenschaft gibt den gleichen Wert zurück, der an den Konstruktor übergeben wird, oder null, wenn die InnerException-Eigenschaft den Wert der inneren Ausnahme nicht an den Konstruktor übergibt.

In der folgenden Tabelle werden die anfänglichen Eigenschaftenwerte für eine AmbiguousMatchException-Instanz aufgeführt.

Eigenschaft Wert
InnerException Der Verweis auf die interne Ausnahme.
Message Die Zeichenfolge der Fehlermeldung.

Weitere Informationen

Gilt für: