디자인 모델 총화 (1)

패키지, 계승, 다 중 으로 프로그램의 결합 도 를 낮 추어 프로그램 을 더욱 유연 하고 수정 하기 쉬 우 며 재 활용 하기 쉽다

.
단순 공장

public class Operation {
        public double NumberA { get; set; }
        public double NumberB { get; set; }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    public class OperationAdd:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":oper = new OperationAdd(); break;
                default:
                    break;
            }
            return oper;
        }
    }

            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 3;
            oper.NumberB = 5;
            double result = oper.GetResult();

정책 모드 - 기본 코드

전략 모델 은 일련의 알고리즘 을 정의 하 는 방법 으로 같은 방식 으로 모든 방법 을 호출 하여 각종 알고리즘 류 와 사용 알고리즘 간 의 결합 을 감소 시 켰 다.

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

            context = new Context(new ConcreteStrategyA());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyB());
            context.ContextInterface();

            context = new Context(new ConcreteStrategyC());
            context.ContextInterface();

            Console.Read();
        }
    }

    //     
    abstract class Strategy
    {
        //    
        public abstract void AlgorithmInterface();
    }
    //    A
    class ConcreteStrategyA : Strategy
    {
        //  A    
        public override void AlgorithmInterface()
        {
            Console.WriteLine("  A  ");
        }
    }
    //    B
    class ConcreteStrategyB : Strategy
    {
        //  B    
        public override void AlgorithmInterface()
        {
            Console.WriteLine("  B  ");
        }
    }
    //    C
    class ConcreteStrategyC : Strategy
    {
        //  C    
        public override void AlgorithmInterface()
        {
            Console.WriteLine("  C  ");
        }
    }
    //   
    class Context
    {
        Strategy strategy;

        public Context(Strategy strategy)
        {
            this.strategy = strategy;
        }
        //     
        public void ContextInterface()
        {
            strategy.AlgorithmInterface();
        }
    }

단일 직책 원칙

개방 - 폐쇄 원칙

역전 원칙 에 의존

고 층 모듈 은 저층 모듈 에 의존 해 서 는 안 되 고 둘 다 추상 에 의존 해 야 한다

추상 은 디 테 일 에 의존 해 서 는 안 되 고 디 테 일 은 추상 에 의존 해 야 한다

리 씨 교체 원칙: 자 류 는 반드시 그들의 부 류 * 부 류 를 교체 해 야 진정 으로 재 활용 할 수 있 고 자 류 는 부 류 를 바탕 으로 새로운 행 위 를 추가 할 수 있다.

반전 에 의존 하 는 것 은 대상 을 대상 으로 하 는 표지 라 고 할 수 있다. 추상 적 인 프로 그래 밍 은 디 테 일 한 프로 그래 밍 이 아니 라 모든 의존 관 계 는 추상 적 인 유형 이나 인터페이스 에서 중단 되 고 반대로 과정 화 된 디자인 이다.

장식 모드

