~李疆
~李疆

23种设计模式个人总结之C#版

 

目录

 

1.单例模式

2.抽象工厂模式

3.工厂方法模式

4.建造者模式

5.原型模式

6.适配器模式

7.装饰器模式

8.代理模式

9.外观模式

10.桥接模式

11.组合模式

12.享元模式

13.策略模式

14.模板方法模式

15.观察者模式

16.迭代器模式

17.责任链模式

18.命令模式

19.备忘录模式

20.状态模式

21.访问者模式

22.中介者模式

23.解释器模式

1.单例模式

untiy中单例模式有3种表达方式

第一种：（这种比较简单，但是需要新建一个空物体，并将脚本挂载上去。推荐使用此方式）

public class GameObjectPool : MonoBehaviour
{
    public static GameObjectPool _instance;
    private void Awake()
    {
        _instance = this;
    }
}

23种设计模式个人总结之C#版_第1张图片

第二种：（这种方式不用挂载脚本，不过代码量较大）

public class GameObjectPool : MonoBehaviour
{
    private GameObjectPool() { }
    private static GameObjectPool _instance;
    public static GameObjectPool GetInstance()
    {
        if (_instance == null)
        {
            //动态的生成一个名为“GameObjectPool”的对象并将单例脚本附加上去
            _instance = new GameObject("GameObjectPool").AddComponent();

        }
        return _instance;
    }
}

第三种：（这种方式需要挂载脚本，而且代码量还较大）

public class GameObjectPool : MonoBehaviour
{
    private GameObjectPool() { }
    private static GameObjectPool _instance;
    public static GameObjectPool GetInstance()
    {
        if (_instance == null)
        {
            _instance = new GameObjectPool ();

        }
        return _instance;
    }
}

第四种：（通过先Find再Get,需要将此代码挂载到名为“GameManager”的空物体上）

public class GameObjectPool : MonoBehaviour
{
    private static GameObjectPool _instance;
    public static GameObjectPool Instance
    {
        if (_instance == null)
        {
            _instance =GameObject.Find("GameManager").GetComponent();

        }
        return _instance;
    }
}

2.抽象工厂模式

23种设计模式个人总结之C#版_第2张图片


    class Client
    {
        static void Main(string[] args)
        {
            // 南昌工厂制作南昌的鸭脖和鸭架
            AbstractFactory nanChangFactory = new NanChangFactory();
            YaBo nanChangYabo = nanChangFactory.CreateYaBo();
            nanChangYabo.Print();
            YaJia nanChangYajia= nanChangFactory.CreateYaJia();
            nanChangYajia.Print();

            // 上海工厂制作上海的鸭脖和鸭架
            AbstractFactory shangHaiFactory = new ShangHaiFactory();
            shangHaiFactory.CreateYaBo().Print();
            shangHaiFactory.CreateYaJia().Print();

            Console.Read();
        }
    }

    public abstract class AbstractFactory// 抽象工厂类
    {
        public abstract YaBo CreateYaBo();
        public abstract YaJia CreateYaJia();
    }

    public class NanChangFactory : AbstractFactory// 南昌绝味工厂
    {
        
        public override YaBo CreateYaBo()// 制作南昌鸭脖
        {
            return new NanChangYaBo();
        }
        public override YaJia CreateYaJia()// 制作南昌鸭架
        {
            return new NanChangYaJia();
        }
    }

    public class ShangHaiFactory : AbstractFactory// 上海绝味工厂
    {
        public override YaBo CreateYaBo()
        {
            return new ShangHaiYaBo();
        }
        public override YaJia CreateYaJia()
        {
            return new ShangHaiYaJia();
        }
    }

    public abstract class YaBo
    {
        public abstract void Print();
    }
    public abstract class YaJia
    {
        public abstract void Print();
    }

    public class NanChangYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("南昌的鸭脖");
        }
    }
    public class ShangHaiYaBo : YaBo
    {
        public override void Print()
        {
            Console.WriteLine("上海的鸭脖");
        }
    }

    public class NanChangYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("南昌的鸭架子");
        }
    }
    public class ShangHaiYaJia : YaJia
    {
        public override void Print()
        {
            Console.WriteLine("上海的鸭架子");
        }
    }

3.工厂方法模式

23种设计模式个人总结之C#版_第3张图片


     public static void Main(string[] args)
        {

            LiveFactory liveFactory = new MusicFactory();
            Live musicLive = liveFactory.Create();
            musicLive.Action();
            Console.ReadLine();
          }

 public abstract class Live
    {
        public abstract void Action();
    }
    public class Music : Live
    {
        public override void Action()
        {
            Console.WriteLine("哼哼哈嘿，快使用刷结棍！");
        }
    }
    public class Bread : Live
    {
        public override void Action()
        {
            Console.WriteLine("努力，面包会有的，鸡蛋也会有的。");
        }
    }
    public abstract class LiveFactory
    {
        public abstract Live Create();
    }
    public class MusicFactory : LiveFactory
    {
        public override Live Create()
        {
            return new Music();
        }
    }
    public class BreadFactory : LiveFactory
    {
        public override Live Create()
        {
            return new Bread();
        }
    }

=》哼哼哈嘿，快使用双结棍！ 

4.建造者模式

