[Serializable] |
An AmbiguousMatchException is thrown if the application calls upon a class and it cannot determine which class or overloaded class to utilize. The binding attempts to locate the proper class to use, determined by the number of parameters and the type of parameters. If no acceptable class can be determined, AmbiguousMatchException is thrown.
Overload resolution is a mechanism for selecting the best function member to invoke given an argument list and a set of candidate function members. Overload resolution selects the function member to invoke. If a selection cannot be determined, an AmbiguousMatchException is thrown.
| ctor #1 | Overloaded:.ctor()Default constructor. This constructor is called by derived class constructors to initialize state in this type.Initializes a new instance of the AmbiguousMatchException class with an empty message string and the root cause exception set to null. |
| ctor #2 | Overloaded:.ctor(string message) Initializes a new instance of the AmbiguousMatchException class with its message string set to the given message and the root cause exception set to null. |
| ctor #3 | Overloaded:.ctor(string message, Exception inner) Initializes a new instance of the AmbiguousMatchException class with a specified error message and a reference to the inner exception that is the cause of this exception. |
| HelpLink (inherited from System.Exception) |
Read-write See base class member description: System.Exception.HelpLink Gets or sets a link to the help file associated with this exception. |
| InnerException (inherited from System.Exception) |
Read-only See base class member description: System.Exception.InnerException Gets the Exception instance that caused the current exception. |
| Message (inherited from System.Exception) |
Read-only See base class member description: System.Exception.Message Gets a message that describes the current exception. |
| Source (inherited from System.Exception) |
Read-write See base class member description: System.Exception.Source Gets or sets the name of the application or the object that causes the error. |
| StackTrace (inherited from System.Exception) |
Read-only See base class member description: System.Exception.StackTrace Gets a string representation of the frames on the call stack at the time the current exception was thrown. |
| TargetSite (inherited from System.Exception) |
Read-only See base class member description: System.Exception.TargetSite Gets the method that throws the current exception. |
| Equals (inherited from System.Object) |
See base class member description: System.Object.Equals Derived from System.Object, the primary base class for all objects. |
| GetBaseException (inherited from System.Exception) |
See base class member description: System.Exception.GetBaseException When overridden in a derived class, returns the Exception that is the root cause of one or more subsequent exceptions. |
| GetHashCode (inherited from System.Object) |
See base class member description: System.Object.GetHashCode Derived from System.Object, the primary base class for all objects. |
| GetObjectData (inherited from System.Exception) |
See base class member description: System.Exception.GetObjectData When overridden in a derived class, sets the SerializationInfo with information about the exception. |
| GetType (inherited from System.Object) |
See base class member description: System.Object.GetType Derived from System.Object, the primary base class for all objects. |
| ToString (inherited from System.Exception) |
See base class member description: System.Exception.ToString Creates and returns a string representation of the current exception. |
| HResult (inherited from System.Exception) |
Read-write See base class member description: System.Exception.HResult Gets or sets HRESULT, a coded numerical value that is assigned to a specific exception. |
| Finalize (inherited from System.Object) |
See base class member description: System.Object.Finalize Derived from System.Object, the primary base class for all objects. |
| MemberwiseClone (inherited from System.Object) |
See base class member description: System.Object.MemberwiseClone Derived from System.Object, the primary base class for all objects. |
Hierarchy:
public AmbiguousMatchException(); |
| Property | Value |
|---|---|
| Exception.InnerException | null |
| Exception.Message | The empty string (""). |
public AmbiguousMatchException( |
message
| Property | Value |
|---|---|
| Exception.InnerException | null |
| Exception.Message | The string. |
message
inner
The following table shows the initial property values for an instance of AmbiguousMatchException.
| Property | Value |
|---|---|
| Exception.InnerException | The inner exception reference. |
| Exception.Message | The error message string. |
Mymethod
. One class takes an integer and the other takes a string. If an integer is passed to
Mymethod
, the first class is used. If a string is passed, the second class is used. If it cannot be determined which
Mymethod
to use, AmbiguousMatchException is thrown.
class Myambiguous {
//The first overload is typed to an Int32
public static void Mymethod (Int32 number){
Console.Write("\n{0}", "I am from Int32 method");
}
//The second overload is typed to a string
public static void Mymethod (string alpha) {
Console.Write("\n{0}", "I am from a string.");
}
public 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("Myambiguous");
MethodInfo Mymethodinfo32 = Mytype.GetMethod("Mymethod", new Type[]{typeof(Int32)});
MethodInfo Mymethodinfostr = Mytype.GetMethod("Mymethod", new Type[]{typeof(System.String)});
//Invoke a method, utilizing a Int32 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(System.Reflection.AmbiguousMatchException theException) {
Console.Write("\nAmbiguousMatchException message - {0}", theException.Message);
}
catch {
Console.Write("\nError thrown");
}
return;
}
}
//This code produces the following output:
//I am from Int32 method
//I am from a string.
//I am from Int32 method
//I am from a string.
//AmbiguousMatchException message - Ambiguous match found.
public virtual string HelpLink {get; set;}
|
"file:///C:/Applications/Bazzal/help.html#ErrorNum42"
protected int HResult {get; set;}
|
public Exception InnerException {get;}
|
Use the InnerException property to obtain the set of exceptions that led to the current exception.
You can create a new exception that catches an earlier exception. The code that handles the second exception can make use of the additional information from the earlier exception to handle the error more appropriately.
Suppose that there is a function that reads a file and formats the data from that file. In this example, as the code tries to read the file, an IOException is thrown. The function catches the IOException and throws a FileNotFoundException. The IOException could be saved in the Exception.InnerException property of the FileNotFoundException, enabling the code that catches the FileNotFoundException to examine what causes the initial error.
The Exception.InnerException property, which holds a reference to the inner exception, is set upon initialization of the exception object.
using System;
public class MyAppException:ApplicationException
{
public MyAppException (String message) : base (message)
{}
public MyAppException (String message, Exception inner) : base(message,inner) {}
}
public class ExceptExample
{
public void ThrowInner ()
{
throw new MyAppException("ExceptExample inner exception");
}
public void CatchInner()
{
try
{
this.ThrowInner();
}
catch (Exception e)
{
throw new MyAppException("Error caused by trying ThrowInner.",e);
}
}
}
public class Test
{
public static void Main()
{
ExceptExample testInstance = new ExceptExample();
try
{
testInstance.CatchInner();
}
catch(Exception e)
{
Console.WriteLine ("In Main catch block. Caught: {0}", e.Message);
Console.WriteLine ("Inner Exception is {0}",e.InnerException);
}
}
}
This code has the following output:
In Main
catch block. Caught: Error caused by trying ThrowInner. Inner Exception is
MyAppException: ExceptExample inner exception at ExceptExample.ThrowInner() at
ExceptExample.CatchInner()
public virtual string Message {get;}
|
The Message property is set only when creating an Exception. If no message was supplied to the constructor for the current instance, the system supplies a default message that is formatted using the current system culture.
The error message should be localized.
public virtual string Source {get; set;}
|
public virtual string StackTrace {get;}
|
StackTrace may not report as many method calls as expected, due to code transformations, such as inlining, that occur during optimization.
By default, the stack trace is captured immediately before an exception object is thrown. Use Environment.StackTrace to get stack trace information when no exception is being thrown.
public MethodBase TargetSite {get;}
|
~AmbiguousMatchException(); |
public virtual Exception GetBaseException(); |
For all exceptions in a chain of exceptions, the GetBaseException method must return the same object (the base exception).
Use the GetBaseException method when you want to find the root cause of an exception but do not need information about exceptions that may have occurred between the current exception and the first exception.
public virtual int GetHashCode(); |
public virtual void GetObjectData( |
info
context
| Exception Type | Condition |
|---|---|
| ArgumentNullException | The info parameter is a null reference (not set or empty). |
public Type GetType(); |
protected object MemberwiseClone(); |
public override string ToString(); |
The default implementation of Exception.ToString obtains the name of the class that threw the current exception, the message, the result of calling ToString on the inner exception, and the result of calling Environment.StackTrace. If any of these members is a null reference (not set or empty), its value is not included in the returned string.
If there is no error message or if it is an empty string (""), then no error message is returned. The name of the inner exception and the stack trace are returned only if they are not a null reference.
This method overrides Object.ToString.
using System;
public class MyClass {}
public class ArgExceptionExample
{
public static void Main()
{
MyClass my = new MyClass();
string s = "sometext";
try
{
int i = s.CompareTo(my);
}
catch (Exception e)
{
Console.WriteLine("Error: {0}",e.ToString());
}
}
}
This code has the following output:
Error:
System.ArgumentException: Object must be of type String. at
System.String.CompareTo(Object value) at ArgExceptionExample.Main()