Compréhension approfondie du modèle stratégique des modèles de conception C# et du partage de cas spécifique au rôle

Modèle de stratégie

Le modèle de stratégie est un modèle de comportement qui définit une série d'algorithmes, encapsule chaque algorithme et les rend interchangeables, permettant à l'algorithme de changer indépendamment du client qui l'utilise.

L'utilisation du modèle de stratégie peut séparer le comportement et l'environnement. La classe d'environnement est responsable de la maintenance et de l'interrogation de la classe de comportement, et divers algorithmes sont fournis dans la classe de stratégie spécifique.

Rôle :

1. Stratégie abstraite (Stratégie)

Il s'agit d'un rôle abstrait, généralement implémenté par une interface ou une classe abstraite. Ce rôle donne toutes les interfaces requises par les classes de stratégie concrètes ;

2. Stratégie concrète

Une classe de stratégie concrète qui implémente des stratégies abstraites et regroupe des algorithmes ou des comportements associés

3. . La classe Environment (Context)

contient une référence à la classe Strategy et peut sélectionner la stratégie correspondante pour l'instance en fonction de la logique.

Exemple :

L'espace de noms StrategyPattern contient la classe de base de stratégie Tax et ses 8 classes d'implémentation La classe d'environnement Context prend en charge There. sont des classes de base stratégiques. Cet exemple fournit une manière élégante de calculer l’impôt sur le revenu des personnes physiques.

Notes de développement C# 04-Comment utiliser C# pour calculer l'impôt sur le revenu des personnes physiques avec élégance ?

namespace StragetyPattern

public abstract class Tax {

    protected decimal TaxRate = 0;

    protected decimal QuickDeduction = 0;

    public virtual decimal Calculate(decimal income) {
        return income * TaxRate - QuickDeduction;
    }

}

La classe de base de stratégie Tax représente l'impôt sur le revenu des personnes physiques, TaxRate est le taux d'imposition, QuickDeduction est la déduction à calcul rapide et Calculate calcule l'impôt sur le revenu des personnes physiques du revenu correspondant.

public class Level0 : Tax {

    public Level0() {
        TaxRate = 0.00m;
        QuickDeduction = 0;
    }

}

Le niveau 0 de l'échelle de l'impôt sur le revenu des personnes physiques représente le statut initial de l'impôt sur le revenu des personnes physiques.

public class Level1 : Tax {

    public Level1() {
        TaxRate = 0.03m;
        QuickDeduction = 0;
    }

}

Échelle de l'impôt sur le revenu des personnes physiques de niveau 1.

public class Level2 : Tax {

    public Level2() {
        TaxRate = 0.10m;
        QuickDeduction = 105;
    }

}

Échelle de l'impôt sur le revenu des personnes physiques niveau 2.

public class Level3 : Tax {

    public Level3() {
        TaxRate = 0.20m;
        QuickDeduction = 555;
    }

}

3 niveaux d'échelle de l'impôt sur le revenu des personnes physiques.

public class Level4 : Tax {

    public Level4() {
        TaxRate = 0.25m;
        QuickDeduction = 1005;
    }

}

4 niveaux d'échelle d'impôt sur le revenu des personnes physiques.

public class Level5 : Tax {

    public Level5() {
        TaxRate = 0.30m;
        QuickDeduction = 2755;
    }

}

Échelle d'impôt sur le revenu des personnes physiques à 5 niveaux.

public class Level6 : Tax {

    public Level6() {
        TaxRate = 0.35m;
        QuickDeduction = 5505;
    }

}

6 niveaux d'échelle d'impôt sur le revenu des personnes physiques.

public class Level7 : Tax {

    public Level7() {
        TaxRate = 0.45m;
        QuickDeduction = 13505;
    }

}

Échelle d'impôt sur le revenu des personnes physiques à 7 niveaux.

public class Context {

    private Tax _tax = null;

    private const decimal EXEMPTION_VALUE = 3500m;

    private List<decimal> _taxLevel = new List<decimal>{
        0,
        1500,
        4500,
        9000,
        35000,
        55000,
        80000,
        decimal.MaxValue
    };

    private List<Type> _levels = new List<Type>();

    private void GetLevels() {
        _levels = AppDomain.CurrentDomain.GetAssemblies()
                           .SelectMany(tp => tp.GetTypes()
                           .Where(t => t.BaseType == typeof(Tax)))
                           .ToList();
    }

    public Context() {
        GetLevels();
    }

    public Context Calculate(decimal income) {
        _tax = new Level0();
        var result = income - EXEMPTION_VALUE;
        for(int i = 1; i <= _taxLevel.Count - 1; i++) {
            if(result > _taxLevel[i - 1] && result <= _taxLevel[i]) {
                _tax = (Tax)Activator.CreateInstance(_levels[i]);
            }
        }
        Console.WriteLine($"Income = {income}," + $"tax = {_tax.Calculate(result)}!");
        return this;
    }

}

Contexte de la classe d'environnement, il faut d'abord conserver une référence à la taxe, EXEMPTION_VALUE représente le montant de l'exonération (3 500 yuans sont utilisés dans cet exemple), puis sélectionner la classe de mise en œuvre de la taxe correspondante par réflexion et quelques techniques pour calculer l'échelle correspondante de l'impôt sur le revenu des personnes physiques.

public class Program {

    private static Context _context = new Context();

    public static void Main(string[] args) {
        _context.Calculate(2500.00m)
                .Calculate(4900.00m)
                .Calculate(5500.00m)
                .Calculate(7000.00m)
                .Calculate(10000.00m)
                .Calculate(16000.00m)
                .Calculate(43000.00m)
                .Calculate(70000.00m)
                .Calculate(100000.00m)
                .Calculate(4500.00m)
                .Calculate(1986.00m);

        Console.ReadKey();
    }

}

Ce qui précède est le code de l'appelant, Calculate est spécialement traité pour prendre en charge le chaînage de méthodes. Voici le résultat de ce cas :

Income = 2500.00,tax = 0.0000!
Income = 4900.00,tax = 42.0000!
Income = 5500.00,tax = 95.0000!
Income = 7000.00,tax = 245.0000!
Income = 10000.00,tax = 745.0000!
Income = 16000.00,tax = 2120.0000!
Income = 43000.00,tax = 9095.0000!
Income = 70000.00,tax = 17770.0000!
Income = 100000.00,tax = 29920.0000!
Income = 4500.00,tax = 30.0000!
Income = 1986.00,tax = 0.0000!

Avantages :

1. La structure hiérarchique de la classe de stratégie définit un algorithme ou une famille comportementale appropriée. l'utilisation de l'héritage peut déplacer le code commun dans la classe parent pour éviter le code en double ;
2. L'héritage peut gérer une variété d'algorithmes ou de comportements et éviter d'utiliser plusieurs instructions de transfert conditionnel.

Inconvénients :

1. Le client doit connaître toutes les classes de politique et décider laquelle utiliser
2 Le modèle de stratégie pose beaucoup de problèmes ; Classe de stratégie, provoquant une "explosion de sous-classe".

Scénarios d'utilisation :

1. S'il existe de nombreuses classes dans un système et que la seule différence entre elles est leur comportement, alors le modèle de stratégie peut être utilisé pour dynamiquement Laissez un objet choisir un comportement parmi plusieurs comportements ;
2. Un système doit choisir dynamiquement l'un de plusieurs algorithmes.

Articles associés :

Écrire une extension PHP en utilisant C/C++

[Tutoriel c#] Types de données C#

Vidéos associées :

Qu'est-ce que le didacticiel vidéo sur les modèles de conception avancés Design Pattern-php

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!