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

我有两个对象可以表示为int、float、bool或string。我需要对这两个对象执行加法，结果与c#产生的结果相同。例如，1+Foo将等于字符串“1Foo”，2+2.5将等于float 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;
}

---

你能使用.NET4.0吗？如果是这样，则使用动态键入变得非常简单：

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

另一种选择是为每对可能的类型创建一个代理映射。不幸的是，在.NET4.0之前没有

Tuple

类型，因此您必须定义自己的

TypePair

类型作为映射键。当然，你需要确保你涵盖了每一对。。。但至少当您有合适的“AddDelegate”方法时，编译器可以提供帮助：

private void AddDelegate（Func sum函数）
{
//将函数放在映射中
...
}
AddDelegate（（x，y）=>x+y）；
AddDelegate（（x，y）=>x+y）；
AddDelegate（（x，y）=>x+y）；
AddDelegate（（x，y）=>x+y）；
AddDelegate（（x，y）=>x+y）；
AddDelegate（（x，y）=>x+y）；
...

顺便说一句，我把

bool

去掉了，因为

bool

和

float

之间的“加法”（例如）没有任何意义。不过，您可以决定如何组合它们

---

正如米奇所说，我会重新审视你的设计决策——你确定你真的需要这个吗？这是一个相当奇怪的要求。你能告诉我们更大的情况吗？我们可以建议其他方法。

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

    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语言写一个口译员。我在运行时没有太多关于变量的类型信息。不过，我可能有足够的钱来实现您的代表想法！对于object+object，我会考虑什么样的速度问题？与动态+动态相同？？请告诉我

对象o，对象o2

是一个打字错误。。。你的意思是动态的，对吗？他们并不是真的要改变加号操作符的含义，因为谁知道有多少应用程序在野外。。。是吗。。。是吗。。。是吗@马克斯根西耶尔：是的，这是一个打字错误。哦：）不，C#4仍然是静态类型的，除非你有一个动态表达式。乔恩，这是难以置信的主题，但动态C=0；C++；按照预期的方式编译和运行？也就是说，在使用dynamic时，是否所有运算符方法都按预期运行？@Dested：并非所有操作都按预期运行，尽管该示例可能会这样做。关闭某些内容的示例：

dynamic d=（字节）0；字节b=1；d+=b；Console.WriteLine（d.GetType（））

用于打印

System.Byte

，遵循C#的复合赋值运算符的精确规则；它现在打印

System.Int32

。我怀疑这会给很多人带来麻烦：）简单的功能经常被忽视。关键在于有效地确定对象的类型。这就是问题所在，而不是如何将每个数据类型相互添加。当使用重载方法时，您不必确定数据类型：Combine（“一”，2），Combine（3f，“四”），等等，都将调用相应的重载。让编译器为您完成。这是完美的。正是我想说的关于这件事。。。它实际上是为了限制要组合的对象类型，否则如果您允许任何类型，您可以只取这两个值并使用表达式o1+o2，而不是调用任何方法。但是，不兼容的类型将失败。

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