Làm cách nào để thực hiện nguyên tắc DRY khi sử dụng từ khóa 'bằng cách sử dụng'?

Hãy xem xét các phương pháp sau:

public List<Employee> GetAllEmployees()
{
    using (Entities entities = new Entities())
    {
        return entities.Employees.ToList();
    }
}

public List<Job> GetAllJobs()
{
    using (Entities entities = new Entities())
    {
        return entities.Jobs.ToList();
    }
}

public List<Task> GetAllTasksOfTheJob(Job job)
{
    using (Entities entities = new Entities())
    {
        return entities.Tasks.Where(t => t.JobId == job.Id).ToList();
    }
}

Sử dụng khối là như nhau và đã được lặp lại 3 lần ở đây (tất nhiên, hơn 100 lần trong ứng dụng thực). Làm thế nào có thể thực hiện hiệu trưởng DRY (Đừng lặp lại chính mình) cho usingkhối? Có bị coi là vi phạm tiền gốc DRY không?

Cập nhật: Tôi không nói về những gì đã được thực hiện trong usingkhối. Những gì tôi thực sự có nghĩa ở đây, là using (Entities entities = new Entities()). Dòng này được lặp lại 100 lần trở lên.

Một ý tưởng sẽ là bọc nó với một hàm có một Func.

Một cái gì đó như thế này

public K UsingT<T,K>(Func<T,K> f) where T:IDisposable,new()
{
    using (T t = new T())
    {
        return f(t);
    }
}

Sau đó, mã trên của bạn trở thành

public List<Employee> GetAllEmployees()
{
    return UsingT<Entities,List<Employee>>(e=>e.Employees.ToList());
}

public List<Job> GetAllJobs()
{
    return UsingT<Entities,List<Job>>(e=>e.Jobs.ToList());
}

public List<Task> GetAllTasksOfTheJob(Job job)
{
    return UsingT<Entities,List<Task>>(e=>e.Tasks.Where(t => t.JobId == job.Id).ToList());
}

Tôi cũng đã tạo Entitiesmột loại param, vì tôi cho rằng bạn có nhiều hơn một loại bạn đang làm điều này với. Nếu bạn không, bạn có thể xóa nó và chỉ sử dụng kiểu param cho kiểu trả về.

Thành thật mà nói mặc dù loại mã này không giúp đọc được gì cả. Theo kinh nghiệm của tôi, các đồng nghiệp của Jr cũng có một thời gian thực sự khó khăn với nó.

Cập nhật Một số biến thể bổ sung về người trợ giúp bạn có thể xem xét

//forget the Entities type param
public T UsingEntities<T>(Func<Entities,T> f)
{
    using (Entities e = new Entities())
    {
        return f(e);
    }
}
//forget the Entities type param, and return an IList
public IList<T> ListFromEntities<T>(Func<Entities,IEnumerable<T>> f)
{
    using (Entities e = new Entities())
    {
        return f(e).ToList();
    }
}
//doing the .ToList() forces the results to enumerate before `e` gets disposed.

Đối với tôi điều này sẽ giống như lo lắng về việc tìm kiếm trên cùng một bộ sưu tập nhiều lần: đó chỉ là việc bạn cần làm. Bất kỳ nỗ lực để trừu tượng hóa nó hơn nữa sẽ làm cho mã ít dễ đọc hơn.

Có vẻ như bạn đang nhầm lẫn nguyên tắc "Một lần và Chỉ một lần" với nguyên tắc DRY. Nguyên tắc DRY nêu rõ:

Mỗi phần kiến ​​thức phải có một đại diện duy nhất, rõ ràng, có thẩm quyền trong một hệ thống.

Tuy nhiên, nguyên tắc Một lần và Chỉ một lần là hơi khác nhau.

Nguyên tắc [DRY] tương tự như AgainAndOnlyOnce, nhưng với một mục tiêu khác. Với AgainAndOnlyOnce, bạn được khuyến khích tái cấu trúc để loại bỏ mã và chức năng trùng lặp. Với DRY, bạn cố gắng xác định nguồn duy nhất, dứt khoát của mọi phần kiến ​​thức được sử dụng trong hệ thống của bạn và sau đó sử dụng nguồn đó để tạo các phiên bản áp dụng của kiến ​​thức đó (mã, tài liệu, bài kiểm tra, v.v.).

Nguyên tắc DRY thường được sử dụng trong bối cảnh logic thực tế, không quá nhiều sử dụng các câu lệnh:

Giữ cấu trúc của một chương trình DRY khó hơn và giá trị thấp hơn. Đó là quy tắc kinh doanh, câu lệnh if, công thức toán học và siêu dữ liệu chỉ xuất hiện ở một nơi. Nội dung WET - các trang HTML, dữ liệu kiểm tra dự phòng, dấu phẩy và {} dấu phân cách - tất cả đều dễ dàng bỏ qua, do đó, DRYing chúng ít quan trọng hơn.

Nguồn

Tôi không thấy việc sử dụng usingở đây:

Làm thế nào về:

public List<Employee> GetAllEmployees() {
    return (new Entities()).Employees.ToList();
}
public List<Job> GetAllJobs() {
    return (new Entities()).Jobs.ToList();
}
public List<Task> GetAllTasksOfTheJob(Job job) {
    return (new Entities()).Tasks.Where(t => t.JobId == job.Id).ToList();
}

Hoặc thậm chí tốt hơn, vì tôi không nghĩ rằng bạn cần tạo một đối tượng mới mỗi lần.

private Entities entities = new Entities();//not sure C# allows for that kind of initialization, but you can do it in the constructor if needed

