同一类型的多个参数的编译时方法调用验证

Question

这是问题的演示：

class Program
{
    static double Func(double a, double b) { return a * 1000 + b * b; }

    static void Main(string[] args)
    {
        var a = 1.1d;
        var b = 2.2d;
        Console.WriteLine(Func(a, b));
        // this is the problem, function doesn't recognize when a and b
        // "accidentally" exchanged, target is to make this row a compile-time error
        Console.WriteLine(Func(b, a));
    }
}

如果有许多参数的方法（例如double 类型的十个），这将成为一个问题：

double Func(double parameter1, double parameter2, ..., double parameter10);

问题：有没有办法在调用方法时验证参数，让程序员更不容易出错？

---

如果参数类型不同，这不是问题。我认为可能包装到新类型会有所帮助：

class A
{
    private double _value;
    public static implicit operator A(double value) { return new A() { _value = value }; }
    public static implicit operator double(A value) { return value._value; }
}
class B
{
    private double _value;
    public static implicit operator B(double value) { return new B() { _value = value }; }
    public static implicit operator double(B value) { return value._value; }
}

class Program
{
    static double Func(A a, B b) { return a * 1000 + b * b; }

    static void Main(string[] args)
    {
        A a = 1.1d;
        B b = 2.2d;
        Console.WriteLine(Func(a, b));
        Console.WriteLine(Func(b, a)); // compile-time error! yay!
        Console.WriteLine(Func(a, b) + 123.123d - a * 2); // implicit conversion power
        Console.ReadKey();
    }
}

确实如此，但我不确定这种方法是否有效。我怀疑这是否是一个好主意。是吗？还是有更好的？

我知道如果我总是调用这样的方法（使用named arguments 方法调用）我可以绝对安全

Func(a:a, b:b);

这不应该带来任何代码开销，但需要大量输入。包装更好，因为它只完成一次（创建新类型很容易），但它可能有开销。

Answer 1

如果两个参数属于同一类型，则无法在编译时、运行时或其他情况下检测参数变量的名称是否与参数的名称相对应。这是一个悬而未决的问题，但我会提供一些想法。

• 按照 Mehrzad 的建议，考虑按某种类型对参数进行分组。例如，不要考虑double Distance(double x1, double y1, double x2, double y2)，而是考虑double Distance(Point p1, Point p2)

• 一般来说，如果您的方法有超过 4-5 个参数，请考虑重构。可能你的方法做的东西太多，逻辑可以分？

• 如果您真正想做的是执行一些检查，例如确保a < b，请考虑查看Code contracts。您也可以使用Debug.Assert()，但这仅在运行时有效。

• 我不推荐您建议的那种隐式转换。对我来说，A a = 1.1 除了编译时检查参数之外应该没有任何语义目的，这感觉很笨拙和不直观。您的最终目标是让代码整体更易于维护。

Answer 2

一个方法永远不应该有 10 个参数。

一旦您有大约 4 个参数，就开始考虑使用一个新类来包含这些参数...例如，考虑用户在网站上导航的偏好...

void Main()
{
    UserPreferences preference = new UserPreferences
    {
        BackgroundColor = "#fff",
        ForegroundColor = "#000",
        Language = "en-GB",
        UtcOffSetTimeZone = 0
    };

    User aydin = new User(preference);
}

public class User
{
    public User(UserPreferences preferences)
    {
        this.Preferences = preferences;
    }

    public UserPreferences Preferences { get; set; }
}

public class UserPreferences
{
    public string BackgroundColor { get; set; }
    public string ForegroundColor { get; set; }
    public int UtcOffSetTimeZone { get; set; }
    public string Language { get; set; }
}

Answer 3

使用类似这样的继承类

    class Program
    {
        static double Func(List<Parent> l) { return l[0]._value * 1000 + l[1]._value * l[1]._value; }

        static void Main(string[] args)
        {
            A a = 1.1d;
            B b = 2.2d;
            Console.WriteLine(Func(new List<Parent>() {a,b}));
            Console.WriteLine(Func(new List<Parent>() { a, b })); // compile-time error! yay!
            Console.WriteLine(Func(new List<Parent>() { a, b }) + 123.123d - a * 2); // implicit conversion power
            Console.ReadKey();
        }
    }
    class Parent
    {
        public double _value { get; set; }
    }
    class A : Parent
    {
        public static implicit operator A(double value) { return new A() { _value = value }; }
        public static implicit operator double(A value) { return value._value; }
    }
    class B : Parent
    {
        public static implicit operator B(double value) { return new B() { _value = value }; }
        public static implicit operator double(B value) { return value._value; }
    }