Perché la restrizione del tipo non è parte della firma del metodo?

Question

Quindi ho letto Eric Lippert's 'Constraints are not part of the signature' e ora capisco che le specifiche specificano che i vincoli di tipo vengono controllati DOPO la risoluzione di sovraccarico, ma non sono ancora chiaro sul perché questo DEVE essere il caso. Di seguito è riportato l'esempio di Eric:

Questo non viene compilato perché la risoluzione di sovraccarico per: Foo(new Giraffe()) ne deduce che Foo<Giraffe> è la miglior partita di sovraccarico, ma poi i vincoli di tipo falliscono e un errore di compilazione viene generata. Nelle parole di Eric:

Il principio è la risoluzione di sovraccarico (e il tipo di metodo di deduzione) trovare la migliore corrispondenza possibile tra un elenco di argomenti e la lista di ogni metodo candidato di parametri formali. Cioè, guardano la firma del metodo candidato.

I vincoli di tipo NON fanno parte della firma, ma perché non possono essere? Quali sono alcuni scenari in cui è una cattiva idea considerare i vincoli di tipo parte della firma? È solo difficile o impossibile da implementare? Non sto sostenendo che se il sovraccarico scelto migliore è per qualsiasi motivo impossibile da chiamare, allora silenziosamente ripiego al secondo migliore; Lo odierò. Sto solo cercando di capire perché i vincoli di tipo non possono essere utilizzati per influenzare la scelta del sovraccarico migliore.

sto immaginando che internamente al compilatore C#, solo per scopi di risoluzione di sovraccarico (non riscrivere in modo permanente il metodo), il seguente:

static void Foo<T>(T t) where T : Reptile { } 

si trasforma a:

static void Foo(Reptile t) { } 

Perché non è possibile "inserire" i vincoli di tipo nell'elenco dei parametri formali? In che modo questo cambia la firma in modo negativo? Sento che rafforza solo la firma. Quindi Foo<Reptile> non sarà mai considerato un candidato sovraccarico.

Modifica 2: Nessuna meraviglia che la mia domanda fosse così confusa. Non ho letto correttamente il blog di Eric e ho citato l'esempio sbagliato. Ho modificato nell'esempio che ritengo più appropriato. Ho anche cambiato il titolo per essere più specifico. Questa domanda non sembra semplice come ho immaginato, forse mi manca qualche concetto importante. Sono meno sicuro che si tratti di materiale stackoverflow, potrebbe essere meglio spostare questa domanda/discussione altrove.

Answer 1

il compilatore C# deve non considerare vincoli di tipo come parte come la firma del metodo, perché non fanno parte della firma del metodo per il CLR. Sarebbe disastroso se la risoluzione di sovraccarico funzionasse in modo diverso per linguaggi diversi (principalmente a causa del legame dinamico che potrebbe verificarsi in fase di esecuzione e non dovrebbe essere diverso da una lingua all'altra, altrimenti tutti gli inferni si scatenerebbero).

Perché è stato deciso che questi vincoli non avrebbero fatto parte della firma del metodo per il CLR è un'altra domanda a parte, e ho potuto fare solo supposizioni informate su questo. Farò sapere alle persone che lo sanno.

Answer 2

Se T corrisponde a più vincoli, si crea un'ambiguità che non può essere risolta automaticamente. Per esempio si dispone di una classe generica con il vincolo

where T : IFirst

e un altro con il vincolo

where T : ISecond

È ora vuole T sia una classe che implementa sia IFirst e ISecond.

Calcestruzzo esempio di codice:

public interface IFirst 
{ 
    void F(); 
} 

public interface ISecond 
{ 
    void S(); 
} 

// Should the compiler pick this "overload"? 
public class My<T> where T : IFirst 
{ 
} 

// Or this one? 
public class My<T> where T : ISecond 
{ 
} 

public class Foo : IFirst, ISecond 
{ 
    public void Bar() 
    { 
     My<Foo> myFoo = new My<Foo>(); 
    } 

    public void F() { } 
    public void S() { } 
}