'using'키워드를 사용할 때 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 번 이상). using블록에 대해 DRY (Do n't Repeat Yourself) 교장을 어떻게 구현할 수 있습니까? 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 당신이 이것을하는 두 가지 이상의 유형을 가지고 있다고 가정하기 때문에 유형 매개 변수도 . 그렇지 않은 경우 제거하고 반환 유형에 type 매개 변수를 사용할 수 있습니다.

솔직히 말해서 이런 종류의 코드는 가독성에 전혀 도움이되지 않습니다. 내 경험상 더 많은 Jr 동료들은 그것으로 정말 힘든 시간을 보냅니다.

고려할 수있는 도우미에 대한 몇 가지 추가 변형 업데이트

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

나에게 이것은 같은 컬렉션에 대해 여러 번 foreaching을 걱정하는 것과 같습니다. 그것은 당신이해야 할 일입니다. 더 추상화하려고 시도하면 코드를 훨씬 덜 읽을 수 있습니다.

"한 번만"원칙과 DRY 원칙을 혼동하는 것 같습니다. DRY 원칙은 다음과 같이 말합니다.

모든 지식은 시스템 내에서 하나의 명백하고 권위있는 표현을 가져야합니다.

그러나 Once and Only Once 원칙은 약간 다릅니다.

[DRY] 원칙은 OnceAndOnlyOnce와 유사하지만 목적이 다릅니다. OnceAndOnlyOnce를 사용하면 중복 코드 및 기능을 제거하기 위해 리팩토링하는 것이 좋습니다. DRY를 사용하면 시스템에 사용 된 모든 지식 조각의 단일 결정적인 소스를 식별 한 다음 해당 소스를 사용하여 해당 지식의 적용 가능한 인스턴스 (코드, 문서, 테스트 등)를 생성 할 수 있습니다.

DRY 원칙은 일반적으로 실제 논리와 관련하여 사용되며 명령문을 사용하여 너무 많이 중복되지 않습니다.

프로그램의 구조를 DRY로 유지하는 것은 어렵고 가치는 낮습니다. 비즈니스 규칙, if 문, 수학 공식 및 메타 데이터가 한 곳에만 표시되어야합니다. HTML 페이지, 중복 테스트 데이터, 쉼표 및 {} 구분 기호 등의 WET 항목은 모두 무시하기 쉬우므로 DRY를 사용하는 것이 덜 중요합니다.

출처

나는 사용을 보지 못했다 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를 적용하는 것은 실제로 모든 마이크로 최적화와 마찬가지로 자전거 흘림 과 같은 문제를 해결하지 못하지만 새로운 것을 도입 할 위험 이있는 아키텍처 마이크로 최적화 입니다.
내 경험에 따르면, 해당 수준에서 코드 중복성을 줄이려고하면 실제로 명확하고 간단한 것을 난독 화함으로써 코드 품질에 부정적인 영향을 미칩니다.

편집 :
좋아. 따라서 문제는 실제로 using 문이 아니며 매번 생성하는 객체에 대한 종속성입니다. 생성자를 주입하는 것이 좋습니다.

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도 사용합니다. 다음과 같이 코드를 리팩터링합니다.

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

마지막 논리를 제외하고는 어떤 종류의 비즈니스 논리도 없기 때문입니다. 내 견해로는 실제로 건조하지는 않습니다.

마지막 블록은 using 블록에 DRY가 없지만 where 절이 어디에서나 바뀌어야한다고 생각합니다.

이것은 코드 생성기의 일반적인 작업입니다. 코드 생성기를 작성하고 덮고 각 유형마다 생성하도록하십시오.

동일한 일회용 객체를 반복해서 만들고 파괴하기 때문에 클래스 자체가 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당신이 필요로하는 것을 요약하기 위해서만 존재합니다. 나는 이것을 항상 추천할지는 확실하지 않지만 사용할 수 있습니다. "더 나은"아이디어는 StructureMap과 같은 DI 컨테이너를 사용하고 Entities 클래스를 요청 컨텍스트로 범위 지정하고 컨트롤러에 삽입 한 다음 컨트롤러가 필요없이 수명주기를 처리하도록하는 것입니다.