RhinoMCPServer CLAUDE.md

C# Design Principles

Overview

This document outlines the C# design philosophy for this project, drawing inspiration from three influential software engineers and their distinct approaches to code quality and architecture.

Core Design Philosophy

John Carmack's Approach: Functional Clarity & Performance

"The idea that I can be presented with a problem, set out to logically solve it with the tools at hand, and wind up with a program that could not be implemented in any other language."

Principles:

• Pure Functions First: Favor stateless, predictable methods over stateful classes
• Explicit Dependencies: Make all dependencies visible in constructors and method signatures
• Minimal Abstractions: Only abstract when complexity reduction is clear and measurable
• Performance Awareness: Consider memory allocation, GC pressure, and execution paths

Implementation:

// Good: Pure function with explicit dependencies
public static class ProjectCalculator
{
    public static int CalculateProjectProgress(IReadOnlyList<Process> processes)
    {
        if (processes is null || processes.Count == 0)
        {
            return 0;
        }

        var completed = processes.Count(p => p.Progress == 100);
        return (int)Math.Round((double)completed / processes.Count * 100);
    }
}

// Avoid: Hidden state and side effects
public class ProjectManager
{
    private readonly Dictionary<Guid, object> _cachedStats = new(); // Hidden state

    public void UpdateProject(Project project)
    {
        // ... side effects buried in methods
    }
}

Robert C. Martin's Approach: Clean Architecture & SOLID

"Clean code is simple and direct. Clean code reads like well-written prose."

Principles:

• Single Responsibility: Each class/method has one reason to change
• Dependency Inversion: Depend on abstractions, not concretions
• Clear Naming: Names should reveal intent without comments
• Small Methods: Methods should do one thing well