Mehrdeutige Anruf zwischen zwei C# Erweiterung generische Methoden ein, wo T: Klasse und andere, wo T: struct

Question

Betrachten wir zwei Erweiterungsmethoden:

public static T MyExtension<T>(this T o) where T:class 
public static T MyExtension<T>(this T o) where T:struct 

Und eine Klasse:

class MyClass() { ... } 

Nun ist die Erweiterung Methode aufrufen auf einer Instanz der oben Klasse:

var o = new MyClass(...); 
o.MyExtension(); //compiler error here.. 
o.MyExtension<MyClass>(); //tried this as well - still compiler error.. 

der Compiler sagt, dass die Methode ruft eine mehrdeutige cal l wenn ich es in einer Klasse anrufe. Ich hätte gedacht, dass es bestimmen könnte, welche Erweiterungsmethode aufgerufen werden soll, da MyClass eine Klasse und keine Struktur ist?

Answer 1

EDIT: Ich habe jetzt blogged about this im Detail.

---

Meine ursprüngliche (und ich glaube, jetzt falsch) Gedanke: generic Einschränkungen nicht berücksichtigt bei der Überladungsauflösung und Typinferenz Phasen genommen - sie sind nur das Ergebnis der Überladungsauflösung zu validieren.

EDIT: Okay, nach einem Los davon zu gehen auf diesem, ich denke, ich bin da. Grundsätzlich war mein erster Gedanke fast korrekt.

Generische Typ-Constraints wirken nur, um Methoden aus einem Kandidatensatz in einem sehr begrenzten Satz von Umständen zu entfernen ... insbesondere, nur wenn der Typ eines Parameters selbst generisch ist; nicht nur ein Typparameter, sondern ein generischer Typ, der einen generischen Typparameter verwendet. An diesem Punkt werden die Einschränkungen für die Typparameter des generischen Typs überprüft, nicht die Einschränkungen für die Typparameter der generischen Methode, die Sie aufrufen.

Zum Beispiel:

// Constraint won't be considered when building the candidate set 
void Foo<T>(T value) where T : struct 

// The constraint *we express* won't be considered when building the candidate 
// set, but then constraint on Nullable<T> will 
void Foo<T>(Nullable<T> value) where T : struct 

Also, wenn Sie versuchen, Foo<object>(null) das obige Verfahren zu nennen nicht Teil des Kandidatensatzes, weil Nullable<object> value die Zwänge des Nullable<T> nicht erfüllt. Wenn es andere anwendbare Methoden gibt, könnte der Aufruf dennoch erfolgreich sein.

Jetzt im obigen Fall sind die Einschränkungen genau gleich ... aber sie müssen nicht sein. Betrachten wir zum Beispiel:

class Factory<TItem> where TItem : new() 

void Foo<T>(Factory<T> factory) where T : struct 

Wenn Sie versuchen, Foo<object>(null) zu nennen, werden nach wie vor das Verfahren Teil des Kandidatensatzes sein - denn wenn TItemobject, ausgedrückt die Einschränkung in Factory<TItem> hält nach wie vor, und dass ist, was überprüft hat beim Aufbau des Kandidatensets. Wenn dies die beste Methode erweist, wird es dann nicht Validierung später, in der Nähe des Ende von 7.6.5.1:

Wenn die beste Methode, eine generische Methode ist, die Typargumente (geliefert oder abgeleitet) werden gegen die Einschränkungen (§4.4.4), die für die generische Methode deklariert sind, geprüft. Wenn ein Typargument die entsprechenden Integritätsbedingungen für den Typparameter nicht erfüllt, tritt ein Bindungszeitfehler auf.

Eric's blog post enthält weitere Details zu diesem Thema.

Answer 2

Eric Lippert erklärt besser als ich jemals könnte, here.

Ich bin auf diese selbst gestoßen. Meine Lösung war

public void DoSomthing<T> (T theThing){ 
    if (typeof (T).IsValueType) 
     DoSomthingWithStruct (theThing); 
    else 
     DoSomthingWithClass (theThing); 
} 

// edit - seems I just lived with boxing 

public void DoSomthingWithStruct (object theThing) 
public void DoSomthingWithClass(object theThing) 

Answer 3

ich diese „interessant“ seltsame Art und Weise festgestellt, dass zu tun, in Werten .NET 4.5 unter Verwendung von Standard-Parametern :) Vielleicht ist nützlicher für Bildungs ​​\ spekulative Zwecke als für wirkliche Verwendung, aber ich mag zeigen, es:

/// <summary>Special magic class that can be used to differentiate generic extension methods.</summary> 
public class MagicValueType<TBase> 
    where TBase : struct 
{ 
} 

/// <summary>Special magic class that can be used to differentiate generic extension methods.</summary> 
public class MagicRefType<TBase> 
    where TBase : class 
{ 
} 

struct MyClass1 
{ 
} 

class MyClass2 
{ 
} 

// Extensions 
public static class Extensions 
{ 
    // Rainbows and pink unicorns happens here. 
    public static T Test<T>(this T t, MagicRefType<T> x = null) 
     where T : class 
    { 
     Console.Write("1:" + t.ToString() + " "); 
     return t; 
    } 

    // More magic, other pink unicorns and rainbows. 
    public static T Test<T>(this T t, MagicValueType<T> x = null) 
     where T : struct 
    { 
     Console.Write("2:" + t.ToString() + " "); 
     return t; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 

     MyClass1 t1 = new MyClass1(); 
     MyClass2 t2 = new MyClass2(); 

     MyClass1 t1result = t1.Test(); 
     Console.WriteLine(t1result.ToString()); 

     MyClass2 t2result = t2.Test(); 
     Console.WriteLine(t2result.ToString()); 

     Console.ReadLine(); 
    } 
}