Jak mogę użyć wielu konstruktorów do usunięcia zduplikowanego kodu przy zachowaniu czytelności?

Question

int a, b, c; 

Constructor() 
{ 
    a = 5; 
    b = 10; 
    c = 15; 
    //do stuff 
} 
Constructor(int x, int y) 
{ 
    a = x; 
    b = y; 
    c = 15; 
    //do stuff 
} 
Constructor(int x, int y, int z) 
{ 
    a = x; 
    b = y; 
    c = z; 
    //do stuff 
} 

Aby uniknąć powielania „rzeczy” i kilka zadań, starałem się coś takiego:

int a, b, c; 

Constructor(): this(5, 10, 15) 
{ 
} 
Constructor(int x, int y): this(x, y, 15) 
{ 
} 
Constructor(int x, int y, int z) 
{ 
    a = x; 
    b = y; 
    c = z; 
    //do stuff 
} 

Działa to na to, co chcę zrobić, ale czasami trzeba użyć trochę długi kod, aby utworzyć nowych obiektów lub zrobić kilka obliczeń:

int a, b, c; 

Constructor(): this(new Something(new AnotherThing(param1, param2, param3), 
    10, 15).CollectionOfStuff.Count, new SomethingElse("some string", "another 
    string").GetValue(), (int)Math.Floor(533/39.384)) 
{ 
} 
Constructor(int x, int y): this(x, y, (int)Math.Floor(533/39.384)) 
{ 
} 
Constructor(int x, int y, int z) 
{ 
    a = x; 
    b = y; 
    c = z; 
    //do stuff 
} 

Ten kod jest prawie taka sama jak poprzednio, tylko te parametry, które są przekazywane nie są bardzo czytelne. Wolałbym coś takiego:

int a, b, c; 

Constructor(): this(x, y, z) //compile error, variables do not exist in context 
{ 
    AnotherThing at = new AnotherThing(param1, param2, param3); 
    Something st = new Something(aThing, 10, 15) 
    SomethingElse ste = new SomethingElse("some string", "another string"); 

    int x = thing.CollectionOfStuff.Count; 
    int y = ste.GetValue(); 
    int z = (int)Math.Floor(533/39.384); 

    //In Java, I think you can call this(x, y, z) at this point. 
    this(x, y, z); //compile error, method name expected 
} 
Constructor(int x, int y): this(x, y, z) //compile error 
{ 
    int z = (int)Math.Floor(533/39.384); 
} 
Constructor(int x, int y, int z) 
{ 
    a = x; 
    b = y; 
    c = z; 
    //do stuff 
} 

Zasadniczo buduję parametry w ciele konstruktora. Następnie próbuję przekazać te parametry do innego konstruktora. Myślę, że pamiętam możliwość użycia słów kluczowych "to" i "super" do wywoływania konstruktorów, gdy znajdują się w ciele innego konstruktora podczas kodowania w Javie. To nie wydaje się możliwe w C#.

Czy można to łatwo zrobić? Czy zrobiłem coś niepoprawnie? Jeśli nie jest to możliwe, czy powinienem trzymać się nieczytelnego kodu?

Chyba zawsze mogłem odciąć zduplikowany kod na inną metodę całkowicie poza konstruktorami. Następnie każdy konstruktor po prostu wykona swoją własność i wywoła kod współdzielony przez innych konstruktorów.

Answer 1

Jako alternatywę do wywoływania metody inicjalizacji ze wszystkich konstruktorów (co uniemożliwia korzystanie z readonly pól) lub metod fabrycznych (które wprowadzają dodatkowe złożoności, gdy masz pochodzący klasach), można użyć parameter object:

int a, b, c; 

public Constructor() 
    : this(new ConstructorParameters()) 
{ 
} 

public Constructor(int x, int y) 
    : this(new ConstructorParameters(x, y)) 
{ 
} 

public Constructor(int x, int y, int z) 
{ 
    a = x; 
    b = y; 
    c = z; 
    //do stuff 
} 

private Constructor(ConstructorParameters parameters) 
    : this(parameters.X, parameters.Y, parameters.Z) 
{ 
} 

private class ConstructorParameters 
{ 
    public int X; 
    public int Y; 
    public int Z; 

    public ConstructorParameters() 
    { 
     AnotherThing at = new AnotherThing(param1, param2, param3); 
     Something st = new Something(at, 10, 15) 
     SomethingElse ste = new SomethingElse("some string", "another string"); 

     X = st.CollectionOfStuff.Count; 
     Y = ste.GetValue(); 
     Z = (int)Math.Floor(533/39.384); 
    } 

    public ConstructorParameters(int x, int y) 
    { 
     X = x; 
     Y = y; 
     Z = (int)Math.Floor(533/39.384); 
    } 
} 

Answer 2

Można zrobić

Constructor() : this(5, 10, 15) 
{ 
} 
Constructor(int x, int y) : this(x, y, 15) 
{ 
} 
Constructor(int x, int y, int z) 
{ 
    int a = x; 
    int b = y; 
    int c = z; 
    //do stuff 
} 

Jednak jeśli trzeba zrobić wymyślnej logiki w zależności od parametrów, chciałbym użyć factory pattern:

public class myclass 
{ 
    private myclass(int x, int y, int z) 
    { 
    int a = x; 
    int b = y; 
    int c = z; 
    //do stuff 
    } 
    public static myclass Create() 
    { 
    AnotherThing at = new AnotherThing(param1, param2, param3); 
    Something st = new Something(aThing, 10, 15) 
    SomethingElse ste = new SomethingElse("some string", "another string"); 

    int x = thing.CollectionOfStuff.Count; 
    int y = ste.GetValue(); 
    int z = (int)Math.Floor(533/39.384); 

    return new myclass(x, y ,z); 
    } 
    public static myclass Create(int x, int y) 
    { 
    if (x = 1) 
     return new myclass(x, y, 2) 
    else 
     return new myclass(x, y, 15); 
    } 
    public static myclass Create(int x, int y, int z) 
    { 
    //so on and so forth 
    return new myclass(x, y, z); 
    } 
} 

Chociaż NIE potrzebę się wzór fabryczny, zdecydowanie sprawia, że ​​logika konstruktora jest czytelna.