C# Equivalente para Macros en C++ y usando Auto <> Propiedades

Question

Tengo un código de auto-instanciación que me gustaría aplicar a unas 15 propiedades en una clase bastante grande. El código es similar a la siguiente, pero el tipo es diferente para cada instancia:

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

     return _propertyName; 
    } 
} 

Para repetir esto en C++ (ya que hay ~ 15 casos), habría utilizado un preprocesador macro pero note que C# no los admite.

Me pregunto si alguien tiene una recomendación sobre cómo hacer esto limpiamente en C#?

Answer 1

Esto podría hacer las cosas un poco más ordenado, se podría añadir este método para introducir un poco de reutilización:

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

A pesar de que no resuelve directamente el problema, se puede echar un vistazo a la nueva clase Lazy<T> que se envía con .NET 4.0. Está diseñado específicamente para escenarios de inicialización perezosa.

Answer 3

Usted puede utilizar el operador ?? para simplificar el código en una línea:

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

Como nota al margen que probablemente evitar los campos protegidos. Si necesita establecer la propiedad de una clase derivada, preferiría crear un setter protegido.

Answer 4

se puede hacer una estructura genérica que se encarga de la creación perezosa:

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

podría utilizar el muy pasado por alto T4 (plantillas de texto Transformation Toolkit) para generar el código. Se incluye con Visual Studio 2008.

Hubo un episodio Rocas 2009-06 .NET al respecto: "Peter Vogel uses Code Generation".

Answer 6

Intente utilizar Hashtable o Diccionario < cadena, ComplexType > para agrupar todas las propiedades. Algo como esto:

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

Se podría aplicar la inicialización perezosa de una manera similar a esto:

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(); 
     } 
    } 

que permitirá escribir código como este:

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

Los detalles de la inicialización es irrelevante, lo escribí así para mostrar que puede convertirlo en convertible transparente a la versión no perezosa y realizar la inicialización en la primera conversión. :)