Visual Studio-Code-Metriken und der Wartbarkeit Index des Schaltergehäuses

Question

Als eine Person, die die besten Praktiken zu folgen liebt,

Wenn ich Code-Metriken (Rechtsklick auf Projektnamen in Lösung Explorer und wählen Sie "Berechnen-Code Metrics" - Visual Studio 2010) laufen auf:

    public static string GetFormFactor(int number)
    {
        string formFactor = string.Empty;
        switch (number)
        {
            case 1:
                formFactor = "Other";
                break;

            case 2:
                formFactor = "SIP";
                break;

            case 3:
                formFactor = "DIP";
                break;

            case 4:
                formFactor = "ZIP";
                break;

            case 5:
                formFactor = "SOJ";
                break;
        }

        return formFactor;
    }

Es gibt mir ein Wartbarkeitsindex von 61

(natürlich diese unbedeutend ist, wenn Sie diese haben, aber wenn Sie ein Dienstprogramm wie Klasse whos Philosophie verwenden tut Sachen, Ihre Utility-Klasse wird die Wartbarkeit Index haben viel schlimmsten ..)

Was ist die Lösung?

Answer 1

Zu allererst: 61 wird als wartbaren Code sein. Für den Wartbarkeit Index ist 100 sehr einfach Code zu erhalten, während 0 ist schwer aufrecht zu erhalten.

• 0-9 = schwer zu pflegen
• 10-19 = mäßig halten
• 20-100 = gut zu halten

Die Wartbarkeit Index basiert auf drei Code-Metriken: Nämlich die Halstead Volumen, die zyklomatische Komplexität und Codezeilen und basierend auf der folgende Formel :

MAX (0, (171 bis 5,2 * ln (Halstead Volume) - 0,23 * (Zyklomatische Komplexität) - 16,2 * ln (Linien Code)) * 100/171)

In der Tat, in Ihrem Beispiel die Ursache für den niedrigen Wert des Maintainability Index ist die zyklomatische Komplexität. Dieser Messwert wird basierend auf den verschiedenen Ausführungspfaden in dem Code berechnet. Leider hat die Metrik nicht unbedingt mit „menschlicher Lesbarkeit“ des Codes auszurichten.

Beispiele wie Ihr Code Ergebnis in sehr niedrigen Indexwerten (denken Sie daran, niedrigere Mittel härter zu halten), aber in Wirklichkeit sind sie sehr leicht zu lesen. Dies ist üblich, wenn zyklomatische Komplexität unter Verwendung von Code zu bewerten.

Stellen Sie sich vor Code, der einen Schalter-Block für Tage (Mo-So) und einen Schalter-Block für Monate (Jan-Dez) hat. Dieser Code wird sehr gut lesbar und wartbar sein, aber in einer enormen zyklomatische Komplexität und somit in einem sehr niedrigen Wartbarkeit Index in Visual Studio 2010.

führen

Dies ist eine gut bekannte Tatsache über die Metrik und soll in Betracht gezogen werden, wenn Code beurteilt wird, die Zahlen auf der Grundlage. Anstatt bei der absoluten Zahl suchen, sollten die Zahlen überwacht im Laufe der Zeit als Indikator für die Änderung des Codes zu verstehen. Z.B. wenn der Wartbarkeit Index immer bei 100 war und ging plötzlich auf 10 nach unten sollten Sie die Änderung kontrollieren, die dies verursacht.

Answer 2

Der Wartbarkeitsindex könnte höher sein, weil der Mangel an Erweiterungsmöglichkeiten in der Methode, die Sie für Ihre Lösung wählen.

Die richtige Lösung (Mark Simpson auf oben berühren) ist derjenige, der einen neuen Formfaktor erweitert werden kann, ohne den Code verwenden umgebaut - Switch / Case-Anweisungen im Code ist immer ein Zeichen dafür, dass OO-Design vergessen wurde und soll immer als schlechter Code Geruch zu erkennen.

Ich persönlich würde implementieren ...

interface IFormFactor
{
    // some methods
}

