C # Entity Framework (сначала код), реализация операций CRUD на модели

Question

Мне просто интересно, можете ли вы сохранить функцию в модели (транзакции CRUD), которая будет выглядеть примерно так:

Мой существующий код:

public class tbluser
{
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int id { get; set; }

    [Required(ErrorMessage = "Username is required")]
    public string username { get; set; }

    [Required(ErrorMessage = "Password is required")]
    public string password { get; set; }

    public static List<tbluser> list()
    {
        using (var db = new sample())
        {
            var user = db.tbluser.ToList();
            return user;
        }
    }
}

Что я хочу:

public class tbluser:DbContext
{
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int id { get; set; }

    [Required(ErrorMessage = "Username is required")]
    public string username { get; set; }

    [Required(ErrorMessage = "Password is required")]
    public string password { get; set; }


    public static List<tbluser> list()
    {
        return this.toList();
    }
}

Я просто хочу спросить также, подходит ли этот метод реализации Entity Framework.

Answer 1

Существует один известный принцип под названием " Разделение проблем ", который очень рассердится, если вы сделаете это.Мой совет - сохранить код простым, значимым и слабо связанным.

Answer 2

Вот краткий пример того, как вы можете настроить простую реализацию Code First для начала работы.

Сначала определите свою модель User.Атрибут Key для целочисленного типа автоматически настраивает для вас свойство identity.Затем вам может потребоваться индекс по имени пользователя, если вы планируете делать частые поиски по имени пользователя (чтобы получить информацию о пользователе или подтвердить пароль).

public class User
{
    [Key] // Becomes identity by default
    public int Id { get; set; }
    [Index("IX_User_Username", IsUnique = true)]
    public string Username { get; set; }
    public string Password { get; set; }
}

Затем вы можете определить

public class AppDataContext : DbContext
{
    public AppDataContext() : base("name=DBConnection") { }
    public DbSet<User> Users { get; set; }
}

Вам просто нужно убедиться, что в вашем конфигурационном файле есть строка подключения, соответствующая переданному имени.

<connectionStrings>
    <add name="DBConnection"  providerName="System.Data.SqlClient"
        connectionString="Data Source=instancePath;Initial Catalog=dbName;Integrated Security=true;MultipleActiveResultSets=True" />
</connectionStrings>

Теперь это позволит вам создавать репозитории, такие как:

public class UserRepo : IDisposable
{
    public Lazy<AppDataContext> _db = new Lazy<AppDataContext>(() => new AppDataContext());

    public IQueryable<User> Get() => _db.Value.Users.AsQueryable();
    public IList<User> GetAll() => _db.Value.Users.ToList();

    public void Dispose()
    {
        if (_db.IsValueCreated)
            _db.Value.Dispose();
    }
}

Итак, вы можете использовать репо или контекст напрямую.

// Use the repo
using (var userRepo = new UserRepo())
{
    var allUsers = userRepo.GetAll();
    var user = userRepo.Get().FirstOrDefault(m => m.Username == "myUsername");
}
// Or just use the data context
using (var db = new AppDataContext())
{
    var allUsers = db.Users.ToList(); // Get all users
    var user = db.Users.FirstOrDefault(m => m.Username == "myUsername");
}

Для получения дополнительной информации, вот несколько полезных ссылок с большими деталями:

• Простой пример
• Аннотации данных
• Конфигурирование инициализатора
• Миграции

Answer 3

Код, подобный этому, будет очень проблематичным.

В первом примере вы тесно связываете экземпляр DbContext с сущностью.Вызов tblUser.list () вернет список пользовательских сущностей, но теперь они будут выходить за рамки DbContext.(Из-за закрытия блока using()) Это означает, что любые ленивые вызовы загрузки для извлечения связанных сущностей завершатся неудачно, и вы не сможете сохранить какие-либо изменения в сущностях, пока они не будут повторно присоединены к другому DbContext.Это становится очень грязным, очень быстрым.

Во втором примере вы расширяете DbContext, что означает, что каждая «сущность» эффективно определяет область применения DbContext для заполнения своих экземпляров.Вы не можете просто «статически» обернуть метод, потому что он не будет иметь видимости для нестатических DbSets, унаследованных от DbContext.

Это было бы ужасно с точки зрения производительности, и с точки зрения кода выглядело быпросто странно:

Т.е.

using (var user = new tbluser)
{
   var users = user.list(); // not static.
   // .. Do stuff..
}

Сделать статичным было бы проблематично, потому что DbContext должен был бы быть статически ограничен внутри tbluser

public class tbluser
{
   private static MyContext _context = new MyContext();

   // ...

   public static List<tbluser> list()
   {
      return _context.tblusers.ToList();
   }
}

И это можетпо-прежнему возникают проблемы, такие как расположение статического экземпляра до того, как он будет удаленно функционировать, но я, конечно, не могу рекомендовать такой подход.

Вместо этого используйте DbContext, как предполагалось.Посмотрите на контейнеры IoC, такие как Unity или Autofac, чтобы управлять областью жизни для DbContext и внедрить экземпляр как зависимость в классы, которые в этом нуждаются, или как минимум обернуть его в блок using() {} и обработать его как хранилище с егоDbSets.

Существует множество примеров эффективного использования DbContext, использования шаблонов Repositories и Unit of Work с внедрением зависимостей.Освойте их, прежде чем пытаться раскрутить что-то уникальное.Будущие разработчики, просматривающие ваш код, будут вам благодарны.:)