7
votes

Pourquoi comparer un seul élément contre un iNeumable n'est pas une erreur de compilation

var fooRef = new FooRef();
var fooRefEnumerable = Enumerable.Empty<FooRef>();

var fooRefEquality = (fooRef == fooRefEnumerable); //This compiles without any errors

var fooVal = new FooVal();
var fooValEnumerable = Enumerable.Empty<FooVal>();

//Compilation error : Error 1 Operator '==' cannot be applied to operands of type 'FooVal' and 'System.Collections.Generic.IEnumerable<FooVal>'
var fooValEquality = (fooVal == fooValEnumerable); 

public class FooRef { }
public struct FooVal { }   
Why is it comparing a single object and an IEnumerable valid for RefTypes?

0 commentaires

3 Réponses :


1
votes

La raison pour laquelle vous rencontrez est que FooVoval (votre structure) est un type différent de celui du type fox -enumérable (type iEnumerable). La structure est le type de valeur et vous ne pouvez pas le comparer à un type de référence comme celui-là.


0 commentaires

9
votes

Pourquoi est-ce que c'est comparer un seul objet et un iénumérable est valable pour Reftypes?

Parce que c'est tout à fait réalisable qu'il retournerait true : xxx

Notez que cela utilise les mêmes types de compilation pour fooref et foorefenumerable tel que vous utilisez.

Si vous scellez fooref , le compilateur sait que c'est impossible < / em> pour un fooref Référence Pour aussi être une référence iEnumerable , vous obtiendrez une erreur de compilation.


3 commentaires

+1 grande réponse. En plus de plus en plus, si vous voulez vraiment pouvoir écrire structure == objet , vous pouvez également remplacer l'opérateur d'égalité dans la structure. Voir ici pour un exemple.


@Xenolightning: Vous voulez dire surcharge, mais oui :)


Tu m'as eu! Mon excuse est que c'est tôt le matin! :-P



0
votes

Le jeton == est utilisé pour représenter deux opérateurs différents, qui seraient représentées dans certaines langues (telles que VB) être représentées avec des jetons différents. Si l'un des types d'opérande a une surcharge définie applicable à l'autre type, alors == représentera un opérateur d'égalité surcharge et utilisera cette surcharge. Sinon, si les deux opérandes sont des types de référence et qu'il leur serait possible d'identifier le même objet (non nuls), il représentera un opérateur d'égalité de référence. Notez que la sémantique d'un test d'égalité de référence est bien définie pour toute combinaison de types; Si X identifie une pomme et Y identifie une orange, la question "do x et y identifier le même objet" peut être répondu sans difficulté (c'est toujours "non"). C # aboutira à de telles comparaisons sur la base qu'une tentative de comparer les choses qui tentent de poser une question dont la réponse est toujours "non" est d'une erreur, mais si par exemple. X est non cassé la classe automobile et y est une ifloatable, le compilateur permettra la possibilité que X et Y puissent identifier le même véhicule amphibie (qui dérive de l'automobile et des outils ifloats. Notez que si x étaient un scellé la classe [ou une structure, qui serait nécessairement scellée], le compilateur reconnaîtrait que si la classe de X n'ait pas implémenter ifloattable , x ne peut pas identifier un objet qui fait.


0 commentaires