عنوان:

‫معیارهای کد (Code Metrics) و پیکربندی


نویسنده: وحید نصیری
تاریخ: ۱۴۰۴/۰۸/۲۸ ۱۲:۲۵
آدرس: www.dntips.ir
در دنیای توسعه نرم‌افزار، ابزارهای تحلیل کد (Code Metrics) به استانداردی ثابت تبدیل شده‌اند. ویژوال استودیو و اکوسیستم دات‌نت (.NET) ابزارهای قدرتمندی برای اندازه‌گیری کیفیت کد در اختیار ما می‌گذارند، اما نحوه تفسیر و واکنش ما به این اعداد، اغلب داستانی متفاوت و گاه ترسناک دارد. مشکل از جایی شروع می‌شود که تیم‌ها بدون درک "چرایی" این اعداد، کورکورانه به دنبال سبز کردن چراغ‌های داشبورد هستند. در این مقاله، می‌خواهیم بررسی کنیم که این معیارها واقعاً چه چیزی را می‌سنجند، چگونه باید آن‌ها را درست پیکربندی کرد و چرا گاهی اوقات، "کد قرمز" بسیار بهتر از "کد سبز" است.

۱. کالبدشکافی معیارها: واقعاً چه چیزی را اندازه می‌گیریم؟

قبل از اینکه تصمیمی بگیرید، باید بدانید اعداد داشبورد ویژوال استودیو دقیقاً چه معنایی دارند.

شاخص قابلیت نگهداری (Maintainability Index - MI)

این یک نمره ترکیبی بین ۰ تا ۱۰۰ است که مایکروسافت محاسبه می‌کند:
  • ۲۰ تا ۱۰۰ (سبز): نگهداری خوب
  • ۱۰ تا ۱۹ (زرد): نگهداری متوسط
  • ۰ تا ۹ (قرمز): نگهداری سخت

نکته کلیدی: این عدد ترکیبی از "پیچیدگی سایکلماتیک"، "تعداد خطوط کد" و "حجم محاسباتی" است. اما فریب نخورید؛ یک متد می‌تواند نمره ۸۰ بگیرد اما اصول SOLID را نقض کرده باشد، یا برعکس، یک الگوریتم پیچیده ریاضی نمره پایین بگیرد در حالی که بهترین پیاده‌سازی ممکن را دارد.

پیچیدگی سایکلماتیک (Cyclomatic Complexity)

این معیار، تعداد مسیرهای مستقل اجرایی در کد را می‌شمارد. هر if, for, while, case, && یا || یک واحد به این عدد اضافه می‌کند.
  • عرف عمومی: زیر ۱۰ عالی، ۱۰ تا ۲۰ متوسط، بالای ۲۰ نیازمند بازبینی.

نکته‌ی تکمیلی: پیچیدگی سایکلماتیک یک ایراد بزرگ دارد؛ این روش "تعداد شاخه‌ها" را می‌شمارد، نه "سختی درک" را. یک متد switch-case ساده با ۲۰ حالت، پیچیدگی ۲۰ دارد اما کاملاً خواناست. در مقابل، ۳ حلقه تودرتو پیچیدگی کمتری دارد اما درک آن عذاب‌آور است. (اینجاست که معیاری مدرن‌تر به نام Cognitive Complexity که در ابزارهایی مثل SonarQube وجود دارد، تصویر واقعی‌تری ارائه می‌دهد).

وابستگی بین کلاس‌ها (Class Coupling)

تعداد کلاس‌های دیگری که کلاس شما به آن‌ها ارجاع دارد. وابستگی زیاد معمولاً بد است، اما نه همیشه. یک کلاس Controller در معماری وب، طبیعتاً به سرویس‌ها، مدل‌های ورودی و خروجی و لاگرها وابسته است. تلاش برای صفر کردن این وابستگی، منجر به کدهای انتزاعی و غیرقابل فهم می‌شود.

۲. دام بزرگ: حد آستانه‌های بدون منطق (Thresholds)

