[JAVA] Getter, Setter Reverse Problem-10 [C # Refactoring Sample]

Warum kehren Sie Getter und Setter um?

Sogar Leute, die normalerweise keine Codierungsprobleme haben, können Code finden, der Getter und Setter umkehrt. Wenn Sie Getter als Rückgabewert für die zu erfassenden Daten verwenden und Setter zum Ändern interner Variablen oder zum Aktualisieren von Argumenten verwenden, können Sie Setter verwenden, dies ist jedoch möglicherweise nicht so einfach. Schauen wir uns den Beispielcode an.

Beispielcode

Der gesamte Beispielcode vereinfacht den Code, den Sie in einem realen Projekt gesehen haben. Es ist zu beachten, dass die Verarbeitung von NG1 nach NG3 nicht zusammenhängt und keine Reihe von Verarbeitungen ist.

        private void Main()
        {
            //NG1 Get-Methode, obwohl es keinen Rückgabewert gibt und das Argument aktualisiert wird
            var dtoes = new List<Dto>();
            GetData(dtoes);

            //NG2 Methode festlegen, obwohl ein Rückgabewert vorhanden ist
            dtoes = SetData();

            //NG3 Aufgrund einer Mischung korrekter Setter schwer zu lesen
            var dto2 = SetDto2();
            dto2.SetDtoes(SetData());
        }

        private void GetData(List<Dto> dtoes)
        {
            //Vermutlich von der DB erworben.
            dtoes.Add(new Dto());
        }

        private List<Dto> SetData()
        {
            //Vermutlich von der DB erworben.
            var dtoes = new List<Dto>();
            return new List<Dto>();
        }

        private Dto2 SetDto2()
        {
            var dto2 = new Dto2();
            return dto2;
        }

        /**Tabelle DTO**/
        private class Dto
        {

        }

        /**Übergeordnetes DTO mit Dto als Mitglied**/
        private class Dto2
        {
            public List<Dto> _dtoes;

            public void SetDtoes(List<Dto> dtoes)
            {
                _dtoes = dtoes;
            }
        }

    public void main() {
        //NG1 Get-Methode, obwohl es keinen Rückgabewert gibt und das Argument aktualisiert wird
        List<Dto> dtoes = new ArrayList<Dto>();
        getData(dtoes);

        //NG2 Methode festlegen, obwohl ein Rückgabewert vorhanden ist
        dtoes = setData();

        //NG3 Aufgrund einer Mischung korrekter Setter schwer zu lesen
        Dto2 dto2 = setDto2();
        dto2.setDtoes(setData());
    }

    private void getData(List<Dto> dtoes) {
        //Vermutlich von der DB erworben.
        dtoes.add(new Dto());
    }

    private List<Dto> setData() {
        //Vermutlich von der DB erworben.
        List<Dto> dtoes = new ArrayList<Dto>();
        return new ArrayList<Dto>();
    }

    private Dto2 setDto2() {
        Dto2 dto2 = new Dto2();
        return dto2;
    }

    /**Tabelle DTO**/
    private class Dto {

    }

    /**Übergeordnetes DTO mit Dto als Mitglied**/
    private class Dto2 {
        public List<Dto> _dtoes;

        public void setDtoes(List<Dto> dtoes) {
            _dtoes = dtoes;
        }
    }

Erwägung

Überlegen Sie, warum es wie im obigen Beispielcode aussieht. GetData: Getter, weil wir Daten von der DB erhalten SetData: Da die von DB erfassten Daten gesetzt und zurückgegeben werden, Setter SetDto2: Setter, da die Instanz gesetzt und zurückgegeben wird SetDtoes: Setter, weil Dto gesetzt ist Ist das der Ort? Es gibt kein Gefühl der Einheit und der Code ist schwer zu lesen. Wenn die zu erfassenden Daten als Rückgabewert verwendet werden, habe ich sie mit einer Regel namens Get umgeschrieben, interne Variablen aktualisiert und Argumente mit einer Regel namens Set aktualisiert.

Nach dem Refactoring

       private void Main()
        {
            //OK Argument Update
            var dtoes = new List<Dto>();
            SetData(dtoes);

            //OK Der Rückgabewert sind die erfassten Daten.
            dtoes = GetData();

            //OK Getter und Setter wurden vereinheitlicht, um das Lesen zu erleichtern.
            var dto2 = GetDto2();
            dto2.SetDtoes(GetData());
        }

        private void SetData(List<Dto> dtoes)
        {
            //Vermutlich von der DB erworben.
            dtoes.Add(new Dto());
        }

        private List<Dto> GetData()
        {
            //Vermutlich von der DB erworben.
            var dtoes = new List<Dto>();
            return new List<Dto>();
        }

        private Dto2 GetDto2()
        {
            var dto2 = new Dto2();
            return new Dto2();
        }

        /**Tabelle DTO**/
        private class Dto
        {

        }

        /**Übergeordnetes DTO mit Dto als Mitglied**/
        private class Dto2
        {
            public List<Dto> _dtoes;

            public void SetDtoes(List<Dto> dtoes)
            {
                _dtoes = dtoes;
            }
        }

    public void main() {

        //OK Argument Update
        List<Dto> dtoes = new ArrayList<Dto>();
        setData(dtoes);

        //OK Der Rückgabewert sind die erfassten Daten.
        dtoes = getData();

        //OK Getter und Setter wurden vereinheitlicht, um das Lesen zu erleichtern.
        Dto2 dto2 = getDto2();
        dto2.setDtoes(getData());
    }

    private void setData(List<Dto> dtoes) {
        //Vermutlich von der DB erworben.
        dtoes.add(new Dto());
    }

    private List<Dto> getData() {
        //Vermutlich von der DB erworben.
        List<Dto> dtoes = new ArrayList<Dto>();
        return new ArrayList<Dto>();
    }

    private Dto2 getDto2() {
        Dto2 dto2 = new Dto2();
        return dto2;
    }

    /**Tabelle DTO**/
    private class Dto {

    }

    /**Übergeordnetes DTO mit Dto als Mitglied**/
    private class Dto2 {
        public List<Dto> _dtoes;

        public void setDtoes(List<Dto> dtoes) {
            _dtoes = dtoes;
        }
    }

Vorheriger Artikel (Können wir Funktionsaufrufe und Bedingungen trennen?)

Nächster Artikel (Alles anordnen)

Inhaltsverzeichnis