วิธีการใช้หลักการ DRY เมื่อใช้คำหลัก 'ใช้'?

พิจารณาวิธีการเหล่านี้:

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();
    }
}

การใช้บล็อกเหมือนกันและทำซ้ำ 3 ครั้งที่นี่ (แน่นอนมากกว่า 100 ครั้งในแอปพลิเคชันจริง) เป็นไปได้อย่างไรที่จะนำหลักการ DRY (อย่าซ้ำตัวเอง) ไปใช้กับusingบล็อก มันถือเป็นการฝ่าฝืนหลักการของ DRY หรือไม่?

อัปเดต: ฉันไม่ได้พูดถึงสิ่งที่นำไปใช้ในusingบล็อก using (Entities entities = new Entities())สิ่งที่จริงผมหมายถึงที่นี่เป็น บรรทัดนี้ทำซ้ำ 100 ครั้งหรือมากกว่า

Funcหนึ่งความคิดที่จะห่อด้วยฟังก์ชั่นที่ใช้เป็น

บางสิ่งเช่นนี้

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

จากนั้นโค้ดด้านบนของคุณจะกลายเป็น

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());
}

ฉันทำEntitiesแบบพารามิเตอร์เช่นกันเพราะฉันคิดว่าคุณมีมากกว่าหนึ่งประเภทที่คุณทำเช่นนี้ หากคุณไม่ได้คุณสามารถลบออกและเพียงแค่ใช้ประเภทพารามิเตอร์สำหรับประเภทกลับ

จะซื่อสัตย์แม้ว่ารหัสประเภทนี้ไม่ได้ช่วยให้อ่านง่ายเลย จากประสบการณ์ของฉันเพื่อนร่วมงานจูเนียร์มากขึ้นก็มีช่วงเวลาที่ยากลำบากเช่นกัน

อัปเดต รูปแบบเพิ่มเติมบางอย่างเกี่ยวกับผู้ช่วยเหลือที่คุณอาจพิจารณา

//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.

สำหรับฉันนี่จะเป็นเรื่องที่กังวลเกี่ยวกับการเก็บสะสมเดียวกันหลาย ๆ ครั้ง: มันเป็นสิ่งที่คุณต้องทำ ความพยายามใด ๆ ที่จะทำให้เป็นนามธรรมเพิ่มเติมจะทำให้โค้ดอ่านน้อยลงมาก

ดูเหมือนว่าคุณกำลังสับสนกับหลักการ "กาลครั้งเดียวเท่านั้น" กับหลักการอบแห้ง หลักการของ DRY:

ความรู้ทุกชิ้นจะต้องมีการเป็นตัวแทนเพียงหนึ่งเดียวไม่คลุมเครือและเชื่อถือได้ภายในระบบ

อย่างไรก็ตามหลักการในกาลครั้งเดียวมีความแตกต่างกันเล็กน้อย

[DRY] หลักการคล้ายกับ OnceAndOnlyOnce แต่มีวัตถุประสงค์แตกต่างกัน ด้วย OnceAndOnlyOnce คุณจะได้รับการสนับสนุนให้ปรับโครงสร้างเพื่อกำจัดรหัสและฟังก์ชันการทำงานที่ซ้ำซ้อน ด้วย DRY คุณจะพยายามระบุแหล่งที่มาที่ชัดเจนของความรู้ทุกชิ้นที่ใช้ในระบบของคุณจากนั้นใช้แหล่งข้อมูลนั้นเพื่อสร้างอินสแตนซ์ของความรู้นั้น (รหัสเอกสารการทดสอบและอื่น ๆ )

หลักการ DRY มักจะใช้ในบริบทของตรรกะที่แท้จริงไม่มากเกินไปโดยใช้คำสั่ง:

การรักษาโครงสร้างของโปรแกรม DRY นั้นยากกว่าและมีค่าต่ำกว่า มันเป็นกฎเกณฑ์ทางธุรกิจข้อความ if if สูตรคณิตศาสตร์และข้อมูลเมตาที่ควรปรากฏในที่เดียว สิ่งของเปียก - หน้า HTML, ข้อมูลการทดสอบซ้ำ, จุลภาคและตัวคั่น {} - ทั้งหมดง่ายต่อการเพิกเฉยดังนั้นการอบแห้งมีความสำคัญน้อยกว่า

