Question

I got a rather big class library that contains a lot of code.

I am looking at how to optimize the performance of some of the code, and for some rather simple utility methods I’ve found that the parameter validation occupies a rather large portion of the runtime for some core methods.

Let me give a typical example:

1. A.MethodA1 runs a loop, iterating over a collection, calling B.MethodB1 for each element
2. B.MethodB1 processes the element and returns the result, it’s a rather basic calculation, but since it is used many places, it has been put into its own method instead of being copied and pasted where needed
3. A.MethodA1 calls C.MethodC1 with the results of B.MethodB1, and puts the result into a list that is returned at the end of the loop

In the case I’ve found now, B.MethodB1 does rudimentary parameter validation. Since the method calls other internal methods, I’d like to avoid having NullReferenceExceptions several layers deep into the code, and rather fail early, hence B.MethodB1 validates the parameters, like checking for null and some basic range checks on another parameter.

However, in this particular call scenario, it is impossible (due to other program logic) for these parameters to ever have the wrong values. If they had, from the program standpoint, B.MethodB1 would never be called at all for those values, A.MethodA1 would fail before the call to B.MethodB1.

So I was considering removing the parameter validation in B.MethodB1, since it occupies roughly 65% of the method runtime (and this is part of some heavily used code.)

However, B.MethodB1 is a public method, and can thus be called from the program, in which case I want the parameter validation.

So how would you solve this dilemma?

1. Keep the parameter validation, and take the performance hit
2. Remove the parameter validation, and have potentially fail-late problems in the method
3. Split the method into two, one internal that doesn’t have parameter validation, called by the “safe” path, and one public that has the parameter validation + a call to the internal version.

The latter one would give me the benefits of having no parameter validation, while still exposing a public entrypoint which does have parameter validation, but for some reason it doesn’t sit right with me.

Opinions?

Answer 1

I would go with option 3. I tend to use assertions for private and internal methods and do all the validation in public methods.

By the way, is the performance hit really that big?