Différence entre contient et égal (==)

J’ai une propriété de dictionnaire

public Dictionary SearchType { get; set; } 

ce dictionnaire a 4 clés et 4 valeurs pour ces clés. Maintenant, je les prends dans une variable de SearchType, si les valeurs sont vraies

 var searchTypes = searchDetail.SearchType.Where(x => x.Value == true).ToList(); 

Ici, j’ai vérifié que la clé est CKBinstituteType ou CKBstate, etc., à partir du code ci-dessous.

 foreach (var searchType in searchTypes) { if (searchType.Key.Contains("CKBinstituteType")) { } if (searchType.Key.Contains("CKBstate")) { } if (searchType.Key.Contains("CKBlocation")) { } if (searchType.Key.Contains("CKBdistance")) { } } 

ou essayé avec cette méthode (opération égale utilisée au lieu de contient)

 foreach (var searchType in searchTypes) { if (searchType.Key == "CKBinstituteType") { } if (searchType.Key == "CKBstate") { } if (searchType.Key == "CKBlocation") { } if (searchType.Key == "CKBdistance") { } } 

Quelle est la différence entre eux? Lequel est bon pour ma situation? (comme la performance, le code standard, etc.)

Quelle est la différence entre eux?

Contains et Equals utilisent la comparaison de chaînes. Étant donné que votre Key est de type chaîne, la commande Contains vérifie si le paramètre transmis fait partie de la clé, alors que Equals compare la chaîne complète à l’égalité.

Lequel est bon pour ma situation? (comme la performance, le code standard, etc.)

Utilisez la méthode ContainsKey au lieu de ssortingng est égal à ou contient. Contains et Equals sont utilisés dans la boucle foreach , où vous comparez la Key qui est une ssortingng avec Contains et Equals . Vous n’avez pas besoin de parcourir chaque élément du dictionnaire. Si vous essayez d’y accéder via Key, il s’agit d’effectuer une recherche linéaire avec une complexité de O(n) vs d’effectuer une recherche dans un dictionnaire avec une complexité O(1)

Vous pouvez utiliser ContainsKey Like

 if (SearchType.ContainsKey("CKBinstituteType")) { } 

Actuellement, vous convertissez votre dictionnaire en liste, je ne sais pas s’il est vraiment nécessaire que votre dictionnaire soit en liste, puis effectuez une recherche linéaire. Si vous devez vraiment filtrer le dictionnaire en fonction de valeurs true projetez le jeu de résultats dans un dictionnaire, puis utilisez ContainsKey comme ContainsKey :

 var searchTypes = searchDetail.SearchType.Where(r => r.Value == true) .ToDictionary(r => r.Key, r => r.Value); if (searchTypes.ContainsKey("CKBinstituteType")) { } if (searchTypes.ContainsKey("CKBstate")) { } if (searchTypes.ContainsKey("CKBlocation")) { } if (searchTypes.ContainsKey("CKBdistance")) { } 

La différence est que

 ssortingngExpr.Contains("CKBinstituteType") 

vérifie s’il existe une sous-chaîne de ssortingngExpr qui est égale à "CKBinstituteType" , alors que

 ssortingngExpr == "CKBinstituteType" 

vérifie si ssortingngExpr est égal à "CKBinstituteType" .

Dans les deux cas, une comparaison ordinale (qui est invariante de la culture) est utilisée. Comme exemple explicite

 "xyzxyzCKBinstituteTypexyzxyzxyz".Contains("CKBinstituteType") 

est true alors que

 "xyzxyzCKBinstituteTypexyzxyzxyz" == "CKBinstituteType" 

est false .


Performance: ssortingngExpr.Contains("CKBinstituteType") sera plus lent que ssortingngExpr == "CKBinstituteType" . Notez que je ne parle pas du fait que ces chaînes sont des clés dans un Dictionary . Voir la réponse de Habib. Un Dictionary<,> offre une recherche rapide (O (1)) sur une clé. Vous n’utilisez pas cela lorsque vous dict.Where(x => criterion).ToList() .

contains() recherche une sous-chaîne, où equals() recherche une chaîne entière, et une autre différence est, contains() prend un object de la classe CharSequence, où equals() prend un object comme paramètre.

En ce qui concerne simplement si l’utilisation de Compare ou Equals sur des chaînes équivalentes fait une différence:

En utilisant ReSharper pour voir le code source de Compare, la première chose à faire est

 if ((Object)strA == (Object)strB) { return 0; } 

Il semble donc qu’elles seraient essentiellement les mêmes pour des chaînes équivalentes.

En ce qui concerne les performances, ce blog discute de la différence, bien que les commentaires incluent les comparaisons les plus utiles. La plupart des commentateurs semblaient trouver une différence négligeable, même après les avoir exécutés dans de très grandes boucles. Le dernier commentaire montre cependant une grande différence entre Equals et Contains et me fait me demander pourquoi les résultats ne reflètent pas plus fidèlement les autres.