[Serializable] |
For a list of initial property values for an instance of DllNotFoundException, see the DllNotFoundException.#ctor constructors.
| 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 DllNotFoundException class with default properties. |
| ctor #2 | Overloaded:.ctor(string message) Initializes a new instance of the DllNotFoundException class with a specified error message. |
| ctor #4 | Overloaded:.ctor(string message, Exception inner) Initializes a new instance of the DllNotFoundException 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.TypeLoadException) |
Read-only See base class member description: System.TypeLoadException.Message Gets the error message for this 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. |
| TypeName (inherited from System.TypeLoadException) |
Read-only See base class member description: System.TypeLoadException.TypeName Gets the fully qualified name of the type that causes the 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.TypeLoadException) |
See base class member description: System.TypeLoadException.GetObjectData Sets the SerializationInfo object with the class name, method name, resource ID, and additional exception information. |
| 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. |
| ctor #3 | Overloaded:.ctor(SerializationInfo info, StreamingContext context) Initializes a new instance of the DllNotFoundException class with serialized data. |
| 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 DllNotFoundException(); |
| Property | Value |
|---|---|
| Exception.InnerException | null . |
| TypeLoadException.Message | The localized error message string. |
public DllNotFoundException( |
message
| Property | Value |
|---|---|
| Exception.InnerException | null . |
| TypeLoadException.Message | The error message string. |
protected DllNotFoundException( |
info
context
message
inner
The following table shows the initial property values for an instance of DllNotFoundException.
| Property | Value |
|---|---|
| Exception.InnerException | The inner exception reference. |
| TypeLoadException.Message | The error message string. |
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 override string Message {get;}
|
This proerty is read-only.
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;}
|
public string TypeName {get;}
|
Assembly myAssembly = Assembly.Load("mscorlib");
try
{
Console.WriteLine("This program throws an exception upon successful run.");
// Attempt to load a non-existent type from an assembly.
Type myType = myAssembly.GetType("System.NonExistentType", true);
}
catch (TypeLoadException e)
{
// Display the name of the Type that was not found.
Console.WriteLine ("TypeLoadException: \n\tError loading the type '{0}' from the assembly 'mscorlib'", e.TypeName);
Console.WriteLine ("\tError Message = " + e.Message);
}
catch (Exception e)
{
Console.WriteLine ("Exception: Error Message = " + e.Message);
}
~DllNotFoundException(); |
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 override void GetObjectData( |
info
context
| Exception Type | Condition |
|---|---|
| ArgumentNullException | The info object is null. |
For more information, see the conceptual topic at MSDN: serialization.
using System;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
using System.IO;
class GetObjectDataDemo : Attribute
{
public static void Main()
{
// Load the mscorlib assembly and get a reference to it.
Assembly myAssembly = Assembly.Load("mscorlib");
try
{
Console.WriteLine ("Attempting to load a type not present in the assembly 'mscorlib'");
// This loading of invalid type raises a TypeLoadException
Type myType = myAssembly.GetType("System.NonExistentType", true);
}
catch (TypeLoadException)
{
// Serialize the exception to disk and reconstitute it back again.
try
{
System.DateTime ErrorDatetime = DateTime.Now;
Console.WriteLine("A TypeLoadException has been raised.");
// Create MyTypeLoadException instance with current time.
MyTypeLoadExceptionChild myTypeLoadExceptionChild = new MyTypeLoadExceptionChild(ErrorDatetime);
IFormatter myFormatter = new SoapFormatter();
Stream myFileStream = new FileStream("typeload.xml", FileMode.Create, FileAccess.Write, FileShare.None);
Console.WriteLine("Serializing the TypeLoadException with DateTime as " + ErrorDatetime);
// Serialize the MyTypeLoadException instance to a file.
myFormatter.Serialize(myFileStream, myTypeLoadExceptionChild);
myFileStream.Close();
Console.WriteLine("Deserializing the Exception.");
myFileStream = new FileStream("typeload.xml", FileMode.Open, FileAccess.Read, FileShare.None);
// Deserialize and reconstitute the instance from file.
myTypeLoadExceptionChild = (MyTypeLoadExceptionChild) myFormatter.Deserialize(myFileStream);
myFileStream.Close();
Console.WriteLine("Deserialized exception has ErrorDateTime = " + myTypeLoadExceptionChild.ErrorDateTime);
}
catch (Exception e)
{
Console.WriteLine ("Exception :" + e.Message);
}
}
catch(Exception e)
{
Console.WriteLine("Exception : " + e.Message);
}
}
}
// This class overrides the GetObjectData method and initializes
// its data with current time.
[Serializable]
public class MyTypeLoadExceptionChild : TypeLoadException
{
public System.DateTime ErrorDateTime = DateTime.Now;
public MyTypeLoadExceptionChild(DateTime myDateTime)
{
ErrorDateTime = myDateTime;
}
protected MyTypeLoadExceptionChild(SerializationInfo sInfo, StreamingContext sContext)
{
// Reconstitute the deserialized information into the instance.
ErrorDateTime=sInfo.GetDateTime("ErrorDate");
}
public override void GetObjectData(SerializationInfo sInfo, StreamingContext sContext)
{
// Add a value to the Serialization information.
sInfo.AddValue("ErrorDate",ErrorDateTime);
}
}
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()