23种设计模式个人总结之C#版_第4张图片


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

            director.Construct(b1);// 老板叫员工去组装第一台电脑
   
            Computer computer1 = b1.GetComputer();// 组装完，组装人员搬来组装好的电脑
            computer1.Show();
           
            director.Construct(b2);// 老板叫员工去组装第二台电脑
            Computer computer2 = b2.GetComputer();
            computer2.Show();

            Console.Read();
        }
    }
    public class Director
    { 
        public void Construct(Builder builder)// 组装电脑
        {
            builder.BuildPartCPU();
            builder.BuildPartMainBoard();
        }
    }

    public class Computer// 电脑类
    {
        private 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+"已装好");
            }

            Console.WriteLine("电脑组装好了");
        }
    }

    public abstract class Builder// 抽象建造者
    {
        public abstract void BuildPartCPU();// 装CPU
        public abstract void BuildPartMainBoard();// 装主板       
        public abstract Computer GetComputer();// 获得组装好的电脑
    }
    public class ConcreteBuilder1 : Builder
    {
        Computer computer = new Computer();
        public override void BuildPartCPU()
        {
            computer.Add("CPU1");
        }
        public override void BuildPartMainBoard()
        {
            computer.Add("Main board1");
        }
        public override Computer GetComputer()
        {
            return computer;
        }
    }
    public class ConcreteBuilder2 : Builder
    {
        Computer computer = new Computer();
        public override void BuildPartCPU()
        {
            computer.Add("CPU2");
        }
        public override void BuildPartMainBoard()
        {
            computer.Add("Main board2");
        }
        public override Computer GetComputer()
        {
            return computer;
        }
    }

 23种设计模式个人总结之C#版_第5张图片

5.原型模式

23种设计模式个人总结之C#版_第6张图片

class Program
    {
        static void Main(string[] args)
        {
            MonkeyPrototype prototypeMonkey=new ConcretePrototype ("Monkey");
            MonkeyPrototype clone1 = prototypeMonkey.Clone() as ConcretePrototype;
            Console.WriteLine("克隆1：" + clone1.name);
            MonkeyPrototype clone2 = prototypeMonkey.Clone() as ConcretePrototype;
            Console.WriteLine("克隆2：" + clone2.name);
            Console.ReadLine();
        }
    }
    public abstract class MonkeyPrototype //孙悟空原型
    {
        public string name { get; set; }
        public MonkeyPrototype(string Name)
        {
            name = Name;
        }
        public abstract MonkeyPrototype Clone();
    }
    public class ConcretePrototype:MonkeyPrototype
    {
        public ConcretePrototype(string id) : base(id) { }
        public override MonkeyPrototype Clone()//浅拷贝
        {
            return (MonkeyPrototype)MemberwiseClone();//调用MemberwiseClone()的是浅拷贝
        }
    }

6.适配器模式

23种设计模式个人总结之C#版_第7张图片

class Target
    {
        public virtual void Request()
        {
            Console.WriteLine("普通请求");
        }
    }
    class Adapter:Target
    {
         Adaptee adaptee = new Adaptee();
        public override void Request()
        {
            adaptee.SpecificRequest();
        }
    }
    class Adaptee
    {
        public void SpecificRequest()
        {
            Console.WriteLine("我是需要适配的类");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Target target = new Adapter();
            target.Request();
            Console.Read();
        }
    }

 =》我是需要适配的类

7.装饰器模式

23种设计模式个人总结之C#版_第8张图片

23种设计模式个人总结之C#版_第9张图片

    class Program
    {
        static void Main(string[] args)
        {
            Phone ap = new ApplePhone(); //新买了个苹果手机
            Decorator aps = new Sticker(ap); //准备贴膜组件
            aps.Print();
 
            Decorator apa = new Accessories(ap); //过了几天新增了挂件组件
            apa.Print();
 
            Sticker s = new Sticker(ap);       //准备贴膜组件
            Accessories a = new Accessories(s);//同时准备挂件
            a.Print(); 
        }
    }
    public abstract class Phone
    {
        public abstract void Print();
    }
    public class ApplePhone:Phone
    {
        public override void Print()
        {
            Console.WriteLine("我有一部苹果手机");
        }
    }
    public abstract class Decorator:Phone
    {
        private Phone p ;    //该装饰对象装饰到的Phone组件实体对象 
        public Decorator(Phone p)
        {
            this.p = p;
        }
        public override void Print()
        {
            if (this.p != null)
            {
                p.Print();
            }
        }
    }
    public class Sticker:Decorator// 贴膜
    {
        public Sticker(Phone p) : base(p) { }
        public override void Print()
        {
            base.Print();
            AddSticker();
        }
        public void AddSticker()
        {
            Console.WriteLine("现在苹果手机有贴膜了");
        }
    }
    public class Accessories:Decorator// 手机挂件，即具体装饰者
    {
        public Accessories(Phone p) : base(p) { }
        public override void Print()
        {
            base.Print();
            AddAccessories();
        }
        public void AddAccessories()
        {
            Console.WriteLine("现在苹果手机有漂亮的挂件了");
        }
    }

 23种设计模式个人总结之C#版_第10张图片

8.代理模式

23种设计模式个人总结之C#版_第11张图片


    class Client
    {
        static void Main(string[] args)
        {
            Person proxy = new Friend();
            proxy.BuyProduct();
            Console.Read();
        }
    }
    public abstract class Person
    {
        public abstract void BuyProduct();
    }
    public class RealBuyPerson : Person
    {
        public override void BuyProduct()
        {
            Console.WriteLine("帮我买一个IPhone和一台苹果电脑");
        }
    }
    public class Friend:Person
    {
        RealBuyPerson realSubject;
        public override void BuyProduct()
        {
            Console.WriteLine("通过代理类访问真实实体对象的方法");
            if (realSubject == null)
            {
                realSubject = new RealBuyPerson();
            }
            PreBuyProduct();
            realSubject.BuyProduct();
            this.PostBuyProduct();
        }
        public void PreBuyProduct()
        {
            // 可能不知一个朋友叫这位朋友带东西，首先这位出国的朋友要对每一位朋友要带的东西列一个清单等
            Console.WriteLine("我怕弄糊涂了，需要列一张清单，张三：要带相机，李四：要带Iphone...........");
        }
        public void PostBuyProduct()
        {
            Console.WriteLine("终于买完了，现在要对东西分一下，相机是张三的；Iphone是李四的..........");
        }
    }

 

