Proposal: parameter contracts

[Opiumtm]

Introduce "interface struct" contract for method and constructor parameters.

public interface struct SomeParams
{
    int Id;
    string Optional = null;
    string[] Optional2 = new string[0];
    int Id2;
}

public class ClassA
{
    public ClassA(SomeParams par)
    {
        // constructor code
    }
}

// and use it

var a = new ClassA(Id: 1, Id2: 2);
var par = new SomeParams() { Id = 1, Id2 = 2 };
var a1 = new ClassA(par);

this would be translated to

[InterfaceStruct]
public struct SomeParams
{
    [ParameterOrder(1)] // if not specified explicitly, parameter order assigned implicit order based on declaration order in interface struct
    public int Id;

    // non-optional parameters are always placed before optional parameters by default
    [ParameterOrder(2)]
    public int Id2;

    [ParameterOrder(3)]
    [Optional(Value: null)]
    public string Optional;

    [ParameterOrder(4)]
    [Optional(MethodName: "Optional2_GetDefault")]
    public string[] Optional2;

    // for non-standard default values use static method to get defaults
    public static string[] Optional2_GetDefault()
    {
        return new string[0];
    }
}

public class ClassA
{
    [ParameterContract(typeof(SomeParams))]
    public ClassA(int Id, int Id2, string Optional, string[] Optional2)
    {
        SomeParam par = new SomeParam()
        {
            Id = Id,
            Optional = Optional,
            Optional2 = Optional2,
            Id2 = Id2
        };
        // constructor code
    }
}

var a = new ClassA(1, 2, null, SomeParams.Optional2_GetDefault());
var par = new SomeParams() { 
    Id = 1, 
    Id2 = 2, 
    Optional = null, 
    Optional2 = SomeParams.Optional2_GetDefault()
};
var a1 = new ClassA(par.Id, par.Id2, par.Optional, par.Optional2);

This would overcome some parameter list limitations and ambiguity. Most importantly - it introduce ability to declare non-standard default values logic. It doesn't take struct as parameter and provide parameters as parameter list. Struct is created and initialized from paremeters in method/constructor body instead.

[dsaf]

Most importantly - it introduces ability to declare non-standard default values logic.

I personally would prefer to see an enhanced support for literals for this dotnet/roslyn#263 dotnet/roslyn#2401.