Confronti diretti di tipi di valore C#

Question

Ho letto la seguente dichiarazione relativa al confronto dei tipi di valore C# in C# in Depth, Second Edition più volte.

pagina 77,

Quando un parametro tipo è vincolata (vincoli vengono applicati ad esso), è possibile utilizzare == e! = Operatori, ma solo per confrontare un valore di quel tipo con null. Non è possibile confrontare due valori di tipo T l'uno con l'altro.

...

Quando un parametro di tipo è costretto a essere un tipo di valore, == e! = Non può essere utilizzato con esso a tutti.

Se ho capito (io non la penso così) in modo corretto, fondamentalmente mi dice che non si può uso == o! = Per confrontare due tipi di valore. Perché perché perché?

Sarà meglio se un esempio semplice può essere dato per questo caso. Qualcuno può darmi una piccola idea di ciò che il paragrafo precedente cerca di trasmettere?

Answer 1

Significa semplicemente questo quando vincolare un tipo di valore (secondo paragrafo)

static bool TryToCompare<T>(T first, T second) where T : struct 
{ 
    return first == second; // not legal 
    return first.Equals(second); // legal 
} 

Senza il vincolo valore tipo sul generico, dice anche questo (primo paragrafo)

static bool TryToCompare<T>(T first, T second) 
{ 
    return first == second; // not legal 
    return first == null; // legal 
    return first.Equals(second); // legal 
} 

Se si vincola T a un tipo di riferimento, è possibile ottenere utilizzando ==

static bool TryToCompare<T>(T first, T second) where T : class 
{ 
    return first == second; // legal 
    return first == null; // legal 
    return first.Equals(second); // legal 
} 

Answer 2

Gli oggetti non sono confrontabili poiché un confronto usando == sta verificando se il riferimento è lo stesso (l'indirizzo di memoria). Normalmente si userebbe se (string1.Equals (stringa2)).

Qualcosa che non capisco è che ho visto circostanze in cui == funziona con stringhe e circostanze in cui non lo fa.