9.外观模式

23种设计模式个人总结之C#版_第12张图片23种设计模式个人总结之C#版_第13张图片

    class Client
    {
        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("\n方法组合A()---");
            one.MethodOne();
            two.MethodTwo();
            four.MethodFour();
        }
        public void MethodB()
        {
            Console.WriteLine("\n方法组B()---");
            two.MethodTwo();
            three.MethodThree();
        }
    }

 23种设计模式个人总结之C#版_第14张图片

10.桥接模式

23种设计模式个人总结之C#版_第15张图片

    class Client
    {
        static void Main(string[] args)
        {
            ISoftware wechat = new WeChat();
            ISoftware qq = new QQ();

            Console.WriteLine("ios系统运行软件：");
            System ios = new IOS();
            ios.Run(wechat);
            ios.Run(qq);

            Console.WriteLine("");

            Console.WriteLine("Android系统运行软件：");
            System android = new Android();
            ios.Run(wechat);
            ios.Run(qq);

            Console.Read();
        }
    }
    public interface ISoftware
    {
        void Running();
    }
    public class WeChat:ISoftware
    {
        public void Running()
        {
            Console.WriteLine("微信已经运行");
        }
    }
    public class QQ : ISoftware
    {
        public void Running()
        {
            Console.WriteLine("QQ已经运行");
        }
    }
    public abstract class System
    {
        public abstract void Run(ISoftware software);
    }
    public class IOS:System 
    {
        public override void Run(ISoftware software)
        {
            Console.WriteLine("欢迎来到IOS系统");
            software.Running();
        }
    }
    public class Android: System 
    {
        public override void Run(ISoftware software)
        {
            Console.WriteLine("欢迎来到Android系统");
            software.Running();
        }
    }

 23种设计模式个人总结之C#版_第16张图片

11.组合模式

