L'operatore == non può essere applicato a tipi generici in C #?

Secondo la documentazione ==dell'operatore in MSDN ,

Per tipi di valore predefiniti, l'operatore di uguaglianza (==) restituisce vero se i valori dei suoi operandi sono uguali, falso altrimenti. Per tipi di riferimento diversi da string, == restituisce true se i suoi due operandi si riferiscono allo stesso oggetto. Per il tipo di stringa, == confronta i valori delle stringhe. I tipi di valori definiti dall'utente possono sovraccaricare l'operatore == (vedi operatore). Anche i tipi di riferimento definiti dall'utente possono essere definiti, sebbene per impostazione predefinita == si comporti come descritto sopra sia per i tipi di riferimento predefiniti che per quelli definiti dall'utente.

Quindi perché questo frammento di codice non viene compilato?

bool Compare<T>(T x, T y) { return x == y; }

Ottengo l'errore L' operatore '==' non può essere applicato agli operandi di tipo 'T' e 'T' . Mi chiedo perché, dal momento che capisco l' ==operatore è predefinito per tutti i tipi?

Modifica: grazie a tutti. All'inizio non ho notato che l'affermazione riguardava solo i tipi di riferimento. Ho anche pensato che il confronto bit per bit è previsto per tutti i tipi di valore, che ora so non è corretto.

Ma, nel caso in cui sto usando un tipo di riferimento, l' ==operatore userebbe il confronto di riferimento predefinito, o userebbe la versione sovraccarica dell'operatore se un tipo ne definisse uno?

Modifica 2: attraverso prove ed errori, abbiamo appreso che l' ==operatore utilizzerà il confronto di riferimento predefinito quando utilizza un tipo generico senza restrizioni. In realtà, il compilatore utilizzerà il metodo migliore che può trovare per l'argomento di tipo limitato, ma non cercherà oltre. Ad esempio, il codice seguente verrà sempre stampato true, anche quando Test.test<B>(new B(), new B())viene chiamato:

class A { public static bool operator==(A x, A y) { return true; } }
class B : A { public static bool operator==(B x, B y) { return false; } }
class Test { void test<T>(T a, T b) where T : A { Console.WriteLine(a == b); } }

"... per impostazione predefinita == si comporta come descritto sopra per i tipi di riferimento predefiniti e definiti dall'utente."

Il tipo T non è necessariamente un tipo di riferimento, quindi il compilatore non può fare questa ipotesi.

Tuttavia, questo verrà compilato perché è più esplicito:

    bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }

Seguire la domanda aggiuntiva "Ma, nel caso in cui sto usando un tipo di riferimento, l'operatore == userebbe il confronto di riferimento predefinito o userebbe la versione sovraccarica dell'operatore se un tipo ne definisse uno?"

Avrei pensato che == su Generics avrebbe usato la versione sovraccarica, ma il seguente test dimostra il contrario. Interessante ... Mi piacerebbe sapere perché! Se qualcuno lo sa, per favore condividi.

namespace TestProject
{
 class Program
 {
    static void Main(string[] args)
    {
        Test a = new Test();
        Test b = new Test();

        Console.WriteLine("Inline:");
        bool x = a == b;
        Console.WriteLine("Generic:");
        Compare<Test>(a, b);

    }


    static bool Compare<T>(T x, T y) where T : class
    {
        return x == y;
    }
 }

 class Test
 {
    public static bool operator ==(Test a, Test b)
    {
        Console.WriteLine("Overloaded == called");
        return a.Equals(b);
    }

    public static bool operator !=(Test a, Test b)
    {
        Console.WriteLine("Overloaded != called");
        return a.Equals(b);
    }
  }
}

Produzione

In linea: sovraccarico == chiamato

Generico:

Premere un tasto qualsiasi per continuare . . .

Follow-up 2

Voglio sottolineare che cambiando il mio metodo di confronto in

    static bool Compare<T>(T x, T y) where T : Test
    {
        return x == y;
    }

causa la chiamata dell'operatore overload ==. Immagino che senza specificare il tipo (come dove ), il compilatore non può dedurre che dovrebbe usare l'operatore sovraccarico ... anche se penso che avrebbe abbastanza informazioni per prendere quella decisione anche senza specificare il tipo.

Come altri hanno già detto, funzionerà solo quando T è vincolato ad essere un tipo di riferimento. Senza alcun vincolo, puoi confrontare con null, ma solo null - e tale confronto sarà sempre falso per i tipi di valore non annullabili.

Invece di chiamare Equals, è meglio usare un IComparer<T>- e se non hai più informazioni, EqualityComparer<T>.Defaultè una buona scelta:

public bool Compare<T>(T x, T y)
{
    return EqualityComparer<T>.Default.Equals(x, y);
}

A parte qualsiasi altra cosa, questo evita boxe / casting.

In generale, EqualityComparer<T>.Default.Equalsdovrebbe fare il lavoro con tutto ciò che implementa IEquatable<T>o che ha Equalsun'implementazione ragionevole .

Se, tuttavia, ==e Equalssono implementati diversamente per qualche motivo, il mio lavoro sugli operatori generici dovrebbe essere utile; supporta le versioni operatore di (tra gli altri):

• Uguale (valore T1, valore T2)
• NotEqual (valore T1, valore T2)
• Maggiore (valore T1, valore T2)
• Meno di (valore T1, valore T2)
• GreaterThanOrEqual (valore T1, valore T2)
• LessThanOrEqual (valore T1, valore T2)

