[JAVA] Eine etwas besorgniserregende Codesammlung - ich möchte Ihnen die Möglichkeit geben, guten Code zu schreiben. 2 [C # Refactoring Sample]

Eine Sammlung von Codes, die etwas besorgniserregend sind

Während der Codeüberprüfung gab es eine Quelle, an der ich interessiert war, daher werde ich sie auflisten. Es ist keine große Sache, aber es kann nicht geholfen werden.

• Verwendung des nulltoleranten Typs

1. Nullprüfung

            int? inputValue = null;

            //NG Ich konnte mir keine solche Implementierungsmethode vorstellen, deshalb fand ich sie ein wenig erstaunlich.
            if (string.IsNullOrWhiteSpace(inputValue.ToString()))
            {
            }

            //Verwenden Sie die Eigenschaft OK
            if (!inputValue.HasValue)
            {
            }

            // OK !Nullable.Dies ist in Ordnung, da es HasValue entspricht.
            if (inputValue == null)
            {
            }

2. Extrahieren Sie den Wert aus dem nulltoleranten Typ.

            int? inputValue = 1;

            int value;
            if (inputValue.HasValue)
            {
                //NG Lassen Sie uns die Idee beenden, dass alles eine Zeichenkette sein sollte
                value = int.Parse(inputValue.ToString());
                //NG nutzlose Besetzung 1
                value = Convert.ToInt32((object)inputValue);
                //Verwenden Sie die Eigenschaft OK
                value = inputValue.Value;
                //OK Sieht aus wie eine nutzlose Besetzung, aber inputValue.Wert wird aufgerufen.
                value = (int)inputValue;

            }

• Objekttyp

1. Besetzung

            object objectValue = 1;
            int castValue;
            if (objectValue != null)
            {
                //Das Casting als NG-String ist verschwenderisch
                castValue = int.Parse(objectValue.ToString());
                // OK .Verwenden Sie den vom Net Framework bereitgestellten Konvertierungsprozess
                castValue = Convert.ToInt32(objectValue);
                //OK normale Besetzung
                castValue = (int)objectValue;
            }

Zusammenfassung

Viele Leute denken, dass es eine Zeichenkette sein sollte. Auch wenn im Betrieb kein Problem vorliegt, kann der Prüfer nichts dagegen tun.

Beispielcode (Java) 24.03.2017 Hinzugefügt

        /**Nullprüfung**/
        Integer inputValue = null;

        //Niemand würde dies in NG Java schreiben.
        //Übrigens, C.#Int?Da es sich um eine Nullable-Struktur handelt, war vor ToString keine Nullprüfung erforderlich.
        if (inputValue == null || inputValue.toString().length() == 0) {

        }

        //OK Für Java ist es richtig, mit null zu vergleichen.
        if (inputValue == null) {

        }
        /**Null tolerant**/
        Integer inputValue = 1;

        int value;
        if (inputValue != null) {
            //NG Lassen Sie uns die Idee beenden, dass alles eine Zeichenkette sein sollte
            value = Integer.parseInt(inputValue.toString());
            //NG nutzlose Besetzung
            value = (int) inputValue;
            // OK Integer.intValue wird aufgerufen.
            value = inputValue;
            // OK
            value = inputValue.intValue();
        }

        /**Objekttyp**/
        Object objectValue = 1;
        int castValue;
        if (objectValue != null) {
            //NG Wenn Sie den Originaltyp kennen, müssen Sie ihn nicht in eine Zeichenfolge konvertieren.
            castValue = Integer.parseInt(objectValue.toString());
            //OK In Originalform gießen
            castValue = (int) objectValue;
        }

Vorheriger Artikel (verwirrende bedingte Verzweigung)

[Nächster Artikel (fließende Schnittstelle)] (http://qiita.com/csharpisthebest/items/403d40374acc70ef24e3)

Inhaltsverzeichnis