public List<Employee> GetAllEmployees() {
    return entities.Employees.ToList();
}
public List<Job> GetAllJobs() {
    return entities.Jobs.ToList();
}
public List<Task> GetAllTasksOfTheJob(Job job) {
    return entities.Tasks.Where(t => t.JobId == job.Id).ToList();
}

Đối với vi phạm DRY: DRY không áp dụng ở cấp độ này. Trong thực tế không có nguyên tắc thực sự làm, ngoại trừ khả năng đọc. Cố gắng áp dụng DRY ở cấp độ đó thực sự chỉ là tối ưu hóa vi mô kiến ​​trúc, giống như tất cả tối ưu hóa vi mô chỉ là đổ xe đạp và không giải quyết được bất kỳ vấn đề nào, nhưng thậm chí có rủi ro để giới thiệu những vấn đề mới.
Từ kinh nghiệm của riêng tôi, tôi biết rằng nếu bạn cố gắng giảm sự dư thừa mã ở mức đó, bạn sẽ tạo ra tác động tiêu cực đến chất lượng mã, bằng cách che giấu những gì thực sự rõ ràng và đơn giản.

Chỉnh sửa:
Ok. Vì vậy, vấn đề không thực sự là câu lệnh sử dụng, vấn đề là sự phụ thuộc vào đối tượng bạn tạo ra mỗi lần. Tôi sẽ đề nghị tiêm một constructor:

private delegate Entities query();//this should be injected from the outside (upon construction for example)
public List<Employee> GetAllEmployees() {
    using (var entities = query()) {//AFAIK C# can infer the type here
        return entities.Employees.ToList();
    }
}
//... and so on

Không chỉ sử dụng là mã trùng lặp (bằng cách đó là mã trùng lặp và thực sự so sánh với một câu lệnh try..catch..finally) mà cả toList cũng vậy. Tôi sẽ cấu trúc lại mã của bạn như thế này:

 public List<T> GetAll(Func<Entities, IEnumerable<T>> getter) {
    using (Entities entities = new Entities())
    {
        return getter().ToList();
    }
 }

public List<Employee> GetAllEmployees()
{
    return GetAll(e => e.Employees);
}

public List<Job> GetAllJobs()
{
    return GetAll(e => e.Jobs);
}

public List<Task> GetAllTasksOfTheJob(Job job)
{
    return GetAll(e => e.Tasks.Where(t => t.JobId == job.Id));
}

Vì không có logic kinh doanh của bất kỳ loại nào ở đây ngoại trừ cái cuối cùng. Nó không thực sự KHÔ, theo quan điểm của tôi.

Cái cuối cùng không có bất kỳ DRY nào trong khối sử dụng nhưng tôi đoán mệnh đề where sẽ thay đổi ở đâu khi nó được sử dụng.

Đây là một công việc điển hình cho các trình tạo mã. Viết và bao gồm trình tạo mã và để nó tạo cho từng loại.

Vì bạn đang tạo và hủy bỏ cùng một đối tượng dùng một lần, lớp của bạn là một ứng cử viên tốt để thực hiện mẫu IDis Dùng một lần.

class ThisClass : IDisposable
{
    protected virtual Entities Context { get; set; }

    protected virtual void Dispose( bool disposing )
    {
        if ( disposing && Context != null )
            Context.Dispose();
    }

    public void Dispose()
    {
        Dispose( true );
    }

    public ThisClass()
    {
        Context = new Entities();
    }

    public List<Employee> GetAllEmployees()
    {
        return Context.Employees.ToList();
    }

    public List<Job> GetAllJobs()
    {
        return Context.Jobs.ToList();
    }

    public List<Task> GetAllTasksOfTheJob(Job job)
    {
        return Context.Tasks.Where(t => t.JobId == job.Id).ToList();
    }
}

Điều này khiến bạn chỉ cần "sử dụng" khi tạo một thể hiện của lớp. Nếu bạn không muốn lớp chịu trách nhiệm xử lý các đối tượng, thì bạn có thể làm cho các phương thức chấp nhận sự phụ thuộc như một đối số:

public static List<Employee> GetAllEmployees( Entities entities )
{
    return entities.Employees.ToList();
}

public static List<Job> GetAllJobs( Entities entities )
{
    return entities.Jobs.ToList();
}

public static List<Task> GetAllTasksOfTheJob( Entities entities, Job job )
{
    return entities.Tasks.Where(t => t.JobId == job.Id).ToList();
}

Một chút yêu thích của tôi về phép thuật không thể so sánh!

public class Blah
{
  IEnumerable<T> Wrap(Func<Entities, IEnumerable<T>> act)
  {
    using(var entities = new Entities()) { return act(entities); }
  }

  public List<Employee> GetAllEmployees()
  {
    return Wrap(e => e.Employees.ToList());
  }

  public List<Job> GetAllJobs()
  {
    return Wrap(e => e.Jobs.ToList());
  }

  public List<Task> GetAllTasksOfTheJob(Job job)
  {
    return Wrap(e => e.Tasks.Where(x ....).ToList());
  }
}

Wrapchỉ tồn tại để trừu tượng ra hoặc bất kỳ phép thuật nào bạn cần. Tôi không chắc chắn tôi sẽ khuyên bạn điều này mọi lúc nhưng nó có thể sử dụng. Ý tưởng "tốt hơn" sẽ là sử dụng một thùng chứa DI, như StructMap, và chỉ phạm vi lớp Thực thể cho bối cảnh yêu cầu, đưa nó vào bộ điều khiển và sau đó để nó xử lý vòng đời mà không cần bộ điều khiển của bạn.