I'm using Code Contracts in C# 4.0. I'm applying the usual static method chaining to simulate optional parameters (I know C# 4.0 supports optional parameters but I really don't want to use them).

The thing is that my contract requirements are executed twice (or possibly the number of chained overloads I'd implement) if I call the Init(string , string[]) method -- an obvious effect from the sample source code below. This can be expensive, especially due to relatively expensive requirements like the File.Exists I use.

public static void Init(string configurationPath, string[] mappingAssemblies)
{
    // The static contract checker 'makes' me put these here as well as
    // in the overload below.
 Contract.Requires<ArgumentNullException>(configurationPath != null, "configurationPath");
 Contract.Requires<ArgumentException>(configurationPath.Length > 0, "configurationPath is an empty string.");
 Contract.Requires<FileNotFoundException>(File.Exists(configurationPath), configurationPath);
 Contract.Requires<ArgumentNullException>(mappingAssemblies != null, "mappingAssemblies");
 Contract.ForAll<string>(mappingAssemblies, (n) => File.Exists(n));

 Init(configurationPath, mappingAssemblies, null);
}

public static void Init(string configurationPath, string[] mappingAssemblies, string optionalArgument)
{
    // This is the main implementation of Init and all calls to chained
    // overloads end up here.
 Contract.Requires<ArgumentNullException>(configurationPath != null, "configurationPath");
 Contract.Requires<ArgumentException>(configurationPath.Length > 0, "configurationPath is an empty string.");
 Contract.Requires<FileNotFoundException>(File.Exists(configurationPath), configurationPath);
 Contract.Requires<ArgumentNullException>(mappingAssemblies != null, "mappingAssemblies");
 Contract.ForAll<string>(mappingAssemblies, (n) => File.Exists(n));

 //...
}

If however, I remove the requirements from that method, the static checker complains that the requirements of the Init(string, string[], string) overload are not met. I reckon that the static checker doesn't understand that there requirements of the Init(string, string[], string) overload implicitly apply to the Init(string, string[]) method as well; something that would be perfectly deductable from the code IMO.

This is the situation I would like to achieve:

public static void Init(string configurationPath, string[] mappingAssemblies)
{
    // I don't want to repeat the requirements here because they will always
    // be checked in the overload called here.
 Init(configurationPath, mappingAssemblies, null);
}

public static void Init(string configurationPath, string[] mappingAssemblies, string optionalArgument)
{
    // This is the main implementation of Init and all calls to chained
    // overloads end up here.
 Contract.Requires<ArgumentNullException>(configurationPath != null, "configurationPath");
 Contract.Requires<ArgumentException>(configurationPath.Length > 0, "configurationPath is an empty string.");
 Contract.Requires<FileNotFoundException>(File.Exists(configurationPath), configurationPath);
 Contract.Requires<ArgumentNullException>(mappingAssemblies != null, "mappingAssemblies");
 Contract.ForAll<string>(mappingAssemblies, (n) => File.Exists(n));

 //...
}

So, my question is this: is there a way to have the requirements of Init(string, string[], string) implicitly apply to Init(string, string[]) automatically?