แหล่ง

ฉันไม่เห็นการใช้usingที่นี่:

เกี่ยวกับ:

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();
}

หรือดีกว่านี้เพราะฉันไม่คิดว่าคุณต้องสร้างวัตถุใหม่ทุกครั้ง

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();
}

สำหรับการละเมิด DRY: DRY ใช้ไม่ได้กับระดับนี้ ในความเป็นจริงไม่มีหลักการใดที่ทำได้ยกเว้นว่าอ่านได้ การพยายามใช้ DRY ในระดับนั้นจริงๆแล้วเป็นเพียงการเพิ่มประสิทธิภาพทางสถาปัตยกรรมขนาดเล็กซึ่งการเพิ่มประสิทธิภาพแบบ micro ทั้งหมดนั้นเป็นเพียงการปลดจักรยานและไม่ได้รับการแก้ไขปัญหาใด ๆ แต่ยังมีความเสี่ยงในการแนะนำใหม่
จากประสบการณ์ของฉันเองฉันรู้ว่าถ้าคุณพยายามลดความซ้ำซ้อนของรหัสในระดับนั้นคุณจะสร้างผลกระทบด้านลบต่อคุณภาพของรหัสโดยทำให้สับสนกับสิ่งที่ชัดเจนและเรียบง่าย

แก้ไข:
ตกลง ดังนั้นปัญหาจึงไม่ใช่คำสั่งที่ใช้จริงปัญหาคือการพึ่งพาวัตถุที่คุณสร้างขึ้นทุกครั้ง ฉันขอแนะนำให้ฉีดนวกรรมิก:

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

ไม่เพียง แต่ใช้เป็นรหัสที่ซ้ำกัน (โดยวิธีการเป็นรหัสที่ซ้ำกันและเปรียบเทียบจริง ๆ กับคำสั่ง try..catch..finally) แต่ toList ยัง ฉันจะ refactor รหัสของคุณเช่นนี้:

 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));
}

เนื่องจากไม่มีตรรกะทางธุรกิจของการจัดเรียงใด ๆ ที่นี่ยกเว้นสำหรับการล่าสุด มันไม่แห้งจริงๆในมุมมองของฉัน

อันสุดท้ายไม่มี DRY ใด ๆ ในบล็อกการใช้งาน แต่ฉันเดาว่าประโยคใดควรเปลี่ยนตำแหน่งที่เคยใช้

นี่เป็นงานทั่วไปสำหรับตัวสร้างรหัส เขียนและครอบคลุมตัวสร้างโค้ดและปล่อยให้มันสร้างสำหรับแต่ละประเภท

เนื่องจากคุณกำลังสร้างและทำลายวัตถุที่ใช้แล้วทิ้งที่เหมือนกันซ้ำแล้วซ้ำอีกคลาสของคุณจึงเป็นตัวเลือกที่ดีสำหรับการนำรูปแบบ IDisposable ไปใช้

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();
    }
}

สิ่งนี้ทำให้คุณต้องการเพียง "การใช้" เมื่อสร้างอินสแตนซ์ของคลาสของคุณ หากคุณไม่ต้องการให้ชั้นเรียนมีความรับผิดชอบในการกำจัดวัตถุคุณสามารถทำให้วิธีการยอมรับการพึ่งพาเป็นอาร์กิวเมนต์:

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();
}

บิตที่ฉันโปรดปรานในเวทมนตร์ที่ไม่อาจคาดเดาได้!

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());
  }
}

Wrapมีอยู่เพื่อนามธรรมที่ออกหรือสิ่งที่คุณต้องการเวทมนตร์ ฉันไม่แน่ใจว่าฉันจะแนะนำสิ่งนี้ตลอดเวลา แต่เป็นไปได้ที่จะใช้ แนวคิด "ที่ดีกว่า" คือการใช้คอนเทนเนอร์ DI เช่น StructureMap และเพียงแค่กำหนดขอบเขตคลาสเอนทิตีกับบริบทคำร้องขอฉีดเข้าไปในตัวควบคุมแล้วปล่อยให้ดูแลวงจรชีวิตโดยไม่ต้องใช้ตัวควบคุมของคุณ