class Program
    {
        static void Main(string[] args)
        {
            Person xc = new Person("  ");

            Console.WriteLine("
     ：");

            Sneakers pqx = new Sneakers();
            BigTrouser kk = new BigTrouser();
            TShirts dtx = new TShirts();

            pqx.Decorate(xc);
            kk.Decorate(pqx);
            dtx.Decorate(kk);
            dtx.Show();

            Console.WriteLine("
     ：");

            LeatherShoes px = new LeatherShoes();
            Tie ld = new Tie();
            Suit xz = new Suit();

            px.Decorate(xc);
            ld.Decorate(px);
            xz.Decorate(ld);
            xz.Show();

            Console.WriteLine("
     ：");
            Sneakers pqx2 = new Sneakers();
            LeatherShoes px2 = new LeatherShoes();
            BigTrouser kk2 = new BigTrouser();
            Tie ld2 = new Tie();

            pqx2.Decorate(xc);
            px2.Decorate(pqx);
            kk2.Decorate(px2);
            ld2.Decorate(kk2);

            ld2.Show();

            Console.Read();
        }
    }

    class Person
    {
        public Person()
        { }

        private string name;
        public Person(string name)
        {
            this.name = name;
        }

        public virtual void Show()
        {
            Console.WriteLine("   {0}", name);
        }
    }

    class Finery : Person
    {
        protected Person component;

        //  
        public void Decorate(Person component)
        {
            this.component = component;
        }

        public override void Show()
        {
            if (component != null)
            {
                component.Show();
            }
        }
    }


    class TShirts : Finery
    {
        public override void Show()
        {
            Console.Write(" T  ");
            base.Show();
        }
    }

    class BigTrouser : Finery
    {
        public override void Show()
        {
            Console.Write("   ");
            base.Show();
        }
    }

    class Sneakers : Finery
    {
        public override void Show()
        {
            Console.Write("    ");
            base.Show();
        }
    }

    class Suit : Finery
    {
        public override void Show()
        {
            Console.Write("   ");
            base.Show();
        }
    }

    class Tie : Finery
    {
        public override void Show()
        {
            Console.Write("   ");
            base.Show();
        }
    }

    class LeatherShoes : Finery
    {
        public override void Show()
        {
            Console.Write("   ");
            base.Show();
        }
    }

장식 모델 은 기 존의 기능 동태 에 더 많은 기능 을 추가 하 는 방식 이다.

시스템 에 새로운 기능 이 필요 할 때 낡은 클래스 에 새로운 코드 를 추가 하 는 것 이다. 이런 새로운 코드 는 기 존의 핵심 직책 이나 방 요 행 위 를 장식 하고 주요 클래스 에 새로운 필드, 새로운 방법 과 새로운 논 리 를 추가 하여 주요 유형의 복잡 도 를 증가 시킨다.이런 새로 추 가 된 것 은 특정한 상황 에서 만 실행 되 는 특수 한 행위 의 수 요 를 만족 시 키 기 위 한 것 이다.한편, 장식 모델 은 장식 기능 을 단독 류 에 넣 고 이런 포장 을 장식 할 대상 으로 한다.클래스 중의 장식 기능 을 클래스 에서 옮 겨 제거 하면 원래 의 클래스 를 간소화 하고 클래스 의 핵심 직책 과 장식 기능 을 효과적으로 구분 하여 관련 클래스 에서 중복 되 는 장식 논 리 를 제거한다.

에이전트 모드

    class Program
    {
        static void Main(string[] args)
        {
            SchoolGirl jiaojiao = new SchoolGirl();
            jiaojiao.Name = "   ";

            Proxy daili = new Proxy(jiaojiao);

            daili.GiveDolls();
            daili.GiveFlowers();
            daili.GiveChocolate();


            Console.Read();
        }
    }

    //   
    interface GiveGift
    {
        void GiveDolls();
        void GiveFlowers();
        void GiveChocolate();
    }

    class Proxy : GiveGift
    {
        Pursuit gg;
        public Proxy(SchoolGirl mm)
        {
            gg = new Pursuit(mm);
        }


        public void GiveDolls()
        {
            gg.GiveDolls();
        }

        public void GiveFlowers()
        {
            gg.GiveFlowers();
        }

        public void GiveChocolate()
        {
            gg.GiveChocolate();
        }
    }

    class Pursuit : GiveGift
    {
        SchoolGirl mm;
        public Pursuit(SchoolGirl mm)
        {
            this.mm = mm;
        }
        public void GiveDolls()
        {
            Console.WriteLine(mm.Name + "      ");
        }

        public void GiveFlowers()
        {
            Console.WriteLine(mm.Name + "     ");
        }

        public void GiveChocolate()
        {
            Console.WriteLine(mm.Name + "      ");
        }
    }

    class SchoolGirl
    {
        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

원 격 에이전트

가상 에이전트

안전 대리

스마트 가이드

공장 방법 모델

 /// 

    ///    
    /// 
    class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }

        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

        /// 

        ///       
        /// 
        /// 
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

    /// 

    ///    
    /// 
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }

    /// 

    ///    
    /// 
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    /// 

    ///    
    /// 
    class OperationMul : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    /// 

    ///    
    /// 
    class OperationDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("     0。");
            result = NumberA / NumberB;
            return result;
        }
    }

    /// 

    ///     
    /// 
    interface IFactory
    {
        Operation CreateOperation();
    }

    /// 

    ///       “+”   
    /// 
    class AddFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }

    /// 

    ///       “-”   
    /// 
    class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

    /// 

    ///       “*”   
    /// 
    class MulFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationMul();
        }
    }

    /// 

    ///       “/”   
    /// 
    class DivFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationDiv();
        }
    }

공장 방법 모델 이 실 현 될 때 클 라 이언 트 는 어느 공장 을 실례 화하 여 연산 류 를 실현 할 지 결정 해 야 한다. 판단 하 는 문제 가 존재 하 는 지 를 선택해 야 한다. 공장 방법 은 간단 한 공장 의 내부 논리 판단 을 클 라 이언 트 코드 로 옮 겨 서 진행 해 야 한다. 네가 추가 하고 자 하 는 기능 은 원래 공장 류 를 바 꾸 는 것 이 고 지금 은 클 라 이언 트 를 수정 하 는 것 이다.

