Konstruktor łańcuchowy przekazujący obliczone wartości dla parametrów

Question

Jak przejść z jednego instancji do innego? Przypuśćmy, że mamy tę klasę. Jak przejść z foo (string, string) do foo (Uri)?

public foo 
{ 
    string path { get; private set; } 
    string query { get; private set; } 

    public foo (Uri someUrl) 
    { 
     // ... do stuff here 
    } 

    public foo (string path, string query) 
    { 
     Uri someUrl = new Uri(String.Concat(path, query); 

     // ... do stuff here to pass thru to foo(someUrl) 
    } 
} 

Answer 1

można też zrobić coś takiego:

class Frob 
{ 
    public Frob (Uri uri) 
    { 

    } 

    public Frob(string path, string query) 
     : this(TidyUpUri(path, query)) 
    { 

    } 

    private static Uri TidyUpUri(string path, string query) 
    { 
     var uri = new Uri(string.Concat(path, query)); 

     // etc. 

     return uri; 
    } 
} 

Answer 2

Do prostego konstruktora łańcuchowych, można użyć specjalnych słów kluczowych this lub base się odnosić do innych konstruktorów bieżącego lub dominującej za klasę. Możesz używać parametrów konstruktora wykonawczego jako parametrów do powiązanego konstruktora i możesz łączyć je przy użyciu dowolnego pojedynczego wyrażenia zgodnego z . Jest to zasadniczo ta sama reguła, która ma zastosowanie do każdego innego wyrażenia wbudowanego dostarczanego do wywołania funkcji, z tym że powinieneś unikać używania jakichkolwiek elementów klasy (ponieważ nie została ona jeszcze zbudowana) i ograniczyć się do stałych i parametrów przekazujących:

public foo (Uri someUrl) 
{ 
    this.url = someUrl; 
} 

public foo (string path, string query) 
    : this(new Uri(String.Concat(path, query))) 
{ 
    // this.url is now set and available. 
} 

To będzie działać tak długo, jak przetwarzania, które trzeba zrobić, można zrobić w jednym wyrażeniu wartości. Jeśli potrzebujesz, na przykład, zrobienia czegoś innego z Uri, zanim zostanie ona wysłana do innego konstruktora, lub jeśli potrzebujesz skomplikowanej logiki, nie będziesz w stanie uciec z tą techniką. Alternatywą jest byłaby kodu do metody inicjalizacji:

public foo (Uri someUrl) 
{ 
    this.init(someUrl); 
} 

public foo (string path, string query) 
{ 
    var url = String.Concat(path, query); 
    url = url.Replace("http://", "https://"); 

    this.init(url); 
} 

private void init (Uri someUrl) 
{ 
    this.url = someUrl; 
} 

Answer 3

Skoro przetwarzanie swoich strun przed przekazaniem ich razem, można wyodrębnić Do wspólna metoda. Na przykład

private void ProcessUri(ref Uri theUri) 
{ 
    //...do your URI stuff here 
} 

public foo (Uri someUrl) 
{ 
    ProcessUri(ref someUrl); 
} 

public foo (string path, string query) 
{ 
    Uri someUrl = new Uri(String.Concat(path, query)); 

    // ... do stuff here to pass then call ProcessUri 
    ProcessUri(ref someUrl); 
} 

Zaletą rzeczy mijających się z ref jest to, że można ustawić wartości readonly właściwości tak jak byś jeśli zmienna została ustawiona w konstruktorze.