بزرگترین اشتباه صنعت نرم‌افزار، اعمال قوانین خشک روی این اعداد است. اینکه بگوییم "هر متدی با پیچیدگی بالای ۱۵ باید شکسته شود" دقیقاً مثل این است که بگوییم "هر جمله‌ای در کتاب باید دقیقاً ۱۰ کلمه باشد".
مثال واقعی از فاجعه:
تیمی را در نظر بگیرید که یک متد "مدیریت سفارش" (Order Orchestrator) داشت. این متد ۲۰ مرحله خطی و شفاف داشت (اعتبارسنجی، کسر از انبار، پرداخت، ایمیل و...). پیچیدگی سایکلماتیک آن ۱۸ بود (که بالا محسوب می‌شد).
تیم برای راضی کردن ابزار SonarQube، این متد را تکه‌تکه کرد و به ۱۸ متد کوچک در ۴ فایل مختلف تقسیم نمود.
نتیجه؟ پیچیدگی پایین آمد، اما هیچکس دیگر نمی‌توانست با یک نگاه بفهمد فرآیند سفارش چگونه کار می‌کند. برای دیباگ کردن باید بین ۴ فایل پینگ‌پنگ بازی می‌کردید. کیفیت قربانی متریک شد.
قانون طلایی: متریک‌ها "سیگنال" هستند، نه "حکم دادگاه". آن‌ها به شما می‌گویند "اینجا را نگاه کن"، نمی‌گویند "اینجا را عوض کن".

۳. پیکربندی حرفه‌ای در .NET

بسیاری از توسعه‌دهندگان نمی‌دانند که می‌توانند این قوانین را شخصی‌سازی کنند. به جای استفاده از تنظیمات پیش‌فرض مایکروسافت، باید آن‌ها را مطابق پروژه خود تنظیم کنید.

استفاده از.editorconfig(روش مدرن)

بهترین راه برای اعمال قوانین، فایل .editorconfig است که همراه کد در گیت ذخیره می‌شود تا همه اعضای تیم قانون یکسانی داشته باشند.
# Code metrics configuration
[*.cs]

# تنظیم پیچیدگی سایکلماتیک روی ۲۵ (به جای ۱۵ پیش‌فرض)
dotnet_diagnostic.CA1502.severity = warning
dotnet_code_quality.CA1502.cyclomatic_complexity = 25

