Ekwiwalent C# dla makr C++ i użycie Auto <> Właściwości

Question

Mam pewien kod automatycznej instancji, który chciałbym zastosować do około 15 właściwości w dość dużej klasie. Kod jest podobny do następującego ale typ różni dla każdego wystąpienia:

protected ComplexType _propertyName; 
public ComplexType PropertyName 
{ 
    get 
    { 
     if (_propertyName == null) { 
      _propertyName = new ComplexType(); 
     } 

     return _propertyName; 
    } 
} 

powtórzyć tę C++ (jak jest ~ 15 przypadki), to, że nie używane preprocesor makro ale I powiadomienie C# nie obsługuje ich.

Zastanawiam się, czy ktoś ma zalecenie, jak to zrobić w sposób czysty w C#?

Answer 1

Może to zrobić rzeczy trochę neater można dodać tej metody, aby wprowadzić pewne ponownego użycia:

protected ComplexType _propertyName; 
public ComplexType PropertyName 
{ 
    get 
    { 
     return GetProperty(ref _propertyName); 
    } 
} 
. 
. 
private T GetProperty<T>(ref T property) where T : new() 
{ 
    if (property == null) 
    property = new T(); 
    return property; 
} 

Answer 2

Nawet jeśli bezpośrednio nie rozwiąże problemu, można przyjrzeć się nowej klasy Lazy<T> który jest dostarczany z .NET 4.0. Jest specjalnie zaprojektowany do leniwych scenariuszy inicjalizacji.

Answer 3

Można użyć operatora ?? uproszczenie kodu w jednej linii:

protected ComplexType _propertyName; 
public ComplexType PropertyName 
{ 
    get 
    { 
    return _propertyName ?? (_propertyName = new ComplexType()); 
    } 
} 

marginesie pewnie bym uniknąć pól chronionych. Jeśli musisz ustawić właściwość z klasy pochodnej, wolałabym utworzyć chronionego ustawiacza.

Answer 4

Można zrobić rodzajowe struct, który obsługuje leniwy utworzenia:

public struct LazyCreate<T> where T : class, new() { 
    private T _value; 
    public T Value { 
     get { 
     if (_value == null) { 
      _value = new T(); 
     } 
     return _value; 
     } 
    } 
} 

protected LazyCreate<ComplexType> _propertyName; 
public ComplexType PropertyName { 
    get { 
     return _propertyName.Value; 
    } 
} 

Answer 5

można użyć znacznie pomijane T4 (szablon tekst Transformation Toolkit) do generowania kodu. Jest ono zawarte z Visual Studio 2008.

Było 2009-06 .NET Rocks epizod o tym: "Peter Vogel uses Code Generation".

Answer 6

spróbuje użyć Hashtable lub słownika korzystał < ciąg, complexType > do grupy wszystkie właściwości. Coś takiego:

protected Dictionaty<string, ComplexType> _properties = new Dictionaty<string, ComplexType>(); 
public ComplexType Property(string name) 
{ 
    get 
    { 
     if (!properties.ContainsKey(name)) 
      _properties[name] = new ComplexType(); 

     return __properties[name]; 
    } 
} 

Answer 7

Można wdrożyć leniwe inicjowanie w sposób podobny do tego:

public class Lazy<T> where T : new() 
    { 
     private T _value; 
     private bool _isInitialized; 

     private T GetValue() 
     { 
      if (!_isInitialized) 
      { 
       _value = new T(); 
       _isInitialized = true; 
      } 

      return _value; 
     } 

     public static implicit operator T (Lazy<T> t) 
     { 
      return t.GetValue(); 
     } 
    } 

które pozwalają pisać kod tak:

 private Lazy<ComplexType> _lazyCt = new Lazy<ComplexType>(); 
     public ComplexType LazyCt 
     { 
      get { return _lazyCt; } 
     } 

Specyfika Inicjalizacja jest nieistotna, napisałem to tak, aby pokazać, że można ją przekształcić w przejrzysty sposób w niezaplanowaną wersję i przeprowadzić inicjalizację przy pierwszej konwersji. :)