代码之家 › 专栏 › 技术社区 › T. Stone

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

addition object performance .net c#

T. Stone · 技术社区 · 15 年前

我有两个对象可以表示为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;
}

2 回复 | 直到 13 年前

tames 15 年前

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

    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; }

Jon Skeet 15 年前

你能用.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 从中可以看出 布尔 和A float (例如)没有任何意义。不过,您可以决定如何组合它们。

不过,正如米奇所说,我会重新审视你的设计决策——你确定吗? 真正地 需要这个吗?这是一个非常奇怪的要求。你能告诉我们大局吗?我们可以建议其他方法。