Unity C# Best Practices: Essential Coding Rules for Game Developers

**Code Organization and Style**

**Do:** Organize code with #region blocks for better readability, use PascalCase for public members and camelCase for private ones, and apply [SerializeField] for inspector-exposed private fields.
*Example:*
```csharp
[SerializeField] private float m_speed;
public float Speed => m_speed;
```

**Don't:** Scatter code without structure or expose private fields directly without attributes.
*Example (Avoid):*
```csharp
public float speed; // No casing consistency or serialization
```

**Performance and Architecture**

**Do:** Favor TryGetComponent over GetComponent to prevent null errors, implement object pooling for repeated instantiations, and use ScriptableObjects for shared data.
*Example:*
```csharp
if (TryGetComponent<Rigidbody>(out var rb)) { rb.AddForce(Vector3.up); }
```

**Don't:** Rely on expensive GameObject.Find() or Transform.Find() in Update loops.
*Example (Avoid):*
```csharp
GameObject.Find("Player"); // Slow and unreliable
```

**Unity-Specific Optimizations**

**Do:** Use TextMeshPro for all text, Coroutines for async timing, Job System for heavy computations, and LOD for 3D models; wrap editor code in #if UNITY_EDITOR.
*Example:*
```csharp
#if UNITY_EDITOR
[ContextMenu("Test")] private void Test() { Debug.Log("Test"); }
#endif
```

**Don't:** Instantiate/destroy objects frequently without pooling or use legacy UI Text components.
*Example (Avoid):*
```csharp
Instantiate(prefab); Destroy(gameObject); // Causes GC spikes
```

**Naming Conventions**

**Do:** Prefix members with m_ (e.g., m_health), constants with c_ (e.g., c_maxHealth), statics with s_, and use descriptive names for methods/properties.
*Example:*
```csharp
private const int c_MaxHealth = 100;
private int m_currentHealth;
```

**Don't:** Use generic names like 'temp' or inconsistent prefixes.
*Example (Avoid):*
```csharp
int temp; // Unclear purpose
```

**Lifecycle and Error Handling**

**Do:** Override Awake/Start/OnDestroy properly, add robust logging, and consider cross-platform hardware variations with Range attributes.
*Example:*
```csharp
[SerializeField, Range(0f, 100f)] private float m_maxSpeed;
private void Awake() { /* Init safely */ }
```

**Don't:** Perform heavy logic in Update without optimization or ignore platform differences.
*Example (Avoid):*
```csharp
void Update() { HeavyComputation(); } // Drains battery/performance