(C \ # 디자인 모델 학습 노트) 2. 대상 을 대상 으로 디자인 하 는 7 대 원칙 과 단일 직책 원칙, 개방 폐쇄 원칙 분석

1. 대상 을 대상 으로 하 는 7 대 설계 원칙
설계 원칙 명칭
설계 원칙 안내
1. 단일 직책 원칙 (SRP)
이런 직책 은 단일 해 야 지, 너무 많은 직책 을 한 부류 에 두 어 서 는 안 된다.
2. 개폐 원칙 (OCP)
소프트웨어 실 체 는 확장 에 대해 개방 적 이지 만 수정 에 대해 서 는 닫 힌 다. 즉, 소프트웨어 실 체 를 수정 하지 않 는 토대 에서 그 기능 을 확장 하 는 것 이다.
3. 내부 교체 원칙 (LSP)
기본 적 인 대상 을 받 아들 일 수 있 는 곳 에 서 는 반드시 하나의 하위 대상 을 받 아들 일 수 있다.
4. 역전 원칙 에 의존한다 (DIP)
추상 층 을 대상 으로 프로 그래 밍 을 해 야 지 구체 적 인 클래스 를 대상 으로 프로 그래 밍 을 해 서 는 안 된다.
5. 인터페이스 격 리 원칙 (ISP)
하나의 통 일 된 인 터 페 이 스 를 대체 하기 위해 여러 개의 전문 인 터 페 이 스 를 사용 하 다.
6. 합성 재 활용 원칙 (CRP)
시스템 에 서 는 조합 과 집합 관련 관 계 를 최대한 많이 사용 하고 계승 관 계 를 최대한 적 게 사용 하거나 적용 하지 않 는 다.
7. 디 미트 법칙 (LOD)
하나의 소프트웨어 실체 가 다른 실체 에 대한 인용 이 적 을 수록 좋다. 또는 두 가지 유형 이 서로 직접 통신 할 필요 가 없다 면 이 두 가지 유형 은 직접적인 상호작용 이 발생 하지 않 고 한 제3 자 를 인용 하여 간접 적 인 상호작용 을 해 야 한다.
2. 단일 직책 원칙
1. 정의: 한 대상 은 하나의 직책 만 포함 하고 이 직책 은 하나의 유형 에 완전 하 게 밀봉 된다.분석: 한 가지 직책 이 많 을 수록 그 가 재 활용 되 는 가능성 이 낮 고 한 가지 직책 이 너무 많 으 면 이런 직책 을 결합 시 키 는 것 과 같다. 그 중의 한 직책 이 변화 할 때 다른 직책 운영 에 영향 을 줄 수 있다.
단일 직책 원칙 은 높 은 내부 집적, 낮은 결합 을 실현 하 는 지도 방침 이다.
2. 장점: 유형의 복잡성 이 낮 아 지고 가 독성 이 높 으 며 유지 가능성 이 높 아 지고 변경 으로 인 한 위험 이 낮 아진 다.
3. 개방 폐쇄 (개폐) 원칙
1. 정의: 하나의 소프트웨어 는 확장 을 개방 하고 수정 을 닫 아야 합 니 다.즉, 하나의 모듈 을 설계 할 때 이 모듈 이 수정 되 지 않 은 전제 에서 확 장 될 수 있 도록 해 야 한다. 즉, 현재 소스 코드 를 수정 하지 않 은 상태 에서 이 모듈 의 행 위 를 바 꿀 수 있 도록 해 야 한다.
추상 화 는 개폐 원칙 의 관건 이다.
2. 장점: 개폐 원칙 은 대상 을 대상 으로 디자인 하 는 핵심 이다. 이 원칙 에 따라 대상 을 대상 으로 하 는 기술 이 주장 하 는 큰 장점 을 가 져 올 수 있다. 즉, 유지 할 수 있 고 확장 할 수 있 으 며 재 활용 할 수 있 고 유연성 이 좋다.개발 자 는 프로그램 에서 빈번하게 변화 하 는 부분 에 대해 추상 적 으로 해 야 한다.
3. 실례

namespace _2.        
{
    public interface Fruit
    {
        void Plant();
        void Blossom();
        void Outcome();
    }

    public class Apple:Fruit
    {
        public Apple() //    
        {
            this.Plant();
            this.Blossom();
            this.Outcome();
        }

        public void Blossom()
        {
            Console.WriteLine("     ");
        }

        public void Outcome()
        {
            Console.WriteLine("     ");
        }

        public void Plant()
        {
            Console.WriteLine("      ");
        }
    }

    public class Pear : Fruit
    {
        public Pear()   //    
        {
            this.Plant();
            this.Blossom();
            this.Outcome();
        }
  
        public void Blossom()
        {
            Console.WriteLine("    ");
        }

        public void Outcome()
        {
            Console.WriteLine("    ");
        }

        public void Plant()
        {
            Console.WriteLine("     ");
        }
    }
    public interface GardenerBase
    {
        Fruit GetFruit();
    }

    public class AppleGardener : GardenerBase
    {
        private static AppleGardener appleGardenerSingleton; //    
        private AppleGardener()
        {

        }
        public static AppleGardener GetGardener()
        {
            if(appleGardenerSingleton==null)
            {
                appleGardenerSingleton = new AppleGardener();
            }
            return appleGardenerSingleton;
        }

        public Fruit GetFruit()
        {
            return new Apple();
        }
    }

    public class PearGardener:GardenerBase
    {
        private static PearGardener pearGardenerSingleton;
        private PearGardener()
        {

        }
        public static PearGardener GetGardener()
        {
            if(pearGardenerSingleton==null)
            {
                pearGardenerSingleton = new PearGardener();
            }
            return pearGardenerSingleton;
        }

        public Fruit GetFruit()
        {
            return  new Pear();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {

            Fruit tempApple;
            GardenerBase appleGardener = AppleGardener.GetGardener();
            tempApple = appleGardener.GetFruit();

            Fruit tempPear;
            GardenerBase pearGardener = PearGardener.GetGardener();
            tempApple = pearGardener.GetFruit();

            Console.ReadKey();
        }
    }
}