Comment refactoriser le code qui utilise Neth SISSES?

Je pense personnellement à ce que vous avez bien. Cependant, si vous ne l'aimez vraiment pas, vous pouvez jouer des méthodes locales, je suppose

bool Check(string val, params string[] list) => type == val && list.Contains(status);

// uglay, yet approachable
if (!checkStatus ||
    Check("A", "Complete") ||
    Check("B", "Complete", "Other status", "someother status"))
{
   UpdateData();
}

S'il est d'optimiser la possibilité d'ajouter une nouvelle une nouvelle, je l'aurais placé dans un tableau.

bool[] checks = new bool[]{
    (type == "A" && status == "Complete"),
    (type == "B" && (status == "Complete" || status == "Other status" || status == "someother status"))
}

if (!checkStatus || checks.Contains(false)) //'Contains' requires Linq, it also works with 'checks.Any(c => !c)'
{
    UpdateData();
}

Je suppose que le point principal de ce code consiste à assurer que la mise à jour fonctionne lorsque les conditions sont remplies, ce qui est effectué via des tests unitaires.

Donc, je regarderais comment je pourrais écrire ce code de manière testable afin Je peux être sûr que cela fait ce qu'il dit sur l'étain.

Un moyen de le faire pourrait être quelque chose comme ça: xxx

ceci commence Pour former en tant que moteur de règles et que vous pouvez avoir autant de règles que vous avez besoin

chacun si l'instruction peut maintenant appeler une méthode et chaque règle est séparée dans sa propre méthode qui peut maintenant être facilement testée correctement. < / P>

Vous pouvez mettre toutes les règles dans leur propre classe (ES), le moteur renvoie-t-il un statut et si cet état est vrai, puis exécutez la mise à jour. L'idée principale est de séparer le code de configuration, à partir de l'analyse d'état et du code qui exécute la mise à jour et fait ce qu'il faut faire.

Je préférerais faire quelque chose comme ça, de sorte que, lorsque de nouveaux cas apparaissent ou que des critères de validation changent, nous ne pouvons que trouver un nouveau cas blanche. Ceci est simple / maintenable, fonctionne bien pour une série de valides de valid_cases avec de petits changements.

using System;
using System.Collections.Generic;

public class Program
{
      class Case{
        string type;
        string status;
         public Case(string type_val, string status_val ){
              status = status_val;
             type = type_val;
         }

        public override int GetHashCode()  
        {  
            return type.GetHashCode()+status.GetHashCode();  
        }  
        public override bool Equals(object obj)  
        {  
            Case test = obj as Case;  
            if (test== null)  
                return false;  
            return type == test.type &&  status == test.status ;  
        } 

    }
    public static void Main()
    {
        bool checkStatus = true;
        HashSet<Case> vaild_cases = new HashSet<Case>();
        vaild_cases.Add(new Case("A","Complete"));
        vaild_cases.Add(new Case("B","Complete"));
        vaild_cases.Add(new Case("B","Other status"));
        vaild_cases.Add(new Case("B","someother status"));
        Case current_case = new Case("A","Complete");
        if (!checkStatus || vaild_cases.Contains(current_case))
            UpdateData();
    }

    static void UpdateData()
    {
        Console.WriteLine("Hello, World!");
        return;
    }
}  

Une autre option est la suivante:

if((new string[] {"Complete", "Other status", "someother status"}.Contains(status) && type == "B") ||
   (status == "Complete" && type == "A") ||
   !checkStatus)
{
    UpdateData();
}