디자인 모델 총화 (1)

18372 단어 c#
  • 패키지, 계승, 다 중 으로 프로그램의 결합 도 를 낮 추어 프로그램 을 더욱 유연 하고 수정 하기 쉬 우 며 재 활용 하기 쉽다
  • .
    단순 공장
    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 발표

    좋은 웹페이지 즐겨찾기