class SipFormFactor : IFormFactor...

class DipFormFactor : IFormFactor...

Etc.

... und haben die Methoden auf der Schnittstelle die gewünschte Funktionalität bieten -. Sie daran denken können [ich denke], wie in zu GoF Command-Mustern ähnlich zu sein

Auf diese Weise Ihre höheren Ebene Methoden nur sein kann ...

MyMethod(IFormFactor factor)
{
    // some logic...

    factor.DoSomething();

    // some more logic...
}

... und Sie können zu einem späteren Zeitpunkt kommen und einen neuen Formfaktor einführen, ohne den Code zu ändern, wie Sie es mit der hartcodierte Schalter-Klausel. Dort finden Sie auch dieser Ansatz finden eignet sich auch leicht zu TDD (Sie mit diesem am Ende sollten, wenn Sie TDD richtig tun), da es leicht spöttischen ist.

Answer 3

Ich weiß, diese Antwort ist sehr spät, aber ich war daran interessiert, dass noch niemand die Wörterbuch-Lösung setzen. Ich habe festgestellt, dass, wenn mit großen Switch-Anweisungen handelt, die datenorientiert wie diese sind, ist es oft besser lesbar den Schalter-Fall in ein Wörterbuch kollabieren.

public static readonly IDictionary<int, string> Factors = new Dictionary<int, string> {
   { 1, "Other" },
   { 2, "SIP" },
   { 3, "DIP" },
   { 4, "ZIP" },
   { 5, "SOJ" }
};

public static string GetFormFactor2(int number)
{
   string formFactor = string.Empty;
   if (Factors.ContainsKey(number)) formFactor = Factors[number];
   return formFactor;
}

Das gibt Ihnen einen Wartbarkeitsindex von 74 - etwas niedriger als die Array-Lösung, weil der Klasse zu einem Wörterbuch Kopplung, aber ich fühle es allgemeinere ist, weil es für eine beliebige Anzahl von Arten funktioniert würden Sie normalerweise einschalten. Wie die Array-Lösung skaliert es sehr gut und entfernt eine Menge von sich wiederholenden Code.

Im Allgemeinen eine datengetriebene Ansatz können Sie Ihren Code helfen klarer zu sein, weil es die wichtigen Stücke (in diesem Fall eine Bedingung und ein Ergebnis) trennt sich von der cruft (in diesem Fall der Schalter-Fall) .

Answer 4

Zwei Dinge in dem Sinne:

Verwenden Sie eine Enumeration, die Beschreibung und den Wert heiraten bis

public enum FormFactor
{
    Other = 1,
    SIP = 2,
    etc.
}

Verwenden Sie eine Klasse oder Struktur jeden Formfaktor darstellen

public class FormFactor 
{
    public int Index { get; private set; }
    public string Description { get; private set; }

    public FormFactor(int index, string description)
    {
        // do validation and assign properties
    }
}

Answer 5

Ich würde es auf diese Weise tun und vergessen Sie die Wartbarkeit Index:

public static string GetFormFactor(int number)
{
    switch (number)
    {
        case 1: return "Other";
        case 2: return "SIP";
        case 3: return "DIP";
        case 4: return "ZIP";
        case 5: return "SOJ";
    }

    return number.ToString();
}

IMHO leicht zu lesen und einfach zu wechseln.

Answer 6

Ich weiß nicht, wie viel es darauf ankommt, aber die folgende erhält ein 76:

private static string[] _formFactors = new[] { null, "Other","SIP","DIP", "ZIP", "SOJ"};
public static string GetFormFactor2(int number)
{
    if (number < 1 || number > _formFactors.Length)
    {
        throw new ArgumentOutOfRangeException("number");
    }

    return _formFactors[number];
}

Answer 7

für mich klar, dass die Enum Methode ist die wartbar, da es nicht hartcodierte Strings mit sich bringt somit keinen Tippfehler Problem und Kompilierung-Syntaxprüfung. Nur Einschränkungen Regeln sind zu nennen.