Pourquoi je reçois un résultat différent de deux expressions presque égales pour obtenir des données de la base de données à l'aide d'un cadre de cadre d'entité

La recherche SQL est insensible à la casse et lorsque vous faites le tolist code> vous finissez par faire une comparaison sensible à la casse. Mais le tolist code> retournera tout de la DB. Au lieu de faire le où code> sur la base de données db, puis une autre comparaison pour vous assurer que le mot de passe est le cas correct.

using (var context = new MyDbContext(ConnectionString))
{
  var users = context.Users.Where(x => x.Name == userName && x.Password == password).ToList();
  return users.FirstOrDefault(x =>  x.Password.Equals(password)));
}

Il y a une réponse plus détaillée à cela ici:

https://stackoverflow.com/a/3843382/933416

Si vous en avez besoin, vous pouvez configurer la colonne pour être sensible à la casse du côté serveur. Mais dans votre cas, je ne vois pas pourquoi vous avez même besoin d'interroger le mot de passe. Il n'y a sûrement qu'un mot de passe pour chaque nom d'utilisateur et un nom d'utilisateur est censé être insensible à la casse - alors pourquoi pas seulement interroger le nom d'utilisateur, puis vérifier le mot de passe sur le résultat?

Comme @nmClean mentionné, c'est parce que votre base de données est configurée pour effectuer des comparaisons insensibles de cas. Le petit programme suivant montre comment EF ignore complètement les valeurs code> StringComParison code> transmettes à string.equals code>. Il montre également comment changer la collation de la colonne de base de données permet de réaliser ce dont vous avez besoin.

Il s'agit d'un concept impossible lorsque vous travaillez avec EF (et d'autres fournisseurs LINQ également). Votre requête tel qu'il est écrit looks em> comme le code .NET normal. Cependant, ce n'est pas! De nombreux fournisseurs traduisent le code à quelque chose de complètement différent, dans ce cas SQL (pour SQL Server, Transact-SQL). Seul un sous-ensemble des méthodes .NET disponibles fonctionnera du tout (c'est pourquoi, par exemple, vous ne pouvez pas utiliser regex code> dans une requête EF), et ceux qui travaillent peuvent présenter un comportement subtilement différent. comparé à ce que vous attendez. p>

où vous utilisez tolist () code> sur une requête, puis em> Appliquez votre filtre, vous utilisez réellement LINQ vers des objets , pas ef, pour appliquer le filtre. Linq aux objets est em> "réel" .NET, vous disposez donc de la gamme complète de fonctionnalités .NET à votre disposition. Bien sûr, vous perdez l'avantage d'avoir votre code exécuté sur le serveur SQL, ce n'est donc généralement pas une option. P>

using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;
using System.Linq;

namespace ConsoleApplication2
{
    public class Initializer<T> : DropCreateDatabaseAlways<T> where T : DbContext
    {
        protected override void Seed(T context)
        {
            base.Seed(context);

            // Comment out this line and note how the count changes.
            context.Database.ExecuteSqlCommand("ALTER TABLE MyEntity ALTER COLUMN MyString nvarchar(MAX) COLLATE Latin1_General_CS_AS");
        }
    }

    [Table("MyEntity")]
    public class MyEntity
    {
        [Key]
        public virtual int MyEntityId { get; set; }

        [Required]
        public virtual string MyString { get; set; }
    }

    public class MyContext : DbContext
    {
        public DbSet<MyEntity> Entities
        {
            get { return this.Set<MyEntity>(); }
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            var e = modelBuilder.Entity<MyEntity>();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Database.SetInitializer(new Initializer<MyContext>());

            using (MyContext context = new MyContext())
            {
                context.Entities.Add(new MyEntity { MyString = "aaa" });
                context.Entities.Add(new MyEntity { MyString = "AAA" });

                context.SaveChanges();
            }

            using (MyContext context = new MyContext())
            {
                var caseSensitiveQuery = from e in context.Entities
                                         where e.MyString.Equals("aaa", StringComparison.Ordinal)
                                         select e;

                var caseInsensitiveQuery = from e in context.Entities
                                           where e.MyString.Equals("aaa", StringComparison.OrdinalIgnoreCase)
                                           select e;

                // Note how the StringComparison parameter is completely ignored.  Both EF queries are identical.
                Console.WriteLine("Case sensitive query (count = {0}):\r\n{1}", caseSensitiveQuery.Count(), caseSensitiveQuery);
                Console.WriteLine();

                Console.WriteLine("Case insensitive query (count = {0}):\r\n{1}", caseInsensitiveQuery.Count(), caseInsensitiveQuery);
            }

            Console.ReadLine();
        }
    }
}

Comme tout le monde l'a déjà mentionné, la cause du problème est que SQL Server par défaut de non sensible à la casse et c # par défaut à la case sensible à la casse.

Vous pouvez modifier le champ de mot de passe de varchar à varbinaire pour contourner ce problème.