23种设计模式个人总结之C#版_第17张图片

    //抽象构件，它是叶子和容器共同的父类，并且声明了叶子和容器的所有方法
    abstract class AbstractFile
    {
        public abstract void Add(AbstractFile file);//新增文件
        public abstract void Delete(AbstractFile file);//删除文件
        public abstract AbstractFile GetChildFile(int i);//获取子构件（可以使文件，也可以是文件夹）
        public abstract void KillVirue();//对文件进行杀毒
    }
    class Folder:AbstractFile//文件夹
    {
        private List fileList = new List();
        private string name;
        public Folder(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public override void Add(AbstractFile file)
        {
            fileList.Add(file);
        }
 
        public override void Delete(AbstractFile file)
        {
            fileList.Remove(file);
        }
 
        public override AbstractFile GetChildFile(int i)
        {
            return fileList[i] as AbstractFile;
        }
 
        public override void KillVirue()
        {
            Console.WriteLine("对文件夹{0}进行杀毒",name);
            foreach (AbstractFile obj in fileList)
            {
                obj.KillVirue();
            }
        }
    }
class ImageFile:AbstractFile//图片文件
    {
        private string name;
 
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public ImageFile(string name)
        {
            this.name = name;
        }
        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override void Delete(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override AbstractFile GetChildFile(int i)
        {
            Console.WriteLine("对不起，不支持该方法");
            return null;
        }
        public override void KillVirue()
        {
            //模拟杀毒
            Console.WriteLine("已经对{0}进行了杀毒", name);
        }
    }
class TextFile:AbstractFile//文本文件
    {
        private string name;
 
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        public TextFile(string name)
        {
            this.name = name;
        }
        public override void Add(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override void Delete(AbstractFile file)
        {
            Console.WriteLine("对不起，不支持该方法");
        }
        public override AbstractFile GetChildFile(int i)
        {
            Console.WriteLine("对不起，不支持该方法");
            return null;
        }
        public override void KillVirue()
        {
            //模拟杀毒
            Console.WriteLine("已经对{0}进行了杀毒", name);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            AbstractFile file1, file2, folder1,file3, folder2, folder3;
            folder1 = new Folder("我的视频");
            folder2 = new Folder("我的图片");
            folder3 = new Folder("我的资料");
 
            file1 = new TextFile("文本1");
 
            file2 = new ImageFile("图像2");
            file3 = new TextFile("文本2");
            folder1.Add(file1);
            folder2.Add(file2);
            folder2.Add(file3);
            folder2.KillVirue();
            Console.ReadLine();
        }
    }

 

12.享元模式

       我们可以共用一个 Hello world 对象，其中字符串 “Hello world” 为内部状态，可共享；字体颜色为外部状态，不可共享，由客户端设定。

23种设计模式个人总结之C#版_第18张图片

    class Program
    {
        static void Main(string[] args)
        {
            School school = new School();
            Student student = school.GetStudent(1);
            Console.WriteLine(student.ToString());
            student = school.GetStudent(2);
            Console.WriteLine(student.ToString());
            Console.ReadKey();
        }
    }
    public abstract class abStudent
    {
        public string Name;
        public string schName;
        public string Sex;
        public abStudent()
        {
            schName = "西南科技大学";
            Sex = "男";
        }

        public override string ToString()
        {
            return string.Format("我叫{0},性别{1},在读学校{2}", Name, Sex, schName);
        }
    }
    public class Student : abStudent
    {
        public Student(string name)
        {
            Name = name;
        }
    }
    public class School
    {
        private Dictionary StudentList;
        public School()
        {
            StudentList = new Dictionary();
            StudentList.Add(1, new Student("张三"));
            StudentList.Add(2, new Student("李四"));
        }
        public Student GetStudent(int num)
        {
            return StudentList[num] as Student;
        }
    }

 

13.策略模式

class Program
    {
        static void Main(string[] args)
        {
            Context PShow = new Context(new PersonStragety());
            Console.WriteLine("单人票单价为：{0}", PShow.GetTax(100.00));
            Context GShow = new Context(new Group());
            Console.WriteLine("团体票单价为：{0}", GShow.GetTax(100.00));

            Console.Read();
        }
    }
    public interface Stragety
    {
        double CalculateTax(double income);
    }   
    public class PersonStragety:Stragety//单人票
    {
        public double CalculateTax(double income)
        {
            return income;
        }
    }
    public class Group:Stragety//团体票
    {
        public double CalculateTax(double income)
        {
            return income*0.9f;
        }
    }
    public class Context
    {
        private Stragety m_stragety;
        public Context (Stragety stragety)
        {
            m_stragety = stragety;
        }
        public double GetTax(double income)
        {
            return m_stragety.CalculateTax(income);
        }
    }

 

14.模板方法模式

23种设计模式个人总结之C#版_第19张图片

 class Client
    {
        static void Main(string[] args)
        {
            Spinach spinach = new Spinach();
            spinach.CookVegetabel();
            Console.Read();
        }
    }
    public abstract class Vegetabel
    {
        // 模板方法，不要把模版方法定义为Virtual或abstract方法，避免被子类重写，防止更改流程的执行顺序
        public void CookVegetabel()
        {
            Console.WriteLine("抄蔬菜的一般做法");
            pourOil();
            HeatOil();
            pourVegetable();
            stir_fry();
        }
        public void pourOil()
        {
            Console.WriteLine("倒油");
        }
        public void HeatOil()
        {
            Console.WriteLine("把油烧热");
        }
        public abstract void pourVegetable();// 油热了之后倒蔬菜下去，具体哪种蔬菜由子类决定
        public void stir_fry()
        {
            Console.WriteLine("翻炒");
        }
    }
    public class Spinach : Vegetabel// 菠菜
    {

        public override void pourVegetable()
        {
            Console.WriteLine("倒菠菜进锅中");
        }
    }
    public class ChineseCabbage : Vegetabel// 大白菜
    {
        public override void pourVegetable()
        {
            Console.WriteLine("倒大白菜进锅中");
        }
    }

 23种设计模式个人总结之C#版_第20张图片

15.观察者模式

23种设计模式个人总结之C#版_第21张图片

public abstract class Blog// 订阅号抽象类
    {
        private List observers = new List();
        public string Symbol { get; set; }//描写订阅号的相关信息
        public string Info { get; set; }//描写此次update的信息
        public Blog(string symbol, string info)
        {
            Symbol = symbol;
            Info = info;
        }
        // 对同一个订阅号，新增和删除订阅者的操作
        public void AddObserver(IObserver ob)
        {
            observers.Add(ob);
        }
        public void RemoveObserver(IObserver ob)
        {
            observers.Remove(ob);
        }
        public void Update()
        {
            foreach (IObserver ob in observers)// 遍历订阅者列表进行通知
            {
                if (ob != null)
                {
                    ob.Receive(this);
                }
            }
        }
    }
    public class MyBlog : Blog// 具体订阅号类
    {
        public MyBlog(string symbol, string info)
            : base(symbol, info) { }
    }
    public interface IObserver// 订阅者接口
    {
        void Receive(Blog tenxun);
    }
    public class Subscriber : IObserver// 具体的订阅者类
    {
        public string Name { get; set; }
        public Subscriber(string name)
        {
            Name = name;
        }
        public void Receive(Blog xmfdsh)
        {
            Console.WriteLine("订阅者 {0} 观察到了{1}{2}", Name, xmfdsh.Symbol, xmfdsh.Info);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Blog xmfdsh = new MyBlog("xmfdsh", "发布了一篇新博客");

            xmfdsh.AddObserver(new Subscriber("张三"));
            xmfdsh.AddObserver(new Subscriber("李四"));
            xmfdsh.AddObserver(new Subscriber("王五"));
            xmfdsh.AddObserver(new Subscriber("赵六"));
 
            xmfdsh.Update();//更新信息
            Console.ReadLine();//输出结果，此时所有的订阅者都已经得到博客的新消息
        }
    }

 

16.迭代器模式

23种设计模式个人总结之C#版_第22张图片

    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate monkey = new ConcreteAggregate();
            monkey[0] = "猴子";
            monkey[1] = "刘木同";
            monkey[2] = "笨蛋";
            monkey[3] = "小弟";
            monkey[4] = "领导";
            monkey[5] = "内部人员";
            monkey[6] = "小偷";

            Iterator i = new ConcreteIterator(monkey);
            object item = i.First();//从第一个乘客开始
            while (!i.IsDone())
            {
                Console.WriteLine("{0}请买火车票", i.CurrentItem());//若没买票，请补票
                i.Next();//遍历下一个
            }
            Console.Read();
        }
    }
    abstract class Iterator
    {
        public abstract object First();//1开始对象
        public abstract object Next();//2得到下一个对象
        public abstract bool IsDone();//3判断是否到结尾
        public abstract object CurrentItem();//4当前对象
    }
    abstract class Aggregate//聚集抽象类
    {
        public abstract Iterator CreateIterator();//创建迭代器
    }
    class ConcreteIterator : Iterator//具体迭代器类
    {
        private ConcreteAggregate aggregate;//定义一个具体聚集对象
        private int current = 0;
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;//初始化时将具体的聚集对象传入
        }
        public override object First()//得到聚集的第一个对象
        {
            return aggregate[0];
        }
        public override object Next()//得到聚集的下一个对象
        {
            object ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }
        public override bool IsDone()//判断当前是否遍历到结尾，到结尾返回true
        {
            return current >= aggregate.Count ? true : false;
        }
        public override object CurrentItem()
        {
            return aggregate[current];//返回当前的聚集对象
        }
    }  
    class ConcreteAggregate : Aggregate//具体聚集类
    {
        private IList items = new List();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        public int Count
        {
            get { return items.Count; }
        }
        public object this[int index]
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    } 
  
 23种设计模式个人总结之C#版_第23张图片
 
  
