Question

我有两个对象可以表示为int，float，bool或string。我需要对这两个对象执行添加，结果与c＃将产生的结果相同。例如，1 +“Foo”将等于字符串“1Foo”，2 + 2.5将等于浮点数5.5，而3 + 3将等于int 6。目前我正在使用下面的代码，但它似乎令人难以置信的矫枉过正。任何人都可以简化或指出我有效地做到这一点吗？

private object Combine(object o, object o1) {
    float left = 0;
    float right = 0;

    bool isInt = false;

    string l = null;
    string r = null;
    if (o is int) {
        left = (int)o;
        isInt = true;
    }
    else if (o is float) {
        left = (float)o;
    }
    else if (o is bool) {
        l = o.ToString();
    }
    else {
        l = (string)o;
    }

    if (o1 is int) {
        right = (int)o1;
    }
    else if (o is float) {
        right = (float)o1;
        isInt = false;
    }
    else if (o1 is bool) {
        r = o1.ToString();
        isInt = false;
    }
    else {
        r = (string)o1;
        isInt = false;
    }

    object rr;

    if (l == null) {
        if (r == null) {
            rr = left + right;
        }
        else {
            rr = left + r;
        }
    }
    else {
        if (r == null) {
            rr = l + right;
        }
        else {
            rr = l + r;
        }
    }

    if (isInt) {
        return Convert.ToInt32(rr);
    }

    return rr;
}

Answer 1

你能使用.NET 4.0吗？如果是这样，使用动态类型变得非常简单：

private object Combine(dynamic o, dynamic o1)
{
    // Assumes an appropriate addition operator, found at execution time
    return o + o1;
}

另一种方法是为每对可能的类型设置一个代理映射。不幸的是，在.NET 4.0之前没有Tuple类型，因此您必须将自己的TypePair类型定义为地图键。当然，你需要确保覆盖所有可能的对......但至少编译器可以在你有一个合适的“AddDelegate”方法时提供帮助：

private void AddDelegate<T1, T2>(Func<T1, T2, object> sumFunction)
{
    // Put the function in the map
    ...
}

AddDelegate<int,int>((x, y) => x + y);
AddDelegate<int,float>((x, y) => x + y);
AddDelegate<int,string>((x, y) => x + y);
AddDelegate<float,int>((x, y) => x + y);
AddDelegate<float,float>((x, y) => x + y);
AddDelegate<float,string>((x, y) => x + y);
...

顺便说一句，我已经从bool中取出bool，因为float和{{1}}之间的“加法”（例如）没有任何意义。您可以决定如何组合它们。

正如Mitch所说，我会重新审视你的设计决定 - 你确定真的需要这个吗？这是一个非常奇怪的要求。你能告诉我们更大的情况吗？我们或许可以提出其他方法。

Answer 2

您可以使用要使用的不同类型重载方法。它的类型安全且简单。

    private string Combine(string o1, string o2) { return o1 + o2; }
    private string Combine(string o1, int o2) { return o1 + o2; }
    private string Combine(string o1, float o2) { return o1 + o2; }
    private string Combine(float o1, string o2) { return o1 + o2; }
    private float Combine(float o1, int o2) { return o1 + o2; }
    private float Combine(float o1, float o2) { return o1 + o2; }
    private string Combine(int o1, string o2) { return o1 + o2; }
    private float Combine(int o1, float o2) { return o1 + o2; }
    private int Combine(int o1, int o2) { return o1 + o2; }

在C＃中组合两个对象的最有效方法

2 个答案: