[JAVA] Getter, Setter Reverse Problem-10 [Exemple de refactoring C #]

Pourquoi inversez-vous Getter et Setter?

Même les personnes qui n'ont normalement aucun problème de codage peuvent trouver du code qui inverse Getter et Setter. Si vous utilisez Getter comme valeur de retour pour les données à acquérir, et si vous utilisez Setter pour modifier des variables internes ou mettre à jour des arguments, vous pouvez utiliser Setter, mais ce n'est peut-être pas si simple. Regardons l'exemple de code.

Exemple de code

L'ensemble de l'exemple de code simplifie le code que vous avez vu dans un vrai projet. Il est à noter que le traitement de NG1 à NG3 n'est pas lié et n'est pas une série de traitements.

        private void Main()
        {
            //NG1 Get méthode même s'il n'y a pas de valeur de retour et que l'argument est mis à jour
            var dtoes = new List<Dto>();
            GetData(dtoes);

            //NG2 Set méthode même s'il y a une valeur de retour
            dtoes = SetData();

            //NG3 Difficile à lire en raison d'un mélange de Setters corrects
            var dto2 = SetDto2();
            dto2.SetDtoes(SetData());
        }

        private void GetData(List<Dto> dtoes)
        {
            //Supposé avoir été acquis de DB.
            dtoes.Add(new Dto());
        }

        private List<Dto> SetData()
        {
            //Supposé avoir été acquis de DB.
            var dtoes = new List<Dto>();
            return new List<Dto>();
        }

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

        /**Tableau DTO**/
        private class Dto
        {

        }

        /**Parent DTO avec Dto comme membre**/
        private class Dto2
        {
            public List<Dto> _dtoes;

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

    public void main() {
        //NG1 Get méthode même s'il n'y a pas de valeur de retour et que l'argument est mis à jour
        List<Dto> dtoes = new ArrayList<Dto>();
        getData(dtoes);

        //NG2 Set méthode même s'il y a une valeur de retour
        dtoes = setData();

        //NG3 Difficile à lire en raison d'un mélange de Setters corrects
        Dto2 dto2 = setDto2();
        dto2.setDtoes(setData());
    }

    private void getData(List<Dto> dtoes) {
        //Supposé avoir été acquis de DB.
        dtoes.add(new Dto());
    }

    private List<Dto> setData() {
        //Supposé avoir été acquis de DB.
        List<Dto> dtoes = new ArrayList<Dto>();
        return new ArrayList<Dto>();
    }

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

    /**Tableau DTO**/
    private class Dto {

    }

    /**Parent DTO avec Dto comme membre**/
    private class Dto2 {
        public List<Dto> _dtoes;

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

Considération

Considérez pourquoi il ressemble à l'exemple de code ci-dessus. GetData: Getter parce que nous obtenons des données de DB SetData: puisque les données acquises à partir de la base de données sont définies et renvoyées, Setter SetDto2: Setter car l'instance est définie et renvoyée SetDtoes: Setter car Dto est défini Est-ce que c'est l'endroit? Il n'y a pas de sentiment d'unité et le code est difficile à lire. Si les données à acquérir sont utilisées comme valeur de retour, je les réécris avec une règle appelée Get, mettant à jour les variables internes et mettant à jour les arguments avec une règle appelée Set.

Après refactoring

       private void Main()
        {
            //Mise à jour de l'argument OK
            var dtoes = new List<Dto>();
            SetData(dtoes);

            //OK La valeur de retour correspond aux données acquises.
            dtoes = GetData();

            //OK Getter et Setter ont été unifiés pour faciliter la lecture.
            var dto2 = GetDto2();
            dto2.SetDtoes(GetData());
        }

        private void SetData(List<Dto> dtoes)
        {
            //Supposé avoir été acquis de DB.
            dtoes.Add(new Dto());
        }

        private List<Dto> GetData()
        {
            //Supposé avoir été acquis de DB.
            var dtoes = new List<Dto>();
            return new List<Dto>();
        }

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

        /**Tableau DTO**/
        private class Dto
        {

        }

        /**Parent DTO avec Dto comme membre**/
        private class Dto2
        {
            public List<Dto> _dtoes;

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

    public void main() {

        //Mise à jour de l'argument OK
        List<Dto> dtoes = new ArrayList<Dto>();
        setData(dtoes);

        //OK La valeur de retour correspond aux données acquises.
        dtoes = getData();

        //OK Getter et Setter ont été unifiés pour faciliter la lecture.
        Dto2 dto2 = getDto2();
        dto2.setDtoes(getData());
    }

    private void setData(List<Dto> dtoes) {
        //Supposé avoir été acquis de DB.
        dtoes.add(new Dto());
    }

    private List<Dto> getData() {
        //Supposé avoir été acquis de DB.
        List<Dto> dtoes = new ArrayList<Dto>();
        return new ArrayList<Dto>();
    }

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

    /**Tableau DTO**/
    private class Dto {

    }

    /**Parent DTO avec Dto comme membre**/
    private class Dto2 {
        public List<Dto> _dtoes;

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

Article précédent (Peut-on séparer les appels de fonction et les conditions?)

Article suivant (Tout organiser)

Table des matières