C#에서 두 객체를 결합하는 가장 효율적인 방법

Question

int, float, bool 또는 string으로 표현할 수있는 두 개의 객체가 있습니다. 이 두 객체에 추가 작업을 수행해야합니다. 결과는 결과로 생성되는 것과 동일한 결과가됩니다. 예를 들어 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; 
} 

Answer 1

사용하려는 다른 유형으로 메소드를 오버로드하면됩니다. 그것은 타입 안전하고 간단합니다.

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

Answer 2

.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"방법이있어 때 도움이 될 수 있습니다, 나는 밖으로 bool을 촬영했습니다 Btw는

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과 float 사이의 "추가"는 의미가 없습니다. 당신은 어떻게 그들을 결합하고 싶을 지 결정할 수 있습니다.

미치가 말했듯이, 나는 당신의 디자인 결정을 재검토 할 것입니다. 정말로이 필요합니까? 꽤 이상한 요구 사항입니다. 더 큰 그림에 대해 우리에게 아무 것도 말할 수 있습니까? 우리는 대안적인 접근법을 제시 할 수 있습니다.