# نادیده گرفتن پیچیدگی در کدهای تولید شده (Generated Code)
[**/Generated/**.cs]
dotnet_diagnostic.CA1502.severity = none

هشدار جدی: قانون CA1509 (پیکربندی نامعتبر)

مایکروسافت قانونی به نام CA1509 دارد که وظیفه آن بررسی صحت فایل کانفیگ شماست. چرا؟
چون اگر در فایل کانفیگ اشتباه تایپی داشته باشید (مثلاً بنویسید warnin به جای warning)، ابزار هیچ خطایی نمی‌دهد و آن قانون را در سکوت غیرفعال می‌کند!
تیم‌های زیادی ماه‌ها فکر می‌کردند کدشان استاندارد است، در حالی که یک غلط املایی کل سیستم نظارتی‌شان را خاموش کرده بود. همیشه مطمئن شوید که آنالیزورها به درستی لود شده‌اند.

پیکربندی در سطح پروژه (.csproj)

برای اینکه مطمئن شوید قوانین در CI/CD هم چک می‌شوند (نه فقط وقتی دولوپر یادش باشد کلیک کند)، این تنظیمات را به فایل پروژه اضافه کنید:
<PropertyGroup>
  <EnableNETAnalyzers>true</EnableNETAnalyzers>
  <AnalysisLevel>latest</AnalysisLevel>
  
  <WarningsAsErrors>CA1502;CA1505</WarningsAsErrors>
</PropertyGroup>

۴. مثال‌های واقعی: وقتی متریک‌ها دروغ می‌گویند

بیایید سه سناریوی واقعی را ببینیم که در آن‌ها قضاوت انسانی بر اعداد ارجحیت دارد.

مثال ۱: متد ارکستراتور (پیچیدگی بالا، خوانایی عالی)
public async Task<OrderResult> ProcessOrderAsync(OrderRequest request)
{
    // پیچیدگی: ۱۸ (اما کاملاً خطی و خوانا)
    if (request == null) throw ...;
    if (!await ValidateUser(request)) return ...;
    if (!await CheckInventory(request)) return ...;
    if (!await ProcessPayment(request)) return ...;
    // ... مراحل بعدی
    return OrderResult.Success();
}
تحلیل: ابزار به شما می‌گوید این متد را بشکنید. پاسخ شما باید "نه" باشد. این متد یک داستان واحد را روایت می‌کند. شکستن آن فقط خوانایی را از بین می‌برد.

مثال ۲: متد فریبنده (پیچیدگی پایین، خوانایی افتضاح)
public int CalculateDiscount(Customer c, Order o)
{
    // پیچیدگی: ۳ (از نظر ابزار عالی است!)
    return (c.Tier == "Gold" && o.Total > 1000) ? 20 :
           (c.Tier == "Silver" && o.Total > 500) ? 10 : 0;
}
تحلیل: ابزار این کد را تأیید می‌کند چون شاخه‌های کمی دارد. اما استفاده تودرتو از عملگر سه تایی (Ternary Operator) درک آن را سخت کرده است. این کد نیاز به بازآرایی دارد، با اینکه "سبز" است.

مثال ۳: اعتبارسنجی تنظیمات (Guard Clauses)

متدی که ۲۰ فیلد کانفیگ را چک می‌کند که null نباشند.
تحلیل: پیچیدگی این متد ۲۰ است. اما آیا باید آن را تغییر داد؟ خیر. الگوی Guard Clause بسیار تمیز است. اگر فقط برای کاهش عدد، آن را به VerifyStringConfigs و VerifyIntConfigs تقسیم کنید، کد را بیهوده شلوغ کرده‌اید.

۵. بهترین روش‌های پیاده‌سازی (Best Practices)

برای اینکه تیمتان اسیر "فرقه متریک‌ها" نشود، این رویکردها را دنبال کنید:
- قانون گودهارت (Goodhart's Law) را به یاد داشته باشید:
"وقتی یک معیار تبدیل به هدف شود، دیگر معیار خوبی نیست."
هدف شما "کد قابل نگهداری" است، نه "پیچیدگی زیر ۱۰".
- استفاده از SuppressMessage با ذکر دلیل:
  • اگر کدی دارید که پیچیده است اما دلیل موجهی دارد، آن را سرکوب (Suppress) کنید اما حتماً دلیل را کامنت کنید. این کار به توسعه‌دهنده بعدی می‌گوید: "من حواسم به پیچیدگی بود، اما عمداً این مدل را انتخاب کردم."
// Justification: Orchestration logic needs to be linear for readability.
[SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
public void ComplexOrchestrator() { ... }
- روند را دنبال کنید، نه اعداد مطلق را:
  • به جای اینکه بگویید "همه متدها باید زیر ۱۵ باشند"، بگویید "میانگین پیچیدگی پروژه نباید نسبت به ماه قبل بدتر شود". این رویکرد (Ratchet) بسیار سالم‌تر است.
- بازبینی کد (Code Review) بر ابزار مقدم است:
  • اگر ابزار خطایی گرفت، در جلسه Code Review درباره آن صحبت کنید. اگر تیم موافق بود که کد خواناست، تنظیمات ابزار را برای آن مورد نادیده بگیرید. اجازه ندهید ربات‌ها جایگزین تفکر مهندسی شوند.

نتیجه‌گیری

معیارهای کد (Code Metrics) ابزارهای تشخیصی هستند، نه نسخه پزشک. آن‌ها به شما می‌گویند کجا را نگاه کنید، اما نمی‌گویند چه کاری انجام دهید.
کاربران نهایی اهمیتی نمی‌دهند که "پیچیدگی سایکلماتیک" شما ۵ است یا ۵۰؛ آن‌ها نرم‌افزاری می‌خواهند که درست کار کند و باگ نداشته باشد. اگر بازآرایی کد صرفاً برای کاهش یک عدد انجام شود و نتیجه آن کدی ناخوانا یا با ساختاری عجیب باشد، شما در حال تخریب پروژه هستید، نه بهبود آن.

گام بعدی برای شما:
پیشنهاد می‌شود همین امروز فایل .editorconfig پروژه خود را باز کنید. آیا قوانین CA1502 (پیچیدگی) فعال هستند؟ آیا آستانه‌های آن با واقعیت پروژه شما همخوانی دارند یا صرفاً پیش‌فرض‌های مایکروسافت هستند؟ یک جلسه ۱۵ دقیقه‌ای با تیم بگذارید و قوانین را "بومی‌سازی" کنید.