Is there any way in C# (i.e. in .NET) to throw a custom exception but without writing all the code to define your own exception class derived from Exception?
I am thinking something similar you have for example in Oracle PL/SQL where you can simply write
raise_application_error(-20001, 'An arbitary error message');
at any place.
throw new Exception("A custom message for an application specific exception");
Not good enough?
You could also throw a more specific exception if it's relevant. For example,
throw new AuthenticationException("Message here");
or
throw new FileNotFoundException("I couldn't find your file!");
could work.
Note that you should probably not throw new ApplicationException(), per MSDN.
The major draw back of not customizing Exception is that it will be more difficult for callers to catch - they won't know if this was a general exception or one that's specific to your code without doing some funky inspection on the exception.Message property. You could do something as simple as this:
public class MyException : Exception
{
MyException(int severity, string message) : base(message)
{
// do whatever you want with severity
}
}
to avoid that.
Update: Visual Studio 2015 now offers some automatic implementation of Exception extension classes - if you open the Quick Actions and Refactoring Menu with the cursor on the : Exception, just tell it to "Generate All Constructors".
The Exception class is not an abstract, and like most of the exceptions defined in .NET, takes a string message in one of the constructor overloads - you can therefore use an existing exception type, but with a customized message.
throw new Exception("Something has gone haywire!");
throw new ObjectDisposedException("He's Dead, Jim");
throw new InvalidCastException(
$"Damnit Jim I'm a {a.GetType().Name}, not a {b.GetType().Name}!");
Because this uses exception types that are known, it makes it easier for thrid parties to extend your libraries as well, since they don't need to look for MyArbitraryException in catch statements.
Short answer - no.
There is a good reason for enforcing the inheritance of custom exceptions; people need to be able to handle them. If you could throw your custom exception without having a type, people wouldn't be able to catch that exception type.
If you don't want to write a custom exception, use an existing exception type.
An easy way to create custom Exceptions in c# is using a generic class. This reduces the lines of code dramatically if you need to create much exceptions (i.e. if you need to distinguish between them in your unit tests).
First create a simple class called CustomException<T>:
public class CustomException<T> : Exception where T : Exception
{
public CustomException() { }
public CustomException(string message) : base(message){ }
public CustomException(string message, Exception innerException) : base(message, innerException){ }
public CustomException(SerializationInfo info, StreamingContext context) : base(info, context){ }
}
You can override as many constructors and methods as you want (or need) to. In order to create new Exception types just add new one-liner classes:
public class MyCustomException : Exception { }
public class SomeOtherException : Exception { }
If you want to raise your custom exception use:
throw new CustomException<MyCustomException>("your error description");
This keeps your Exception code simple and allows you to distinguish between those exceptions:
try
{
// ...
}
catch(CustomException<MyCustomException> ex)
{
// handle your custom exception ...
}
catch(CustomException<SomeOtherException> ex)
{
// handle your other exception ...
}
You can just throw one of the exceptions that is available in .NET:
throw new System.ArgumentException("Parameter cannot be null", "original");
Or more generic:
throw new ApplicationException("File storage capacity exceeded.");
