c#设计原则

最新推荐文章于 2024-04-23 06:32:07 发布

Bug敲起来

最新推荐文章于 2024-04-23 06:32:07 发布

阅读量255

点赞数

分类专栏： c# 文章标签： c# 里氏替换原则迪米特法则单一职责原则依赖倒置原则

本文链接：https://blog.csdn.net/liuhongze98/article/details/120728954

版权

c# 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

六⼤设计原则

单⼀职责原则（SRP：Single Responsibility Principle）

单⼀职责原则，SRP⼜称单⼀功能原则，⾯向对象五个基本原则（SOLID）之⼀。它规定⼀个类应该只有⼀个
发⽣变化的原因。该原则由罗伯特·C·⻢丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》⼀书中给出的

定义
⼀个模块只负责⼀件事。
⼀个类只负责⼀件事。
⼀个⽅法只负责⼀件事。

常⻅违背单⼀职责场景
在⽅法中出现多个分⽀，分别去执⾏各⾃的逻辑，功能虽然可以实现。
但如果需求变更，就会⾮常的不稳定。

如何遵守单⼀职责原则
定义抽象⽗类or⽗类虚⽅法
⼦类继承后重写，不同的实现

实例：不同动物的叫声处理，喊叫⽅法中多个分⽀，还是不同类不同喊叫⽅法。

单⼀职责的优缺点
优点
每个类相对简单，只负责⾃⼰的事情。
需求变更时，只修改变更类，其他类不受影响。
缺点
代码量会有所增加
解读代码成本增加

何时遵循？何时不遵守？
类型逻辑⾜够简单，⽅法⾜够少，可以不遵守
类型复杂，⽅法很多，⼀定要遵循单⼀职责原则

单⼀职责的不同层⾯
以⽅法为单位
⼀个⽅法只负责⼀件事
⽅法中可以封装成⼀个新⽅法的，就封装成⼀个新⽅法
以类为单位
⼀个类只负责⼀件事
不属于该类的内容，创建新的类去封装
以模块/项⽬为单位
⼀个模块/项⽬只负责⼀件事
不属于该模块的内容，交由属于的模块去负责









⾥⽒替换原则（LSP：Liskov Substitution Principle）

⾥⽒替换原则，LSP作为OO的⾼层原则，主张使⽤“抽象(Abstraction)”和“多态(Polymorphism)”将设计中的静态结构改为动态结构，维持设计的封闭性。“抽象”是语⾔提供的功能。“多态”由继承语义实现。

定义
任何使⽤基类的地⽅，都可以安全的去使⽤其⼦类。

⽗类有的内容，⼦类必须有【类的强继承】
如果⽗类出现了⼦类不应该有的内容，那么就应该断开两个类的继承关系
然后，重新创建新的⽗类，包含⼦类该拥有的内容

⼦类必须有⾃⼰的⾏为和特征
⽗类已经实现的内容，⼦类不要再写【不要使⽤new关键词隐藏⽗类⽅法】
如果⼦类希望可以重写⽗类⽅法，⽗类⽅法⽤abstruct或virtual修饰

实例：游戏⻆⾊中的攻击⽅法，不能被不能攻击的⼦类继承。








迪⽶特法则（LKP：Least Knowledge Principle ）

迪⽶特法则（Law of Demeter）⼜叫作最少知识原则（Least Knowledge Principle 简写LKP），⼀个类对于其他类知道的越少越好，就是说⼀个对象应当对其他对象有尽可能少的了解，只和朋友通信，不和陌⽣⼈说话。

定义
⼀个对象应该对其他对象保持最少的了解，只与直接朋友进⾏通信。

类与类之间的关系：
纵向：继承关系
横向：聚合、组合、关联、依赖「出现在⽅法内部」

⾼内聚、低耦合
降低耦合度的⽅法
1. 少使⽤类的继承，多⽤接⼝隐藏实现的细节。
2. 模块的功能化分尽可能的单⼀，道理也很简单，功能单⼀的模块供其它模块调⽤的机会就少。（其实这是⾼内聚的⼀种说法，⾼内聚低耦合⼀般同时出现）。
3. 遵循⼀个定义只在⼀个地⽅出现。
4. 少使⽤全局变量。
5. 类属性和⽅法的声明少⽤public，多⽤private关键字。
6. 多⽤设计模式，⽐如采⽤MVC的设计模式就可以降低界⾯与业务逻辑的耦合度。
7. 尽量不⽤“硬编码”的⽅式写程序，同时也尽量避免直接⽤SQL语句操作数据库。
8. 最后当然就是避免直接操作或调⽤其它模块或类（内容耦合）；如果模块间必须存在耦合，原则上尽量使⽤数据耦合，少⽤控制耦合，限制公共耦合的范围，避免使⽤内容耦合。

增强内聚度⽅法
1. 模块只对外暴露最⼩限度的接⼝，形成最低的依赖关系。
2. 只要对外接⼝不变，模块内部的修改，就不得影响其他模块。
3. 删除⼀个模块，应当只影响有依赖关系的其他模块，⽽不应该影响其他⽆关部分。
通过降低访问修饰符权限，减少联系，减少耦合

实例：学校介绍->班级介绍->学⽣介绍，两两联系，学校不要与学⽣直接联系













依赖倒置原则（DIP：Dependence Inversion Principle）

依赖倒置原则（Dependence Inversion Principle）是程序要依赖于抽象接⼝，不要依赖于具体实现。简单的说就是要求对抽象进⾏编程，不要对实现进⾏编程，这样就降低了客户与实现模块间的耦合。

定义
⾼层模块不应该依赖于低层模块，两者应该依赖抽象，⽽不是依赖细节。
⾼层：⽅法调⽤⽅
底层：被调⽤⽅

⾯向抽象编程
属性、字段、⽅法参数、返回值，⼀切都尽量使⽤抽象【类/接⼝】
抽象不变，⾼层就不变
抽象⼀般是稳定的，低层的扩展变化不会影响到⾼层，低层就可以横向的⾃由扩展，架构稳定
80%的设计模式跟抽象有关

抽象的好处
⼀个⽅法可以满⾜不同类型的参数传⼊
⽀持动态扩展，只要是实现了这个抽象，不需要修改上层

实例：学⽣类实现不同⼿机的使⽤⽅法，学⽣依赖⼿机，新⼿机出现时，学⽣类也要更新新⽅法。
不同的⼿机应该依赖抽象（⼿机），学⽣类也应该依赖于抽象（⼿机⽤户）












接⼝隔离原则（ISP：Interface Segregation Principle）

客户端不应该依赖它不需要的接⼝。⼀个类对另⼀个类的依赖应该建⽴在最⼩的接⼝上。

定义：
使⽤多个专⻔的接⼝⽐使⽤单⼀的总接⼝要好，但也不建议⼀个接⼝只对应⼀个⽅法。
⼀个类对另外⼀个类的依赖性应当是建⽴在最⼩的接⼝上的。
⼀个接⼝代表⼀个⻆⾊，不应当将不同的⻆⾊都交给⼀个接⼝。没有关系的接⼝合并在⼀起，形成⼀个
臃肿的⼤接⼝，这是对⻆⾊和接⼝的污染。

接⼝的正确定义
既不能⼤⽽全，也建议不能⼀个接⼝⼀个⽅法
应该按照功能的密不可分来定义接⼝
应该是动态的，随业务变化⽽变化，设计的时候要留好提前量，避免抽象的变化

实例：⼿机的核⼼功能就是打电话和发短信，拍照、上⽹等其他功能的接⼝，不要被⼿机所依赖。
参看.Net类中的接⼝的设计与实现










开闭原则（OCP：Open Closed Principle）【总则】

在⾯向对象编程领域中，开闭原则规定“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是
对于修改是封闭的”，这意味着⼀个实体是允许在不改变它的源代码的前提下变更它的⾏为。该特性在产品化
的环境中是特别有价值的，在这种环境中，改变源代码需要代码审查，单元测试以及诸如此类的⽤以确保产
品使⽤质量的过程。遵循这种原则的代码在扩展时并不发⽣改变，因此⽆需上述的过程。

定义
对扩展开放，对修改关闭
扩展：添加新代码（类）
修改：修改原代码（类）
开闭原则是⼀个⽬标，没有任何⼿段，⼜被称为总则

为什么要遵循开闭原则
⾯向对象语⾔是静态语⾔，最害怕变化，因为会波及很多东⻄。
最理想的就是新增类，对原代码没有改动，原有代码才是可信的

遇到需求变更该怎么办呢？
直接修改现有⽅法 （最不可取）
增加⽅法 （稍好⼀些）
增加类 （那更好啦）
增加类库/框架 （那最好啦）

using UnityEngine;-------------------单一职责原则

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public abstract class Animal
{
    private string animalName;
    //只读属性
    public string AnimalName => animalName;
    
    protected Animal(string animalName)
    {
        this.animalName = animalName;
    }

    /// <summary>
    /// 喊叫
    /// </summary>
    /// <returns>喊叫声音</returns>
    public abstract string Shout();
}

public class Dog : Animal
{
    public Dog(string animalName) : base(animalName)
    {
    }

    public override string Shout()
    {
        return "汪汪汪";
    }
}

public class Cat : Animal
{
    public Cat(string animalName) : base(animalName)
    {
    }

    public override string Shout()
    {
        return "喵喵喵";
    }
}


public class SRP : MonoBehaviour
{
    public static void NewAnimalShot(Animal animal)
    {
        Debug.Log(animal.Shout());
    }

    private void Start()
    {
        Animal ani=new Cat("小咪");
        NewAnimalShot(ani);
    }
}

using System;---------------------里氏替换原则
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameRole
{
    
}

public  class CanAttackRole
{
    public virtual void Attack()
    {
        Debug.Log("砍了一刀");
    }

}

public class NormalMaster : CanAttackRole
{
    public override void Attack()
    {
        base.Attack();
        Debug.Log("又砍了一刀");
    }
}

public class RiverCrab : GameRole
{
    
}

public class LSP : MonoBehaviour
{
    private void Start()
    {
        CanAttackRole monster=new NormalMaster();
        monster.Attack();
        Debug.Log("--------------------------");
        CanAttackRole monsterr=new CanAttackRole();
        monsterr.Attack();
    }
}

using System.Collections;-------------迪米特法则，最小知识原则
using System.Collections.Generic;
using LKP;
using UnityEngine;


namespace LKP
{
    public class PlayerController
    {
        public PlayerController()
        {
            Debug.Log(Player.currentPlayer);
        }
    }

    public class PlayerAnimation
    {
        public PlayerAnimation()
        {
            Debug.Log(Player.currentPlayer);
        }
    }

    public class PlayerNavigation
    {
        public PlayerNavigation()
        {   
            Debug.Log(Player.currentPlayer);
        }
    }

    public class Player
    {
        //静态可以直接访问
        public static Player currentPlayer;
        public Monster monster;

        public void Attack(Monster monster)
        {
            Debug.Log(monster.experance);
        }
    }

    public class Monster
    {
        public float experance;
    }

    public class RiverCrab : Monster
    {
        
    }
    public class LKP : MonoBehaviour
    {
    
    }
    
}


namespace LKP_Ex
{
    public class School
    {
        public string schoolName;
        public Class[] classes;

        public School(string schoolName, Class[] classes)
        {
            this.schoolName = schoolName;
            this.classes = classes;
        }

        public void NewDescription()
        {
            for (int i = 0; i < classes.Length; i++)
            {
                classes[i].Desiption();
            }
        }
    }

    public class Class
    {
        public string ClassName;
        public Student[] Students;

        public Class(string className)
        {
            ClassName = className;
        }

        public Class(string className, Student[] students)
        {
            ClassName = className;
            Students = students;
        }

        public void Desiption()
        {
            for (int i = 0; i < Students.Length; i++)
            {
                Students[i].Description();
            }
        }
    }

    public class Student
    {
        public string name;
        public int age;
        public char sex;

        public Student(string name, int age, char sex)
        {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }

        public void Description()
        {
            Debug.Log(name);
            Debug.Log(age);
            Debug.Log(sex);
        }
    }
}

using System;--------------------依赖倒置原则
using System.Collections;
using System.Collections.Generic;
using DIP_Space;
using UnityEngine;

namespace DIP_Space
{
    #region no DIP

    public class Player
    {
        private AK47 _ak47;

        void Firee()
        {
            _ak47.Fire();
        }
    }

    public class AK47
    {
        public void Fire()
        {
            
        }
    }
    

    #endregion

    #region use DIP

    public class Game_UseWeapon
    {
        private Weapon currentWeapon;

        public virtual void UseWeapon(Weapon weapon)
        {
            currentWeapon = weapon;
        }
    }

    public class AIRole_UseWeapon : Game_UseWeapon
    {
        public int AINumber;
        public override void UseWeapon(Weapon weapon)
        {
            base.UseWeapon(weapon);
            weapon.Use();
        }
    }

    public class GamePlayer : Game_UseWeapon
    {
        public string Name;

        public GamePlayer(string name)
        {
            Name = name;
        }

        public override void UseWeapon(Weapon weapon)
        {
            base.UseWeapon(weapon);
            weapon.Use();
        }
    }
    public abstract class Weapon
    {
        public abstract void Use();
    }

    public class Gun : Weapon
    {
        public string name;

        public Gun(string name)
        {
           this.name = name;
        }

        public override void Use()
        {
            Debug.Log("dadad");
        }
    }

    public class ShotGun : Gun
    {
        
        public override void Use()
        {
            Debug.Log("bang");
        }
        public ShotGun(string name) : base(name)
        {
        }
    }
    

    #endregion
}

public class DIP : MonoBehaviour
{
    private void Start()
    {
        Game_UseWeapon xiaoming=new GamePlayer("小明");
        Gun ak47=new Gun("ak47");
        
        Game_UseWeapon ai=new AIRole_UseWeapon();
        Weapon shotgun=new ShotGun("shotgun");

        RoleUseWeapon(ai, shotgun);
        RoleUseWeapon(ai,ak47);
        RoleUseWeapon(xiaoming,shotgun);
        RoleUseWeapon(xiaoming,ak47);

    }

    public void RoleUseWeapon(Game_UseWeapon role, Weapon weapon)
    {
        role.UseWeapon(weapon);
    }
}

Bug敲起来

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
c#设计原则

六⼤设计原则单⼀职责原则（SRP：Single Responsibility Principle）单⼀职责原则，SRP⼜称单⼀功能原则，⾯向对象五个基本原则（SOLID）之⼀。它规定⼀个类应该只有⼀个发⽣变化的原因。该原则由罗伯特·C·⻢丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》⼀书中给出的定义⼀个模块只负责⼀件事。⼀个类只负责⼀件事。⼀个⽅法只负责⼀件事。常⻅违背单⼀职责场景在⽅法中出现多个分⽀，分别去执⾏各⾃的逻辑，功能虽然可以实现。但如果需.
复制链接

扫一扫