Question

Let’s say, for example, we have a method, which for sake of argument we’ll call MethodOne;

public void MethodOne()
    {
      //do stuff. 
    }

Now let’s say we want to create an optional peramater, and we might decide to create another method with the same name, that takes different overloads, for example;

public void MethodOne()
    {
       //do stuff.
    }

public void MethodOne(bool checkVar)
    {
       if(checkVar)
        {
           //do stuff
        }
       else
        {
          //do other stuff
        }
    }

So now we’ve got a method which has two different overload combinations(?). Is this, in practise, better than having one method, and just checking whether the optional overload is null or contains information, for example;

 public void MethodOne(int? testVar)
     {
        if(testVar != null)
         { 
           //do stuff
         }
     }

This may seem trivial with just one overload, but imagine that i’ve got 5 variables i want to pass through, would i create 5 methods, same name with different overloads, or just one method and check the passed variables?

Answer 1

There are a few workarounds for this. You could, for example, use an enumerator and an Object array as second parameter which contains real parameter values so that you know what to do with data by switching the enumerator… or you could just declare 5 Object parameters and then check for their type in a switch, box them accordingly and proceed. But both options are very bad practices.

I suggest you to stick on different overloads:

public void MethodOne(Boolean value)
{
    // Process the value...
}

public void MethodOne(Int32 value)
{
    // Process the value...
}

public void MethodOne(Int32 value, String text)
{
    // Process the value and the text...
}

// And so on...

Or default data in parameter declarations:

public void MethodOne(Int32 integer = 1, String text = "hello", ...)
{
    // Process everything inside the method...
}

Or parametrized methods (if every object type has a common processing):

public void MethodOne(params Object[] parameters)
{
    for (int i = 0; i < parameters.Length; ++i)
        // Check type of parameter and process the value...
}

Or methods bubbling if your design allows it (which is my favorite one as the first one is just producing a lot of code redundancies and the second one may be sometimes confusing for you or other developers working with you):

public void MethodOne(Int32 value)
{
    MethodOne(value, "hello");
}

public void MethodOne(Int32 value, String text)
{
    // Process everything inside the method...
}