Optional Parameters or Overloading

In this case I would vote for optional parameters because what you are doing seems "orthogonal" to me: there's no significant variation.

You could also consider using Enumerable.Sum:

// requires Linq and .NET 3.5
public int SumAll(params int[] values)
{
    return values.Sum();
}

The 'Sum overloads of Enumerable allow you to use a wide variety of Types and optional Func for transformation, or whatever: [^].

You could even use Array.ForEach (.NET 3.0).

I suspect that all of these implementations would perform equally well given the simplicity of what you are doing, and the current sophistication of the .NET compiler's optimizations.

And, in the long run, I think that making your code self-documenting ... expressing your intent in the structure of the code so it is is clear, over times, to others ... can be just as important a factor in the syntax you use to implement this method.

Historically, option parameters weren't introduced. In later versions of C#, this feature have been added. That said, optional parameters have additional value for developers. I think this value is quite obvious: you have less methods; the whole thing is somewhat easier for maintenance; you have less code; the code is more readable overall.

You are the one who has to decide on that. Say, if there is a chance of down-grading the code to older versions of C#, using "overloading" is safer, won't require modification of code back to "overloading". In all other cases, I would prefer optional parameters. But you decide.

[EDIT]

I discussed performance considerations in detail, in the comments to this answers, below.

—SA

In practice, you just have to use some common senses and answer some simple questions like:

Do you want the implementation method to be public?
In some cases, it does not make sense to have all parameters at once as some of them might be exclusive.

Does the function with less parameters should call the one with more or vice versa? In the above case, it would make more sense to reverse the direction like this (only one case shown):

public int sum(int x, int y, int w)
{
  return sum(x, y) + w;
}

Another fact is that when parameters are of different data types, there might not be a single order that make sense (and you don't necessarily want to use named parameters).

As proposes in one solution, the params alternative can make a lot of sense if you have more that a given number of parameters. For a case like an addition, you might provide optimized version for 2 or 3 parameters and the general one above that.

In practice, you also consider the amount of code. In an example like the one above where it take more code to call the other version and the code is trivial, I might simply write the whole addition in each overload particulary if the function are used a lot.

Also, default values are not always simple constants so overload might sometime make sense because you might get the value using some code. And in cases like a virtual function, I would generally avoid default parameters and only have the implementation function virtual.

Another point would be the validation you might do on parameters or the usefullness of finding specific references or add a breakpoint only in a specific case.

Thus except for some trivial cases where it does not matter much, common sense should tell the more appropriate solution.