17.责任链模式
 
  
23种设计模式个人总结之C#版_第24张图片
 
  
    public class PurchaseRequest// 采购请求
    {
        
        public double Amount { get; set; }// 金额
        public string ProductName { get; set; }
        public PurchaseRequest(double amount, string productName)
        {
            Amount = amount;
            ProductName = productName;
        }
    }
    public abstract class Approver// 审批人,Handler
    {
        public Approver NextApprover { get; set; }
        public string Name { get; set; }
        public Approver(string name)
        {
            Name = name;
        }
        public abstract void ProcessRequest(PurchaseRequest request);
    }
    public class Manager : Approver
    {
        public Manager(string name): base(name) { }
        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 10000.0)
            {
                Console.WriteLine("{0}-{1}  想买  {2}", this, Name, request.ProductName);
            }
            else if (NextApprover != null)
            {
                NextApprover.ProcessRequest(request);
            }
        }
    }
    public class VicePresident : Approver// ConcreteHandler,副总
    {
        public VicePresident(string name): base(name) { }
        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 25000.0)
            {
                Console.WriteLine("{0}-{1}  想买  {2}", this, Name, request.ProductName);
            }
            else if (NextApprover != null)
            {
                NextApprover.ProcessRequest(request);
            }
        }
    }
    public class President : Approver// ConcreteHandler，总经理
    {
        public President(string name): base(name) { }
        public override void ProcessRequest(PurchaseRequest request)
        {
            if (request.Amount < 100000.0)
            {
                Console.WriteLine("{0}-{1}  想买  {2}", this, Name, request.ProductName);
            }
            else
            {
                Console.WriteLine("Request需要组织一个会议讨论");
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            PurchaseRequest requestTelphone = new PurchaseRequest(4000.0, "手机");
            PurchaseRequest requestSoftware = new PurchaseRequest(10000.0, "软件");
            PurchaseRequest requestComputers = new PurchaseRequest(40000.0, "电脑");

            Approver manager = new Manager("张三");
            Approver Vp = new VicePresident("李四");
            Approver Pre = new President("王五");
        
            manager.NextApprover = Vp;// 设置责任链
            Vp.NextApprover = Pre;

            manager.ProcessRequest(requestTelphone); // 处理请求
            manager.ProcessRequest(requestSoftware);
            manager.ProcessRequest(requestComputers);
            Console.ReadLine();
        }
    }
 
  
 
 
  
18.命令模式
 
  
23种设计模式个人总结之C#版_第25张图片
 
  
 class Program
    {
        static void Main(string[] args)
        {
            OrderReceiver o = new OrderReceiver(); //命令的响应者      >响应传达者传达的命令
            Command ecmd = new examcmd(o);       //命令的传达和监视者>传达发出这的命令给响应者
            Invoke ka = new Invoke(ecmd);        //命令的发出者      
            ka.Init();                           //>传达给传递者扩散命令

            Console.WriteLine("考试结束后");
            Command pcmd = new papercmd(o); //命令的传达和监视者
            Invoke kb = new Invoke(pcmd);   //命令的发出者
            kb.Init();

            Console.ReadLine();
        }
    }
    public class OrderReceiver// 命令最后的执行者
    {
        public void GetExam()
        {
            Console.WriteLine("进行期中考试！");
        }
        public void GetPaper()
        {
            Console.WriteLine("交卷！");
        }
    }
    public abstract class Command// 传递命令者的抽象类
    {
        protected OrderReceiver recediver;// 命令执行者
        public Command(OrderReceiver recediver)
        {
            this.recediver = recediver;
        }
        public abstract void Action();// 执行命令的方法
    }
    public class examcmd : Command// 执行考试命令传递者
    {
        public examcmd(OrderReceiver recetive) : base(recetive) { }
        public override void Action()
        {
            recediver.GetExam();
        }
    }
    public class papercmd : Command// 执行交卷命令传递者
    {
        public papercmd(OrderReceiver request) : base(request) { }
        public override void Action()// 执行命令
        {
            
            recediver.GetPaper();//开始考试
        }
    }
    public class Invoke// 命令的发出者
    {
        protected Command cmd;
        public Invoke(Command cmd)
        {
            this.cmd = cmd;
        }
        public void Init()
        {
            cmd.Action();
        }
    }
 
  
 
 
  
19.备忘录模式
 
  
23种设计模式个人总结之C#版_第26张图片
 
  
class Program
{
    static void Main(string[] args)
    {
        var persons = new List
        {
                new ContactPerson { Name= "Learning Hard", MobileNum = "123445"},
                new ContactPerson { Name = "Tony", MobileNum = "234565"},
                new ContactPerson { Name = "Jock", MobileNum = "231455"}
            };
        var mobileOwner = new MobileOwner(persons);
        mobileOwner.Show();

        // 创建备忘录并保存备忘录对象
        var caretaker = new Caretaker { ContactM = mobileOwner.CreateMemento() };

        Console.WriteLine("----移除最后一个联系人--------");// 更改发起人联系人列表
        mobileOwner.ContactPersons.RemoveAt(2);
        mobileOwner.Show();

        Console.WriteLine("-------恢复联系人列表------");// 恢复到原始状态
        mobileOwner.RestoreMemento(caretaker.ContactM);
        mobileOwner.Show();

        Console.Read();
    }
}
public class ContactPerson
{
    public string Name { get; set; }
    public string MobileNum { get; set; }
}
public class MobileOwner// 发起人
{
    public List ContactPersons { get; set; }// 发起人需要保存的内部状态
    public MobileOwner(List persons)
    {
        ContactPersons = persons;
    }
    public ContactMemento CreateMemento()// 创建备忘录，将当期要保存的联系人列表导入到备忘录中
    {
        // 这里也应该传递深拷贝，new List方式传递的是浅拷贝，
        // 因为ContactPerson类中都是string类型,所以这里new list方式对ContactPerson对象执行了深拷贝
        // 如果ContactPerson包括非string的引用类型就会有问题，所以这里也应该用序列化传递深拷贝
        return new ContactMemento(new List(this.ContactPersons));
    }
    public void RestoreMemento(ContactMemento memento)// 将备忘录中的数据备份导入到联系人列表中
    {
       //应该传递contactPersonBack的深拷贝，深拷贝可以使用序列化来完成
        ContactPersons = memento.ContactPersonBack;
    }
    public void Show()
    {
        Console.WriteLine("联系人列表中有{0}个人，他们是:", ContactPersons.Count);
        foreach (ContactPerson p in ContactPersons)
        {
            Console.WriteLine("姓名: {0} 号码为: {1}", p.Name, p.MobileNum);
        }
    }
}
public class ContactMemento// 备忘录
{
    public List ContactPersonBack; // 保存发起人的内部状态
    public ContactMemento(List persons)
    {
        ContactPersonBack = persons;
    }
}
public class Caretaker// 管理角色
{
    public ContactMemento ContactM { get; set; }
}
 
  
 23种设计模式个人总结之C#版_第27张图片
 
  
20.状态模式
 
  
        核心思想就是：当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点：1、可以通过改变状态来获得不同的行为。2、你的好友能同时看到你的变化。
 
  
 class Program
    {
        static void Main(string[] args)
        {
            State s = new State();
            s.Say();
            s.Say();
            s.Say();
            Console.Read();
        }
       
    }
    public interface People
    {
        void Say(State s);
    }
    public class Chinese : People
    {
        public void Say(State s)
        {
            Console.Write("现在是中文...");
            s.people = new English();
            Console.WriteLine("现在切换到了英文");
        }
    }
    public class English : People
    {
        public void Say(State s)
        {
            Console.Write("现在是英文...");
            s.people = new Chinese();
            Console.WriteLine("现在切换到了中文");
        }
    }
    public class State
    {
        public People people { get; set; }
        public State()
        {
            people = new Chinese();
            Console.WriteLine("现在默认状态是中文");
        }
        public void Say()
        {
            people.Say(this);
        }
    }
 
  
 
 
  
21.访问者模式
 
  
23种设计模式个人总结之C#版_第28张图片
 
  
    public abstract class Element
    {
        public abstract void Accept(IVistor vistor);
        public abstract void Print();
    }

    public class ElementA : Element
    {
        public override void Accept(IVistor vistor)
        {
            vistor.Visit(this);
        }
        public override void Print()
        {
            Console.WriteLine("我是元素A");
        }
    }
    public class ElementB : Element
    {
        public override void Accept(IVistor vistor)
        {
            vistor.Visit(this);
        }
        public override void Print()
        {
            Console.WriteLine("我是元素B");
        }
    }
    public interface IVistor// 抽象访问者
    {
        void Visit(ElementA a);
        void Visit(ElementB b);
    }
    public class ConcreteVistor : IVistor// 具体访问者
    {
        public void Visit(ElementA a)
        {
            a.Print();
        }
        public void Visit(ElementB b)
        {
            b.Print();
        }
    }
    public class ObjectStructure// 对象结构
    {
        private ArrayList elements = new ArrayList();
        public ArrayList Elements
        {
            get { return elements; }
        }
        public ObjectStructure()
        {
            Random ran = new Random();
            for (int i = 0; i < 6; i++)
            {
                int ranNum = ran.Next(10);
                if (ranNum > 5)
                {
                    elements.Add(new ElementA());
                }
                else
                {
                    elements.Add(new ElementB());
                }
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            ObjectStructure objectStructure = new ObjectStructure();
            foreach (Element e in objectStructure.Elements)
            {
                e.Accept(new ConcreteVistor());// 每个元素接受访问者访问
            }
            Console.Read();
        }
    }
 
  
 
 
  
 
 
  
22.中介者模式
 
  
    public abstract class AbstractCardPartner// 抽象牌友类
    {
        public int MoneyCount { get; set; }
        protected AbstractCardPartner()
        {
            MoneyCount = 0;
        }
        public abstract void ChangeCount(int count, AbstractMediator mediator);
    }
    public class ParterA : AbstractCardPartner// 牌友A类
    {
        public override void ChangeCount(int count, AbstractMediator mediator)// 依赖与抽象中介者对象
        {
            mediator.AWin(count);
        }
    }
    
    public class ParterB : AbstractCardPartner// 牌友B类
    {
        public override void ChangeCount(int count, AbstractMediator mediator)// 依赖与抽象中介者对象
        {
            mediator.BWin(count);
        }
    }
    public abstract class AbstractMediator// 抽象中介者类
    {
        protected AbstractCardPartner A;
        protected AbstractCardPartner B;
        protected AbstractMediator(AbstractCardPartner a, AbstractCardPartner b)
        {
            A = a;
            B = b;
        }
        public abstract void AWin(int count);
        public abstract void BWin(int count);
    }
    public class MediatorPater : AbstractMediator// 具体中介者类
    {
        public MediatorPater(AbstractCardPartner a, AbstractCardPartner b): base(a, b) { }
        public override void AWin(int count)
        {
            A.MoneyCount += count;
            B.MoneyCount -= count;
        }
        public override void BWin(int count)
        {
            B.MoneyCount += count;
            A.MoneyCount -= count;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            AbstractCardPartner A = new ParterA();
            AbstractCardPartner B = new ParterB(); 
            
            A.MoneyCount = 20;// 初始钱
            B.MoneyCount = 20;

            AbstractMediator mediator = new MediatorPater(A, B);
  
            A.ChangeCount(5, mediator);// A赢了
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是25
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是15

            B.ChangeCount(10, mediator);// B 赢了
            Console.WriteLine("A 现在的钱是：{0}", A.MoneyCount);// 应该是15
            Console.WriteLine("B 现在的钱是：{0}", B.MoneyCount); // 应该是25
            Console.Read();
        }
    }
 
  
 
  
23.解释器模式
 
  
23种设计模式个人总结之C#版_第29张图片
 
  
    class Program
    {
        static void Main(string[] args)
        {
            BooleanExp booleanExp1 = new BooleanExp("true");
            BooleanExp booleanExp2 = new BooleanExp("false");

            OrExp orExp = new OrExp(booleanExp1, booleanExp2);//或表达式
            Console.WriteLine(orExp.Interpret());

            AndExp andExp = new AndExp(booleanExp1, booleanExp2);//与表达式
            Console.WriteLine(andExp.Interpret());

            Console.Read();
        }
    }
    abstract class ExpressionClass
    {
        public abstract bool Interpret();
    }
    class BooleanExp : ExpressionClass//布尔表达式
    {
        string Context;
        public BooleanExp(string context)
        {
            Context = context;
        }
        public override bool Interpret()
        {
            return Context.ToLower() == "true";
        }
    }
    class OrExp : ExpressionClass//或表达式
    {
        BooleanExp Exp1;
        BooleanExp Exp2;

        public OrExp(BooleanExp exp1, BooleanExp exp2)
        {
            Exp1 = exp1;
            Exp2 = exp2;
        }
        public override bool Interpret()
        {
            return Exp1.Interpret() || Exp2.Interpret();
        }
    }
    class AndExp : ExpressionClass// 与表达式
    {
        BooleanExp Exp1;
        BooleanExp Exp2;
        public AndExp(BooleanExp exp1, BooleanExp exp2)
        {
            Exp1 = exp1;
            Exp2 = exp2;
        }
        public override bool Interpret()
        {
            return Exp1.Interpret() && Exp2.Interpret();
        }
    }
 
  
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(23种设计模式个人总结之C#版)

        

            

                
    
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • C#中使用split分割字符串
                        互联网打工人no1
c#
                        
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    
                    
    • 
                    
  • 大伟说成语之唉声叹气
                        求索大伟

                        
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
    
                    
    • 
                    
  • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
    
                    
    • 
                    
  • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
    很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
    
                    
    • 
                    
  • 第六集如何安装CentOS7.0，3分钟学会centos7安装教程
                        date分享

                        
    从光盘引导系统按回车键继续进入引导程序安装界面，选择语言这里选择简体中文版点击继续选择桌面安装下面给系统分区选择磁盘，点击完成选择基本分区，点击加号swap分区,大小填内存的两倍在选择根分区，使用所有可用的磁盘空间选择文件系统ext4点击完成，点击开始安装设置root密码，点击完成设置普通用户和密码，点击完成整个过程持续八分钟左右根据个人配置不同，时间长短不同好，现在点击重启系统进入重启状态点击本
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • 锁之缘
                        尘缘诗词原创作品

                        
    是谁追寻梦的足迹，是谁在偷偷的哭泣，日月隔离在黑白天地情感在心中蔓延的痕迹天与地的距离有多远流失的星晨落入哪片空间不要让泪水模糊双眼心牢中一样充满温暖谁说爱情没有永远白娘子又为何爱许仙蝴蝶墓地展翅翩翩轻歌慢舞袖卷人间传奇千古留爱万年…………月落星飞徘徊是选择不去问自已为合舍不得寂寞本就是痛苦的不在追寻梦中的痕迹才不会失去真实的自已
    
                    
    • 
                    
  • ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
    
                    
    • 
                    
  • ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
    ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
    
                    
    • 
                    
  • ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
    ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
    
                    
    • 
                    
  • C++ | Leetcode C++题解之第409题最长回文串
                        Ddddddd_158
经验分享C++Leetcode题解
                        
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
    
                    
    • 
                    
  • 2020-12-24
                        我和我的天使们

                        
    阅读《老子的心事》391—403“将欲取之，必固与之”：想要得到什么，首先就要送出什么。我常常对孩子们说，你希望别人怎样对你你就怎样对待别人。想要得到别人的尊重，首先要尊重别人。我希望她们可以不迟到，因为不迟到是对别人的尊重，我就自己就先做到不迟到。哪怕是约朋友逛街，我尽量准时赴约。我严格要求孩子们，也同样严格要求自己，我跟孩子们一起把好的品格变成习惯。“是谓微明”：这就是微妙的智慧。看起来很少很
    
                    
    • 
                    
  • 18、架构-可观测性之聚合度量
                        大树~~
架构javapython后端架构
                        
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
    
                    
    • 
                    
  • 学习“论语”-第59天
                        春峰轩

                        
    12.14子张问政。子曰：“居之无倦，行之以忠。”子张问为政之道。孔子说：“在位尽职不懈怠，执行政令要忠诚。”12.15子曰：“博学于文，约之以礼，亦可以弗畔矣夫！”孔子说：“君子广泛地学习文献，并且用礼节约束自己，也就不会离经叛道了。”12.16子曰：“君子成人之美，不成人之恶。小人反是。”孔子说：“君子成全别人的好事，而不助长别人的坏处。小人则与此相反行事。”知识点:“成人之美，不成人之恶”贯
    
                    
    • 
                    
  • 如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析
                        北京云巴巴信息技术有限公司
产品经理需求分析
                        
    在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
    
                    
    • 
                    
  • 2021-11-15
                        宙火

                        
    我给宋小姐写了首诗，是我在课上因思恋宋小姐而写的。“自古多情是唐宋，从来双飞归巢燕。邻家小女相聘婷，常使春意荡漾我。不知单思可为爱，惟愿一心付之汝。”我拿给宋小姐看了，她说我写得很棒。我很开心，但又不是那么开心。宋小姐是回复我了，但也只是说我写得很棒，对我诗句中蕴藏的真切感情，不知道是真的没发现，还是装作没发现。但我不深究，只是这样，我就很开心了。我答应宋小姐，一天给她写一首诗。
    
                    
    • 
                    
  • 《我的青葱岁月之缘来是你》 第二章 迎新晚会
                        思源思缘思怨

                        
    “怎么你也来了这里？”我愉快的问到，想着这是上天给的缘分吗？我还没去找他竟然就相遇了。那个让我开心的老乡。“你好，我也是舞蹈社的新人啊！”他说，笑起来回答我，眼睛弯弯的。“这么巧，我叫吴倩，你叫啥？”“我叫韩欢，你也是B市人吧，c中毕业的？”“我不是，我是f中的，不然肯定会认识你的”“是吗？以后多多关照了”他还冲我眨了眨眼睛。内心一阵悸动，这是……回到寝室，我兴奋的告诉我的室友这个事情，我再次觉得
    
                    
    • 
                    
  • 数据结构之哈希表
                        X同学的开始
数据结构数据结构散列表
                        
    哈希表(散列表)出现的原因在顺序表中查找时，需要从表头开始，依次遍历比较a[i]与key的值是否相等，直到相等才返回索引i；在有序表中查找时，我们经常使用的是二分查找，通过比较key与a[i]的大小来折半查找，直到相等时才返回索引i。最终通过索引找到我们要找的元素。但是，这两种方法的效率都依赖于查找中比较的次数。我们有一种想法，能不能不经过比较，而是直接通过关键字key一次得到所要的结果呢？这时，
    
                    
    • 
                    
  • 厦门自由行之第一天:
                        大苏子在广漂

                        
    厦门三人行之杂记出发前一天:12️28日下午15:00从广州粗发，来深圳集合！但是中间发生一个小插曲，验票时候发现车票不见了，或许也是一场恶作剧，对于不排队的人，忍不住说了一下，接下来就发现车票不见了，已经是拿在手上！不过还好，可以凭借购票订单查看到信息，所以有惊无险，顺利进站！晚上三个人一起去吃了柠檬鱼，说实话，那会，感觉美吃饱，啊哈哈！晚上回来，两个人又开始彻夜长谈，发现身边优秀的人，一大把，
    
                    
    • 
                    
  • “这才好”麻辣香锅 能够增加人身体的免疫能力
                        小补文知

                        
    我就来介绍一种香锅，那就是“这才好”麻辣香锅，它产出于著名的蜀地文化，具有悠久的历史土家风味，麻辣鲜香，健康安全。采用传统秘制麻辣香锅油辣子，还有贴心加料“孜然包”满足人们的不同口味需求，香锅底料辣椒，微辣且香，含有丰富微量元素和维生素，具有辣而不躁，味道纯正，醇厚温和。花椒采用历史悠久，被列为宫廷供品的“贡椒”的汉源花椒。我们还挑选了“川菜之魂”郫县豆瓣的鼻祖品牌豆瓣，保留最原始的郫县豆瓣味道，
    
                    
    • 
                    
  • 《太虚游》第六十二章。玄牝之威。
                        古楼臭道士

                        
    “好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
    
                    
    • 
                    
  • 你可能遗漏的一些C#/.NET/.NET Core知识点
                        追逐时光者
C#.NETDotNetGuide编程指南c#.net.netcoremicrosoft
                        
    前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
    
                    
    • 
                    
  • 生命如花
                        坦释空

                        
    每个人的心中都有一株妙莲花。这是禅家语。禅家总是站在理性的高处，以超越红尘的洒脱来参悟人生和自省生命。那么，凡俗中人呢？生如夏花之绚丽，死如秋叶之静美。这是诗人语。多少人在赞美：姑娘好像花一样！又有多少人在咏歌：花儿与少年。的确，人生如花。花一样的生命，理应自诞生之日起，就一瓣一瓣地绽放她的美丽与清香，使这个原本死寂荒凉的世界五彩缤纷，充满快乐。事实上，人类自诞生起，就一代一代地做着这方面的努力，
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
html
                                    
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •