2.7-C#编程规范与代码风格

最新推荐文章于 2025-04-03 22:00:00 发布
最新推荐文章于 2025-04-03 22:00:00 发布
阅读量743 收藏 10
点赞数 21
分类专栏： C#学习笔记整理 文章标签： c# java 数据库 .net 开发语言 前端 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_40263592/article/details/146924439
版权

2.7 C#编程规范与代码风格

在游戏开发中，良好的编程规范和代码风格不仅能提高代码的可读性和可维护性，还能帮助团队成员更好地协作。本节将介绍C#编程中的重要规范和最佳实践。

目录

命名规范

类名和接口名

使用PascalCase（首字母大写）命名类和接口：

// 游戏相关的类名示例
public class PlayerController { }
public class EnemySpawner { }
public class WeaponSystem { }

// 接口名前加I前缀
public interface IInteractable { }
public interface IDamageable { }
public interface IInventoryItem { }

方法名

使用PascalCase命名方法，动词开头：

public class Player
{
  // 动作方法
  public void MoveToPosition(Vector3 position) { }
  public void RotateTowards(Vector3 target) { }
  
  // 状态检查方法
  public bool IsGrounded() { }
  public bool CanAttack() { }
  
  // 获取/设置方法
  public int GetHealth() { }
  public void SetHealth(int value) { }
}

变量和参数

使用camelCase（首字母小写）命名变量和参数：

```csharp

public class GameManager
{
// 私有字段
private int currentScore;
private float gameTime;
private bool isGamePaused;

// 属性
public int CurrentLevel { get; private set; }

// 方法参数
public void AddScore(int scoreValue, bool isBonus = false)
{
    int multiplier = isBonus ? 2 : 1;
    currentScore += scoreValue * multiplier;
}

}


### 常量和只读字段

使用PascalCase命名常量和只读字段，全大写用于特殊配置：

  ```csharp
public class GameConfig
{
    // 游戏常量
    public const float GravityForce = 9.81f;
    public const int MaxPlayers = 4;
    
    // 配置常量
    public const string CONFIG_FILE_PATH = "config.json";
    public const string SAVE_DIRECTORY = "SaveData";
    
    // 只读字段
    private readonly float startingHealth;
    private readonly Vector3 spawnPoint;
}

代码组织

类的结构

按照以下顺序组织类的成员：

public class Enemy
{
  #region Fields
  // 1. 常量和静态字段
  private const float MAX_HEALTH = 100f;
  private static int enemyCount;
  
  // 2. 私有字段
  private float currentHealth;
  private bool isAlive;
  #endregion
  
  #region Properties
  // 3. 公共属性
  public float Health { get; private set; }
  public bool IsActive { get; set; }
  #endregion
  
  #region Events
  // 4. 事件
  public event Action<float> OnHealthChanged;
  public event Action OnDeath;
  #endregion
  
  #region Constructor
  // 5. 构造函数
  public Enemy(float health)
  {
      currentHealth = health;
      isAlive = true;
      enemyCount++;
  }
  #endregion
  
  #region Public Methods
  // 6. 公共方法
  public void TakeDamage(float damage)
  {
      if (!isAlive) return;
      
      currentHealth -= damage;
      OnHealthChanged?.Invoke(currentHealth);
      
      CheckDeath();
  }
  #endregion
  
  #region Private Methods
  // 7. 私有方法
  private void CheckDeath()
  {
      if (currentHealth <= 0 && isAlive)
      {
          isAlive = false;
          OnDeath?.Invoke();
          enemyCount--;
      }
  }
  #endregion
}

文件组织

每个文件应该只包含一个主要的类：

Assets/
  ├─ Scripts/
  │   ├─ Player/
  │   │   ├─ PlayerController.cs
  │   │   ├─ PlayerInput.cs
  │   │   └─ PlayerAnimation.cs
  │   ├─ Enemy/
  │   │   ├─ EnemyController.cs
  │   │   ├─ EnemyAI.cs
  │   │   └─ EnemySpawner.cs
  │   └─ UI/
  │       ├─ UIManager.cs
  │       ├─ HealthBar.cs
  │       └─ MainMenu.cs
  └─ ...

代码格式化

缩进和空格

使用4个空格进行缩进，在适当的地方使用空行分隔代码块：

public class WeaponSystem
{
    private List<Weapon> weapons;
    private int currentWeaponIndex;
    
    public WeaponSystem()
    {
        weapons = new List<Weapon>();
        currentWeaponIndex = 0;
    }
    
    public void AddWeapon(Weapon weapon)
    {
        if (weapon == null)
            throw new ArgumentNullException(nameof(weapon));
        
        weapons.Add(weapon);
    }
    
    public void SwitchWeapon(int index)
    {
        if (index < 0 || index >= weapons.Count)
            return;
        
        currentWeaponIndex = index;
        OnWeaponSwitched?.Invoke(CurrentWeapon);
    }
    
    public Weapon CurrentWeapon => 
        weapons.Count > 0 ? weapons[currentWeaponIndex] : null;
}

大括号和换行

始终使用大括号，即使是单行语句：

public class PlayerMovement
{
    public void Move(Vector3 direction)
    {
        if (direction.magnitude > 1f)
        {
            direction.Normalize();
        }
        
        if (IsGrounded())
        {
            ApplyMovement(direction);
        }
        else
        {
            ApplyAirMovement(direction);
        }
    }
    
    private void ApplyMovement(Vector3 direction)
    {
        // 即使是单行，也使用大括号
        if (direction == Vector3.zero)
        {
            return;
        }
        
        transform.position += direction * speed * Time.deltaTime;
    }
}

最佳实践

使用属性而不是公共字段

public class Character
{
    // 不好的做法
    public float health;
    
    // 好的做法
    private float health;
    public float Health
    {
        get => health;
        set
        {
            health = Mathf.Clamp(value, 0f, maxHealth);
            OnHealthChanged?.Invoke(health);
        }
    }
}

避免魔法数字

public class CombatSystem
{
    // 不好的做法
    public void CalculateDamage(float baseDamage)
    {
        float damage = baseDamage * 1.5f;  // 魔法数字
    }
    
    // 好的做法
    private const float CRITICAL_MULTIPLIER = 1.5f;
    public void CalculateDamage(float baseDamage)
    {
        float damage = baseDamage * CRITICAL_MULTIPLIER;
    }
}

使用有意义的异常处理

public class SaveSystem
{
  public void SaveGame(GameData data)
  {
      try
      {
          string json = JsonUtility.ToJson(data);
          File.WriteAllText(savePath, json);
      }
      catch (IOException ex)
      {
          Debug.LogError($"Failed to save game: {ex.Message}");
          throw new SaveGameException("Could not save game data", ex);
      }
      catch (Exception ex)
      {
          Debug.LogError($"Unexpected error while saving: {ex.Message}");
          throw;
      }
  }
}

遵循单一职责原则

// 不好的做法
public class PlayerManager
{
    public void UpdatePlayer() { }
    public void RenderHealthBar() { }  // UI相关
    public void SavePlayerData() { }   // 数据相关
}

// 好的做法
public class PlayerManager
{
    private PlayerUI ui;
    private PlayerData data;
    
    public void UpdatePlayer() { }
}

public class PlayerUI
{
    public void RenderHealthBar() { }
}

public class PlayerData
{
    public void SaveData() { }
}

使用适当的访问修饰符

public class InventorySystem
{
    // 只在类内部使用的字段
    private List<Item> items;
    
    // 允许子类访问但不公开
    protected virtual void OnItemAdded(Item item) { }
    
    // 公开的API
    public bool AddItem(Item item)
    {
        if (items.Count >= maxItems)
            return false;
            
        items.Add(item);
        OnItemAdded(item);
        return true;
    }
}

代码审查清单

就像游戏测试清单一样，代码审查也需要一个清单：

  1. 命名检查

    • 命名是否清晰且符合规范
    • 是否避免使用魔法数字
    • 是否使用有意义的变量名

  2. 结构检查

    • 代码是否组织合理
    • 是否遵循单一职责原则
    • 是否避免代码重复

  3. 性能检查

    • 是否避免不必要的对象创建
    • 是否合理使用缓存
    • 是否优化循环和条件判断

  4. 安全性检查

    • 是否进行输入验证
    • 是否处理异常情况
    • 是否保护敏感数据

  5. 可维护性检查

    • 是否有适当的注释
    • 是否遵循DRY原则
    • 是否易于测试

实战练习

练习1：重构游戏管理器

将一个混乱的游戏管理器类重构为符合规范的代码：

// 重构前
public class GameManager
{
    public static GameManager instance;
    public int score = 0;
    public bool gameStarted = false;
    public void StartGame() { gameStarted = true; }
    public void EndGame() { gameStarted = false; }
    public void AddScore(int s) { score += s; }
}

// 重构后
public class GameManager : MonoBehaviour
{
    #region Singleton
    private static GameManager instance;
    public static GameManager Instance
    {
        get
        {
            if (instance == null)
            {
                instance = FindObjectOfType<GameManager>();
                if (instance == null)
                {
                    GameObject go = new GameObject("GameManager");
                    instance = go.AddComponent<GameManager>();
                }
            }
            return instance;
        }
    }
    #endregion
    
    #region Events
    public event Action<int> OnScoreChanged;
    public event Action<GameState> OnGameStateChanged;
    #endregion
    
    #region Properties
    private int score;
    public int Score
    {
        get => score;
        private set
        {
            if (score != value)
            {
                score = value;
                OnScoreChanged?.Invoke(score);
            }
        }
    }
    
    public GameState CurrentState { get; private set; }
    #endregion
    
    #region Public Methods
    public void StartGame()
    {
        if (CurrentState != GameState.MainMenu)
            return;
            
        CurrentState = GameState.Playing;
        OnGameStateChanged?.Invoke(CurrentState);
    }
    
    public void EndGame()
    {
        if (CurrentState != GameState.Playing)
            return;
            
        CurrentState = GameState.GameOver;
        OnGameStateChanged?.Invoke(CurrentState);
    }
    
    public void AddScore(int points)
    {
        if (CurrentState != GameState.Playing || points <= 0)
            return;
            
        Score += points;
    }
    #endregion
    
    #region Private Methods
    private void Awake()
    {
        if (instance != null && instance != this)
        {
            Destroy(gameObject);
            return;
        }
        
        instance = this;
        DontDestroyOnLoad(gameObject);
        
        InitializeGame();
    }
    
    private void InitializeGame()
    {
        CurrentState = GameState.MainMenu;
        Score = 0;
    }
    #endregion
}

public enum GameState
{
    MainMenu,
    Playing,
    Paused,
    GameOver
}

练习2：创建规范的组件系统

实现一个符合C#规范的组件系统：

public interface IComponent
{
 void Initialize();
 void Update();
 void Cleanup();
}

public abstract class GameComponent : IComponent
{
 protected bool isInitialized;
 protected GameObject owner;
 
 protected GameComponent(GameObject owner)
 {
     this.owner = owner;
 }
 
 public virtual void Initialize()
 {
     if (isInitialized)
         return;
         
     isInitialized = true;
 }
 
 public abstract void Update();
 
 public virtual void Cleanup()
 {
     isInitialized = false;
 }
}

public class HealthComponent : GameComponent
{
 #region Events
 public event Action<float> OnHealthChanged;
 public event Action OnDeath;
 #endregion
 
 #region Properties
 private float currentHealth;
 public float CurrentHealth
 {
     get => currentHealth;
     private set
     {
         if (currentHealth != value)
         {
             currentHealth = Mathf.Clamp(value, 0f, maxHealth);
             OnHealthChanged?.Invoke(currentHealth);
             
             if (currentHealth <= 0f)
             {
                 OnDeath?.Invoke();
             }
         }
     }
 }
 
 private readonly float maxHealth;
 public float MaxHealth => maxHealth;
 #endregion
 
 #region Constructor
 public HealthComponent(GameObject owner, float maxHealth) : base(owner)
 {
     this.maxHealth = maxHealth;
     this.currentHealth = maxHealth;
 }
 #endregion
 
 #region Public Methods
 public override void Initialize()
 {
     base.Initialize();
     CurrentHealth = maxHealth;
 }
 
 public override void Update()
 {
     // 实现生命值随时间恢复等逻辑
 }
 
 public void TakeDamage(float damage)
 {
     if (damage <= 0f)
         return;
         
     CurrentHealth -= damage;
 }
 
 public void Heal(float amount)
 {
     if (amount <= 0f)
         return;
         
     CurrentHealth += amount;
 }
 #endregion
}

public class ComponentManager
{
 #region Fields
 private readonly Dictionary<Type, IComponent> components;
 private readonly GameObject owner;
 #endregion
 
 #region Constructor
 public ComponentManager(GameObject owner)
 {
     this.owner = owner;
     components = new Dictionary<Type, IComponent>();
 }
 #endregion
 
 #region Public Methods
 public T AddComponent<T>() where T : IComponent, new()
 {
     Type type = typeof(T);
     
     if (components.ContainsKey(type))
     {
         throw new InvalidOperationException(
             $"Component of type {type.Name} already exists.");
     }
     
     T component = new T();
     components.Add(type, component);
     component.Initialize();
     
     return component;
 }
 
 public T GetComponent<T>() where T : IComponent
 {
     Type type = typeof(T);
     
     if (components.TryGetValue(type, out IComponent component))
     {
         return (T)component;
     }
     
     return default;
 }
 
 public void RemoveComponent<T>() where T : IComponent
 {
     Type type = typeof(T);
     
     if (components.TryGetValue(type, out IComponent component))
     {
         component.Cleanup();
         components.Remove(type);
     }
 }
 
 public void UpdateComponents()
 {
     foreach (var component in components.Values)
     {
         component.Update();
     }
 }
 #endregion
}

总结

在本节中，我们学习了：

  1. C#的命名规范和约定
  2. 代码组织和文件结构
  3. 代码格式化规则
  4. 编程最佳实践
  5. 在游戏开发中的实际应用

通过实战练习，我们实现了：

  1. 一个规范的游戏管理器
  2. 一个完整的组件系统

良好的编程规范和代码风格不仅能提高代码质量，还能提升团队协作效率。在实际游戏开发中，我们应该始终遵循这些规范。

C#代码开发规范
TCMY的专栏
03-24 3120
目录 1. 前言... 4 1.1 编写目的... 4 1.2 适用范围... 4 1.3 基本要求... 4 2. 命名规范... 4 2.1 字母大小写约定... 4 2.1.1 说明... 4 2.1.2 Pascal风格... 4 2.1.3 Camel风格... 5 2.2 标识符的大小写规则... 5 2.3 ...
C#编程规范
wzk456的专栏
09-29 876
C#编程规范         修改记录 Ver. No 发版日期 编制人 批准人 修改的说明                              
C#编程规范-程序员们都应该这样写代码
嘻嘻哈哈．Net
03-17 1191
C#编程规范-程序员们都应该这样写代码                                                         -落叶夏日     为了保证大家使用C#编程和C++的风格的连贯,我在C++的标准备上对C#编程规则作了制定(试用版),在这里感谢大家的支持,特别是Stone   Jiang.           基本要求     1程序结构要求     1.1
强烈推荐：C#编码规范手册
dotNet全栈开发
05-09 3494
要作为一名合格的开发者，最基本的素质就是要做到编码规范，从小我们就接受教导“字如其人”，而写代码亦是如此，良好的代码风格，彰显了个人的工作素养。而良好的代码规范，能够帮助我们进行更好的团队协作，它能方便代码的交流和维护；不会影响编码的效率，不与大众习惯冲突；使代码更美观、阅读更方便；使代码的逻辑更清晰、更易于理解。 那为什么要整理这个规范呢？ 最近社区群里有在讨论C#的编码规范，而网络上也没有一些全面的规范文档，所以我就结合微软官方、Resharper和stylecop的规范，以及曾经网路上的一些规范，整理
C# 编程规范
军哥博客欢迎您
01-21 1764
原文  http://blog.csdn.net/nittystone/article/details/37812293 主题 C# SQL C# 编程规范 修改记录 Ver. No 发版日期 编制人 批准人 修改的说明                
C#编程概述
将进酒，杯莫停。
07-09 1068
    今天开始我们进行C#基础第二章节的学习。2.1    一个简单的C#程序        本章将为学习C#打基础。因为以后会广泛的使用代码示例，所以我们先来看看C#程序的样子，还有他不同部分代表什么意思。        我们从一个简单程序开始，逐渐解释他的各组成部分，这里将介绍许多主题，从C#程序的结构到产生程序屏幕输出的方法。        让我们先观察一个简单的C#程序。完整的源程序在图...
国内大公司内部的 C# 编程规范
nittystone的专栏
07-15 3254
金蝶的c#编程规范
c#代码项目风格要求
caohao的专栏
04-13 1418
1.18 常见集合类型后缀命名 凡符合下表所列的集合类型，应添加相应的后缀。 说明 后缀 示例 数组 Array int[] productArray 列表 List List productList DataTable/HashTable Table HashTable productTable 字典 Dictio
C#编程规范--控件命名篇
tomboy1986的专栏
04-27 693
C#编程规范-程序员们都应该这样写代码                                                         -落叶夏日     为了保证大家使用C#编程和C++的风格的连贯,我在C++的标准备上对C#编程规则作了制定(试用版),在这里感谢大家的支持,特别是Stone   Jiang.           基本要求     1程序结构要求     1.1
c#编程规范和范例
04-16
### C#编程规范详解 #### 一、排版规范 **1.1 程序块缩进** - **规范**: 所有的程序块应当采用缩进风格编写，且缩进的空格数应为一个TAB键的宽度。通常情况下，一个TAB键对应的空格数为4个。 - **例外**: 对于由...
C#编码规范操作文档说明书
05-11
C#编程规范旨在提高代码质量，确保代码的易读性、正确性、一致性、流行性、可靠性和安全性。以下是对这些关键特性的详细解释和实现方法： **1. 易懂** - **代码结构**：确保代码逻辑清晰，避免复杂的嵌套和不必要的...
最新C#编程规范
10-21
通过遵循上述C#编程规范，不仅能够提升代码质量和可读性，还能够增强团队间的协作效率。规范的实施需要每位开发者自觉遵守，以确保项目的长期稳定发展。此外，随着项目规模的增长和技术的发展，规范也需要适时调整和...
IDesign C#编程规范
01-08
### IDesign C#编程规范详解 #### 一、命名规则与风格 **1.1 类和方法名采用Pascal风格** - Pascal风格是指首字母大写的命名方式，例如`MyClass`或`GetUserName`。这种命名方式适用于类名、接口名以及方法名。 **...
基于 C# 开发 SQL Server 数据库应用：深入解析与实战指南
zhu1996zhu的博客
04-01 1545
本文围绕基于C#开发SQL Server数据库应用展开，详述开发环境准备，重点呈现数据库连接、查询、插入、更新及删除操作的专业代码示例，还提及可优化方向，助力开发者掌握相关技能，为用C#开发此类数据库应用提供全面实用的参考。
c# 获取redis中所有的value
A_nanda的博客
03-31 826
通过上述代码，可安全高效地获取 Redis 中所有键的值，并根据需要扩展对不同数据类型的支持。// 使用 SCAN 分页遍历键（避免 KEYS * 的性能问题）// 仅获取字符串类型的值（按需扩展其他类型）/// 安全获取所有键的值（分页扫描模式，避免阻塞 Redis）/// 高性能批量获取字符串值（Pipeline 优化）：全量扫描操作（即使分页）仍可能影响性能，建议在低峰期执行。分页遍历键，减少对 Redis 的阻塞风险。// 方法2：批量获取指定键。// 方法1：安全分页扫描。
C# System.Text.Json 中 JsonNamingPolicy 使用详解
最新发布
鲤籽鲲的博客
04-03 902
C# System.Text.Json 中 JsonNamingPolicy 使用详解
C# System.Text.Json 中 JsonConverter 使用详解
鲤籽鲲的博客
04-03 961
C# System.Text.Json 中 JsonConverter 使用详解
C#里第一个WPF程序
大坡3D软件开发
04-03 85
WPF程序对界面进行优化，但是比WINFORMS的程序要复杂很多，并且界面UI基本上不适合拖放，所以需要比较多的时间来布局界面，随着客户对界面的需求提高，还是需要采用这样的方式来实现。产且需要开发人员编写更多的代码。即使如此，在面对诱人的界面表现，App.xaml文件中定义。从这几堆代码来看，就比较多。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值