|
Hmmm. I've never read anything to suggest that you shouldn't be able to use the standard exceptions. It's insane for somebody to suggest otherwise because they are effectively telling you that your code cannot act like the underlying framework. What do I mean by this?
Well, suppose that you have written a framework of your own that sits on top of the .NET framework (an MVVM framework for instance), and it gains popularity with other developers. Now, this framework checks parameters to ensure they aren't null - it's only natural for the end developer to expect that a null parameter would be raised via an ArgumentNullException - after all, he's making other calls that are throwing this exception.
Suppose now, that you've used some GPL in your library, and in this code, it also checks for null arguments and in certain places, your code is such a thin wrapper that you just pass the arguments that you've got across. All of a sudden, you've got two different types of custom ArgumentNullException to handle, and that's just plain stupid.
If you have an exception type that isn't catered for by the underlying framework then, by all means, create your own exception for it - I do this quite a lot (for instance, I have an UnexpectedStringFormatException exception that I sometimes raise when I have a regular expression test that fails). If it's something as simple as an argument out of range, then use the ArgumentOutOfRangeException because that's what it's there for.
|
|
|
|
|
The authors that you're referring to have heard about the rule-of-thumb that you should inherit your own exceptions, preferably not inheriting from ApplicationException. The reasoning is that it helps in differentiating between the exceptions that the framework throws and the exceptions that you app throws.
Not considering the fact that most shops create their own framework on top of .NET, and have multiple apps on that framework. According to their rule-of-thumb, the apps shouldn't re-use the exceptions from their own framework.
..now, if programming could be reduced to a few rule-of-thumbs, we'd all be using Visual Basic. By all means, throw an OutOfRangeException if that's what's occuring - the goal of an exception is handling an exceptional situation, and if OutOfRange describes that best, then that is the one that should be applied.
I are Troll 
|
|
|
|
|
I like to create my own exceptions, except (no pun intended) for the most basic validations, because the situation you mentioned is a bit rare in business applications. The custom exception often adds semantic information. In a similar situation, NegativeDepositAmmountException IMHO could be much more meaningful than ArgumentOutOfRangeException. If your number has a strict domain, often is a class or some entity that needs special treatment.
Another similar case is where you can't receive a Customer with an empty or null Customer.Address field. What would you prefer to receive? A NullReferenceException or a EmptyAdressException?
It means a lot more manual work, but in the long run it pays when you deploy your code to your customers.
|
|
|
|
|
If you have NegativeDepositAmmountException inherit ArgumentOutOfRangeException you can have the best of both worlds. You can encode as much semantic information as you need, while simultaneously making it easy for a consumer to handle common error cases without having to learn all the details of your implementation up front.
3x12=36
2x12=24
1x12=12
0x12=18
|
|
|
|
|
It's a very nice idea, but not always practical, and could lead to some inconsistencies. I learned the hard way to take a lot of care when deriving a class, and follow more rigidly LSP (Liskov Substitution Principle).
In the same example, EmptyAdressException cannot be derived from NullReferenceException, in the same way a Square cannot be derived from a Rectangle.
|
|
|
|
|
I'm not following. If I understand LSP correctly it says that if I derive Square from Rectangle that Squares must have all the properties of a rectangle; which they do so the derivation should be allowed under LSP.
What am I missing?
3x12=36
2x12=24
1x12=12
0x12=18
|
|
|
|
|
That's what I thought at first, too. But LSP is not about properties, nor methods. LSP is about "substitution", and that is more closely related to an specialization. A Red Rectangle can be derived from a Rectangle, but a Square is much more an abstract class on its own.
The "is a" relationship of OO is flawed; you can read more about that on this pdf[^]
|
|
|
|
|
Also, a inherited class should only throw exceptions that the base class throws, or descendants thereof.
I are Troll 
|
|
|
|
|
IMO, it really depends on what description the pre-defined .NET exception is offering. Is it enough for the user to understand what went wrong? If it isn't, then you should create your own exception and put in a custom name and message to let the user know exactly about the problem.
|
|
|
|
|
I would say you need to build your own exception set when you (your clients) don't like the exception set Microsoft is providing - as simple as that.
The funniest thing about this particular signature is that by the time you realise it doesn't say anything it's too late to stop reading it.
My latest tip/trick
|
|
|
|
|
If the condition that triggers the exception is reasonably generic (a null argument, or a value out of range), I use one of the predefined .NET exceptions. If the condition is domain-specific to the application, then I define my own.
For example, I have a class that handles TCP/IP socket communications between my application and a Windows service. This class can throw InvalidCastExceptions, given that our protocol includes data type information along with each data value in a message. This ensures that the sender/receiver on my end agrees with the receiver/sender on the other end. It also can throw BufferException or ReadSizeException, exceptions defined in the class derived from ApplicationException, that reflect protocol errors.
Patrick Skelton wrote: According to some books I have read, the exceptions built into .NET should generally be reserved for .NET's own use and developers should create custom exceptions for classes they create.
This is symptomatic of an 'anti-pattern' you see occasionally. Some programmers think that they always have to insulate their applications from potential changes to the framework they're using. They build wrapper classes for everything. The wrappers end up being extremely thin layers on top of the actual framework. All they accomplish with this is to obfuscate their use of the framework. This makes their code more difficult to debug and maintain, since they rarely document framework considerations and constraints that their wrapper promotes.
Software Zen: delete this;
|
|
|
|
|
I try to handle an exception-causing code to avoid throwing an exception, and let the code fail gracefully (not necessarily terminating a process or action, but using reasonable properties to allow it to continue.
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass." - Dale Earnhardt, 1997
|
|
|
|
|
Yeah, it depends on the situation. I use the built-in Exceptions when they seem appropriate and define my own when I want to add more information. As with Exceptions raised by ADO.net code -- I can throw problem-specific Exceptions (duplicate, referential integrity, etc.) that also include the text of the statement and any parameters involved so they can be handled appropriately by the application.
Also, if you do define your own Exception, derive it from the appropriate base Exception -- your own OutOfRange should derive from the base OutOfRange.
|
|
|
|
|
I'll agreed with the other recommendations also. First, try to prevent the exception in the first place but we all know that is not possible or desirable in some situation. If the exception fits a built-in type, ArgumentNullException for instance then by all means use it. However, if you need to differentiate or have a custom case then certainly creating your own is valid.
I know the language. I've read a book. - _Madmatt
|
|
|
|
|
I generally just do this instead of creating custom exception objects:
catch (Exception ex)
{
throw new Exception("My custom exception message", ex);
}
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass." - Dale Earnhardt, 1997
|
|
|
|
|
Yes but there are times when it is advantageousness to differentiate between a custom exception
try
{
Foo();
}
catch(UserIsMoronException ex)
{
BeatSensless();
}
catch(Exception ex)
{
Log();
}
I know the language. I've read a book. - _Madmatt
|
|
|
|
|
Mark Nischalke wrote: catch(UserIsMoronException ex)
They REALLY need to add this one to the framework. 
".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
"Why don't you tie a kerosene-soaked rag around your ankles so the ants won't climb up and eat your candy ass." - Dale Earnhardt, 1997
|
|
|
|
|
John Simmons / outlaw programmer wrote: Mark Nischalke wrote:
catch(UserIsMoronException ex)
They REALLY need to add this one to the framework.
They did, and 85% of the exceptions where caught by, ... you guessed it right... 
|
|
|
|
|
Having a type-safe object has some advantages over a string.
It's harder to filter if you're examining a string, and I like having a class that describes the problem and being able to catch and handle that specific case. Or worse- let the user decide whether or not those kind of exceptions need be logged (like file-access errors for the sysadmin, common networkexceptions for the networkadmin, and whether the user allows the app to send unhandled exceptions with a stacktrace back home) There's a string in the custom exception of course, along with placeholders for values to help diagnose the problem. But in code, I can act on the object itself, and I don't need to depend on the formatting of a string.
It's a matter of preference, I guess, as you can accomplish the same visual and functional endresult.
No, the worst kind of exceptions are translated ones. Yes, I know about the unlocalize website, but that's not exactly convenient. I'm hoping that I can rectify some by removing the .NET language packs from my PC.
I are Troll
|
|
|
|
|
John Simmons / outlaw programmer wrote: I generally just do this instead of creating custom exception objects:
catch (Exception ex)
{
throw new Exception("My custom exception message", ex);
}
I believe that is a mistake. I discuss this on my article[^], more deeply but there are 3 main problems with this approach:
1. Internationalization: when you need to catch your exception you'll need to have some sort of switch on the text message. With i18n, which message should you use on the switch?
2. You'll force your users to catch (Exception ex), which is a too broad class and they'll need to handle a lot of other different exceptions.
3. You'l force your users to stop using the more efficient catch (XXXXException) and use a switch instead, which is both less readable and less efficient.
|
|
|
|
|
The well designed application doesn’t needs exceptions! 
In a more serious note, the only case I create custom exceptions is when I’m dealing with COM objects and/or native libraries in order to wrap their error handling and error messages. In any other cases the build-in exceptions and re-throwing them in some cases seems to be enough for me.
There is only one Ashley Judd and Salma Hayek is her prophet!
Advertise here – minimum three posts per day are guaranteed.
|
|
|
|
|
Depends on the situation. Mostly one should use built in exceptions, but for some reason the exception is too generic or does not fit in your scenario, then creating a custom exception is better.
|
|
|
|
|
My decision is to define a custom exception when the need to do so is... well... exceptional
Really though…
If you have an exception definition that clearly fits an existing model then use it, why reinvent the wheel at all?
If you are creating a new failure state, usually most likely based upon things like a domain specific business rule, then you define a new exception of your own design. BUT you have to keep in mind that quite often even doing this can cause issues because as we all know business rules change. This means that you may want to be slightly less specific and more generalized by defining a business rule exception and allowing it to express the rule broken, and the why it was considered broken enough to trigger the exception.
I would like to know what books you say are specifically stating that new exceptions should always be defined instead of using the Dotnet ones. I would have to have a conversation with that author I am not even sure I see the value in writing all custom exceptions when creating a whole new code library of your new library is something that sits on top of the Dotnet framework. If you are writing something that is completely disconnected at all form the Dotnet stuff then yeah, you have to create your own exceptions to throw, but that makes no sense in this context really since your question was more related to being told to not use Dotnet exceptions .
If you did want to keep all the exceptions specific to your application layer then there is nothing from stopping you from writing all your own custom exception code, but I would still recommend that you consider catching the Dotnet specific stuff and then just re throwing your own as a general application side exception and then include the Dotnet exception in that object. Seems a bit messy but I guess it is doable and will not require too much writing on your part. Just remember that every additional line of code you have to write can possibly introduce a new error (and thus CAUSE an exception ) so I like to keep them down to a minimum.
One other argument I would make for maintaining the existing exceptions provided by the framework is that anytime they change you need to ensure that your code changes also. This means that if you have wrapped all of the Dotnet exceptions in your code, any time the framework changes you have to review all those changes to see what effects they have on your code. Not that you may not have to do the same if the base libraries change their exceptions and you have to catch them, but usually one of a few things happen there. First, they will keep the older exception around for a while tagged in the new framework that it is being pulled soon so that new code compilation will not allow the use of it but existing code can still use it, and second you have some time to make changes. This is also a good reason to always be sure to include a general catch statement if you want to be sure that you can grab any problems that come up due to your missing a specific exception that perhaps is not well documented or you just missed.
Whew.. a long response…
|
|
|
|
|
I think you would do this when you want to specify additional information beyond a string message describing what went wrong. Some exceptions take advantage of their name to provide additional information, like NullReferenceException. If one is thrown, clearly something is null and the code didn't expect it to be. SqlException contains additional properties related to line numbers in stored procedures that failed, for example.
So, if you'd like to provide additional properties to describe what went wrong, create a class that inherits Exception that has those properties.
|
|
|
|
|
I'll typically only write custom exceptions in the Model (Business) layer. The reason for doing this is so the presentation layer can consume the exception and display a message which is non-technical and meaningful to the user. Probably breaches best practices but it works well example:
Model receives an OutOfRangeException, Model creates a MyModelException with the message "The number of passengers must be greater than 0" and throws the exception to the presentation layer.
Architecture is extensible, code is minimal.
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