원형 모드

 class Program
    {
        static void Main(string[] args)
        {
            Resume a = new Resume("  ");
            a.SetPersonalInfo(" ", "29");
            a.SetWorkExperience("1998-2000", "XX  ");

            Resume b = (Resume)a.Clone();
            b.SetWorkExperience("1998-2006", "YY  ");

            Resume c = (Resume)a.Clone();
            c.SetWorkExperience("1998-2003", "ZZ  ");

            a.Display();
            b.Display();
            c.Display();

            Console.Read();

        }
    }

    //  
    class Resume : ICloneable
    {
        private string name;
        private string sex;
        private string age;

        private WorkExperience work;

        public Resume(string name)
        {
            this.name = name;
            work = new WorkExperience();
        }

        private Resume(WorkExperience work)
        {
            this.work = (WorkExperience)work.Clone();
        }

        //      
        public void SetPersonalInfo(string sex, string age)
        {
            this.sex = sex;
            this.age = age;
        }
        //      
        public void SetWorkExperience(string workDate, string company)
        {
            work.WorkDate = workDate;
            work.Company = company;
        }

        //  
        public void Display()
        {
            Console.WriteLine("{0} {1} {2}", name, sex, age);
            Console.WriteLine("    ：{0} {1}", work.WorkDate, work.Company);
        }

        public Object Clone()
        {
            Resume obj = new Resume(this.work);

            obj.name = this.name;
            obj.sex = this.sex;
            obj.age = this.age;


            return obj;
        }

    }

    //    
    class WorkExperience : ICloneable
    {
        private string workDate;
        public string WorkDate
        {
            get { return workDate; }
            set { workDate = value; }
        }
        private string company;
        public string Company
        {
            get { return company; }
            set { company = value; }
        }

        public Object Clone()
        {
            return (Object)this.MemberwiseClone();
        }
    }

얕 은 복사, 깊 은 복사

템 플 릿 모드

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

            c = new ConcreteClassA();
            c.TemplateMethod();

            c = new ConcreteClassB();
            c.TemplateMethod();

            Console.Read();

        }
    }

    abstract class AbstractClass
    {
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();

        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("");
        }
    }

    class ConcreteClassA : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("   A  1  ");
        }
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("   A  2  ");
        }
    }

    class ConcreteClassB : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("   B  1  ");
        }
        public override void PrimitiveOperation2()
        {
            Console.WriteLine("   B  2  ");
        }
    }

외관 모드

class Program
    {
        static void Main(string[] args)
        {
            Facade facade = new Facade();

            facade.MethodA();
            facade.MethodB();

            Console.Read();

        }
    }

    class SubSystemOne
    {
        public void MethodOne()
        {
            Console.WriteLine("       ");
        }
    }

    class SubSystemTwo
    {
        public void MethodTwo()
        {
            Console.WriteLine("       ");
        }
    }

    class SubSystemThree
    {
        public void MethodThree()
        {
            Console.WriteLine("       ");
        }
    }

    class SubSystemFour
    {
        public void MethodFour()
        {
            Console.WriteLine("       ");
        }
    }

    class Facade
    {
        SubSystemOne one;
        SubSystemTwo two;
        SubSystemThree three;
        SubSystemFour four;

        public Facade()
        {
            one = new SubSystemOne();
            two = new SubSystemTwo();
            three = new SubSystemThree();
            four = new SubSystemFour();
        }

        public void MethodA()
        {
            Console.WriteLine("
   A() ---- ");
            one.MethodOne();
            two.MethodTwo();
            four.MethodFour();
        }

        public void MethodB()
        {
            Console.WriteLine("
   B() ---- ");
            two.MethodTwo();
            three.MethodThree();
        }
    }

건설 자 모드

 class Program
    {
        static void Main(string[] args)
        {
            Director director = new Director();
            Builder b1 = new ConcreteBuilder1();
            Builder b2 = new ConcreteBuilder2();

            director.Construct(b1);
            Product p1 = b1.GetResult();
            p1.Show();

            director.Construct(b2);
            Product p2 = b2.GetResult();
            p2.Show();

            Console.Read();
        }
    }

    class Director
    {
        public void Construct(Builder builder)
        {
            builder.BuildPartA();
            builder.BuildPartB();
        }
    }

    abstract class Builder
    {
        public abstract void BuildPartA();
        public abstract void BuildPartB();
        public abstract Product GetResult();
    }

    class ConcreteBuilder1 : Builder
    {
        private Product product = new Product();

        public override void BuildPartA()
        {
            product.Add("  A");
        }

        public override void BuildPartB()
        {
            product.Add("  B");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    class ConcreteBuilder2 : Builder
    {
        private Product product = new Product();
        public override void BuildPartA()
        {
            product.Add("  X");
        }

        public override void BuildPartB()
        {
            product.Add("  Y");
        }

        public override Product GetResult()
        {
            return product;
        }
    }

    class Product
    {
        IList parts = new List();

        public void Add(string part)
        {
            parts.Add(part);
        }

        public void Show()
        {
            Console.WriteLine("
      ----");
            foreach (string part in parts)
            {
                Console.WriteLine(part);
            }
        }
    }

본 고 는 블 로그 에서 한 글 을 여러 발 로 보 내 는 등 운영 도구 플랫폼 이다.
OpenWrite 발표