Così tante risposte, e non una sola spiega il PERCHÉ? (che Giovanni ha esplicitamente chiesto) ...

I generici .NET non si comportano come modelli C ++. Nei modelli C ++, la risoluzione del sovraccarico si verifica dopo che sono noti i parametri del modello effettivo.

Nei generici .NET (incluso C #), la risoluzione del sovraccarico si verifica senza conoscere i parametri generici effettivi. Le uniche informazioni che il compilatore può utilizzare per scegliere la funzione da chiamare provengono dai vincoli di tipo sui parametri generici.

La compilazione non può sapere che T non può essere una struttura (tipo di valore). Quindi devi dire che può essere solo di tipo di riferimento, penso:

bool Compare<T>(T x, T y) where T : class { return x == y; }

È perché se T potrebbe essere un tipo di valore, potrebbero esserci casi in cui si x == yformerebbe male - nei casi in cui un tipo non ha un operatore == definito. Lo stesso accadrà per questo che è più ovvio:

void CallFoo<T>(T x) { x.foo(); }

Anche questo fallisce, perché potresti passare un tipo T che non avrebbe una funzione foo. C # ti obbliga a assicurarti che tutti i tipi possibili abbiano sempre una funzione foo. Questo è fatto dalla clausola where.

Sembra che senza il vincolo di classe:

bool Compare<T> (T x, T y) where T: class
{
    return x == y;
}

Bisogna rendersi conto che mentre l' operatore eredita un classvincolo , mentre quello di una struttura ha la precedenzaEquals==Object.EqualsValueType.Equals .

Nota che:

bool Compare<T> (T x, T y) where T: struct
{
    return x == y;
}

dà anche lo stesso errore del compilatore.

Finora non capisco perché il compilatore abbia rifiutato un confronto operatore di uguaglianza di tipo valore. So per certo che questo funziona:

bool Compare<T> (T x, T y)
{
    return x.Equals(y);
}

Beh, nel mio caso volevo testare l'operatore di uguaglianza. Avevo bisogno di chiamare il codice sotto gli operatori di uguaglianza senza impostare esplicitamente il tipo generico. I consigli per EqualityComparernon sono stati utili come metodo EqualityComparerchiamato Equalsma non l'operatore di uguaglianza.

Ecco come ho ottenuto questo lavoro con tipi generici creando un LINQ. Chiama il codice giusto per ==e !=operatori:

/// <summary>
/// Gets the result of "a == b"
/// </summary>
public bool GetEqualityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.Equal(paramA, paramB);
    // compile it
    var invokeEqualityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeEqualityOperator(a, b);
}

/// <summary>
/// Gets the result of "a =! b"
/// </summary>
public bool GetInequalityOperatorResult<T>(T a, T b)
{
    // declare the parameters
    var paramA = Expression.Parameter(typeof(T), nameof(a));
    var paramB = Expression.Parameter(typeof(T), nameof(b));
    // get equality expression for the parameters
    var body = Expression.NotEqual(paramA, paramB);
    // compile it
    var invokeInequalityOperator = Expression.Lambda<Func<T, T, bool>>(body, paramA, paramB).Compile();
    // call it
    return invokeInequalityOperator(a, b);
}

C'è una voce MSDN Connect per questo qui

La risposta di Alex Turner inizia con:

Sfortunatamente, questo comportamento è in base alla progettazione e non esiste una soluzione semplice per consentire l'uso di == con parametri di tipo che possono contenere tipi di valore.

Se vuoi assicurarti che vengano chiamati gli operatori del tuo tipo personalizzato, puoi farlo tramite la riflessione. Basta ottenere il tipo utilizzando il parametro generico e recuperare MethodInfo per l'operatore desiderato (ad esempio op_Equality, op_Inequality, op_LessThan ...).

var methodInfo = typeof (T).GetMethod("op_Equality", 
                             BindingFlags.Static | BindingFlags.Public);    

Quindi eseguire l'operatore utilizzando il metodo Invoke di MethodInfo e passare gli oggetti come parametri.

var result = (bool) methodInfo.Invoke(null, new object[] { object1, object2});

Ciò invocherà l'operatore sovraccarico e non quello definito dai vincoli applicati al parametro generico. Potrebbe non essere pratico, ma potrebbe tornare utile per testare le unità degli operatori quando si utilizza una classe base generica che contiene un paio di test.

Ho scritto la seguente funzione guardando l'ultimo msdn. Può facilmente confrontare due oggetti xe y:

static bool IsLessThan(T x, T y) 
{
    return ((IComparable)(x)).CompareTo(y) <= 0;
}

bool Compare(T x, T y) where T : class { return x == y; }

Quanto sopra funzionerà perché == è curato in caso di tipi di riferimento definiti dall'utente.
In caso di tipi di valore, == può essere ignorato. In tal caso, dovrebbe essere definito anche "! =".

Penso che potrebbe essere la ragione, non consente il confronto generico utilizzando "==".

Il .Equals()funziona per me, mentre TKeyè un tipo generico.

public virtual TOutputDto GetOne(TKey id)
{
    var entity =
        _unitOfWork.BaseRepository
            .FindByCondition(x => 
                !x.IsDelete && 
                x.Id.Equals(id))
            .SingleOrDefault();


    // ...
}