AmbiguousMatchException Konstruktor

Definisi

Ruang nama:

System.Reflection

Rakitan:

System.Runtime.dll

Menginisialisasi instans baru kelas AmbiguousMatchException.

Overload

AmbiguousMatchException()	Menginisialisasi instans AmbiguousMatchException baru kelas dengan string pesan kosong dan pengecualian akar penyebab diatur ke null.
AmbiguousMatchException(String)	Menginisialisasi instans AmbiguousMatchException baru kelas dengan string pesannya diatur ke pesan yang diberikan dan pengecualian akar penyebab diatur ke null.
AmbiguousMatchException(String, Exception)	Menginisialisasi instans AmbiguousMatchException baru kelas dengan pesan kesalahan yang ditentukan dan referensi ke pengecualian dalam yang merupakan penyebab pengecualian ini.

AmbiguousMatchException()

Sumber:

AmbiguousMatchException.cs

Menginisialisasi instans AmbiguousMatchException baru kelas dengan string pesan kosong dan pengecualian akar penyebab diatur ke null.

public:
 AmbiguousMatchException();

public AmbiguousMatchException ();

Public Sub New ()

Keterangan

AmbiguousMatchException mewarisi dari Exception. Konstruktor ini mengatur properti objek seperti yang Exception diperlihatkan dalam tabel berikut.

Properti	Nilai
InnerException	null
Message	String kosong ("").

Lihat juga

• Exception
• SystemException

AmbiguousMatchException(String)

Sumber:

AmbiguousMatchException.cs

Menginisialisasi instans AmbiguousMatchException baru kelas dengan string pesannya diatur ke pesan yang diberikan dan pengecualian akar penyebab diatur ke null.

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

public AmbiguousMatchException (string? message);

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

Public Sub New (message As String)

Parameter

message

String

String yang menunjukkan alasan pengecualian ini dilemparkan.

Keterangan

AmbiguousMatchException mewarisi dari Exception. Konstruktor ini mengatur properti objek seperti yang Exception diperlihatkan dalam tabel berikut.

Properti	Nilai
InnerException	null
Message	String message .

AmbiguousMatchException(String, Exception)

Sumber:

AmbiguousMatchException.cs

Menginisialisasi instans AmbiguousMatchException baru kelas dengan pesan kesalahan yang ditentukan dan referensi ke pengecualian dalam yang merupakan penyebab pengecualian ini.

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)

Parameter

message

String

Pesan kesalahan yang menjelaskan alasan pengecualian.

inner

Exception

Pengecualian yang merupakan penyebab pengecualian saat ini. inner Jika parameter bukan null, pengecualian saat ini dimunculkan dalam catch blok yang menangani pengecualian dalam.

Contoh

Contoh berikut menunjukkan dua metode, masing-masing bernama Mymethod. Satu metode mengambil bilangan bulat dan yang lain mengambil string. Jika bilangan bulat diteruskan ke Mymethod, metode pertama digunakan. Jika string diteruskan, metode kedua akan digunakan. Jika tidak dapat ditentukan mana yang Mymethod akan digunakan, AmbiguousMatchException akan dilemparkan.

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.

Keterangan

Pengecualian yang dilemparkan sebagai hasil langsung dari pengecualian sebelumnya harus menyertakan referensi ke pengecualian sebelumnya dalam InnerException properti . Properti InnerException mengembalikan nilai yang sama yang diteruskan ke konstruktor, atau null jika InnerException properti tidak menyediakan nilai pengecualian dalam ke konstruktor.

Tabel berikut ini memperlihatkan nilai properti awal untuk instans AmbiguousMatchException.

Properti	Nilai
InnerException	Referensi pengecualian dalam.
Message	String pesan kesalahan.

Lihat juga

• Exception
• Menangani dan menampilkan pengecualian di .NET