Wie wenn sonst Serie

Question

Arbeit in C# bereinigen, wenn sonst Serie reduzieren wollen, Einheit haben zwei Eigenschaft FromServiceID und ToServiceID, nehme meine ServiceClass Instanz unten information.How unten Code aufzuräumen? Jede Art von Vorschlag wird akzeptiert.

entity= new ServiceClass(); 
entity.FromServiceID=3 
entity.ToServiceID=1 

if (entity.FromServiceID == 1) 
{ 
    entity.1KWithdrawal(); 
} 
else if (entity.FromServiceID == 2) 
{ 
    entity.10KWithdrawal(); 
} 
else if (entity.FromServiceID == 3) 
{ 
    entity.BTWithdrawal(); 
}   
if (entity.ToServiceID == 1) 
{ 
    entity.1KDeposit(); 
} 
else if (entity.ToServiceID == 2) 
{ 
    entity.10KDeposit(); 
} 
else if (entity.ToServiceID == 3) 
{ 
    entity.BTDeposit(); 
} 


public class ServiceClass 
{ 

    public int FromServiceID { get; set; } 
    public int ToServiceID { get; set; } 

    public void 1KWithdrawal() 
    { Console.WriteLine("One_KWithdrawal"); } 

    public void 10KWithdrawal() 
    { Console.WriteLine("Ten_KWithdrawal"); } 

    public void BTWithdrawal() 
    { Console.WriteLine("BTWithdrawal"); } 

    public void 1KDeposit() 
    { Console.WriteLine("One_KDeposit"); } 

    public void 10KDeposit() 
    { Console.WriteLine("Ten_KDeposit"); } 

    public void BTDeposit() 
    { Console.WriteLine("Ten_KDeposit"); } 
} 

Answer 1

Verwenden Sie eine Dictionary. Etwas wie folgt aus:

Dictionary<int, ServiceClass> dictionary = new Dictionary<int, ServiceClass>() 
{ 
    {1, new ServiceClass()}, 
    {2, new ServiceClass()}, 
    {3, new BTWithdrawal()},//assume BTWithdrawal inherits from ServiceClass 
}; 

Ein Beispiel, wie es mit:

ServiceClass value=new ServiceClass(); 
value.FromServiceId=1; 
value.ToServiceId = 2; 
dictionary.TryGetValue(value.FromServiceId, out value); 
//or dictionary.TryGetValue(value.ToServiceId, out value); 
if (value != null) MessageBox.Show(value.Id.ToString()); 

Answer 2

Sie Schaltergehäuse wie unten verwenden:

var entity = new ServiceClass(); 

entity.FromServiceID = 3; 
entity.ToServiceID = 1; 

switch(entity.FromServiceID) 
{ 
    case 1: 
     new 1KWithdrawal(); 
     break; 
    case 2: 
     new 10KWithdrawal(); 
     break; 
    case 3: 
     new BTWithdrawal(); 
     break; 
} 

switch(entity.ToServiceID) 
{ 
    case 1: 
     new 1KDeposit(); 
     break; 
    case 2: 
     new 10KDeposit(); 
     break; 
    case 3: 
     new BTDeposit(); 
     break; 
} 

Answer 3

Vielleicht ist dies ein viel des Guten, aber Sie können erstellen eine Klasse für jeden Ihrer Fälle, die von einer gemeinsamen Schnittstelle erbt (nennen wir sie ICommon), die eine gemeinsame Methode für jeden Fall aufzeigt (in Ihrem Fall eine Create-Methode) und dann diese Schnittstelle in den Konstrukt injiziert ctor von ServiceClass.

Wenn Sie dann ServiceClass verwenden möchten, müssen Sie eine tatsächliche Implementierung von ICommon (eine der Klassen, die Sie aus jedem Fall extrahierten) bereitstellen und schließlich müssen Sie nur entity.Create aufrufen.

Ich glaube, das ist das Strategie-Muster, das zusammenfassend besagt, dass Sie einen Algorithmus in einer anderen Klasse unter einer gemeinsamen Schnittstelle extrahieren sollten.

Schließlich wird dieses Refactoring die zyklotomische Komplexität Ihres Codes reduzieren (das bedeutet hauptsächlich, dass Sie die Verzweigung auf Ihrem Code reduzieren), was immer eine gute Sache ist.

Answer 4

Was Sie tun könnten, ist, alle Variationen in eine enum zu setzen und die enum-Werte genau wie Ihre Methoden, die Sie anrufen möchten, aufzurufen. (Ich würde vorschlagen, keine Zahlen zu verwenden, in dem Namen, da die Compiler es nicht zulassen)

Aus Gründen der Einfachheit und Testbarkeit Ich legte den ENUM und die Methoden in die gleiche Klasse:

public class ServiceClass 
{ 
    public enum ServiceID 
    { 
     OneKWithdrawal, 
     Ten_KWithdrawal, 
     BTWithdrawal, 
     OneKDeposit, 
     Ten_KDeposit, 
     BTDeposit 
    } 
    public ServiceID From_Ser_ID { get; set; } 
    public ServiceID To_Ser_ID { get; set; } 

    public void One_KWithdrawal() 
    { Console.WriteLine("One_KWithdrawal"); } 

    public void Ten_KWithdrawal() 
    { Console.WriteLine("Ten_KWithdrawal"); } 

    public void BTWithdrawal() 
    { Console.WriteLine("BTWithdrawal"); } 

    public void One_KDeposit() 
    { Console.WriteLine("One_KDeposit"); } 

    public void Ten_KDeposit() 
    { Console.WriteLine("Ten_KDeposit"); } 
} 

Dies wäre die Methode, die Ihre if-condition-Methoden ausführen würde. Es verwendet Reflektion, um auf die Methoden zuzugreifen, die in der Enumeration codiert sind. Sie müssen wahrscheinlich den Parameter object im Aufruf abhängig davon, wo sich Ihre Methoden befinden, anpassen. Wenn sie in der gleichen Klasse sind, in der Sie execute anrufen, können Sie this verwenden.

public static void execute(ServiceClass sc) 
{ 
    sc.GetType().GetMethod(sc.From_Ser_ID.ToString()).Invoke(sc, null); 
    sc.GetType().GetMethod(sc.To_Ser_ID.ToString()).Invoke(sc, null); 
} 

Und hier können Sie den gesamten Code testen:

public static void Main(string[] args) 
{ 

    ServiceClass entity = new ServiceClass(); 
    entity.From_Ser_ID = ServiceClass.ServiceID.BTWithdrawal; 
    entity.To_Ser_ID = ServiceClass.ServiceID.Ten_KDeposit; 

    execute(entity); 
} 

So würden Sie mit einem Enum und 2 Codezeilen enden.