validar - cómo anular el conjunto en C#de propiedades automáticas

propiedades virtuales c#

Question

Quiero usar propiedades implementadas automáticamente, pero al mismo tiempo quiero llamar a un método cada vez que se cambia la propiedad.

public float inverseMass
{
    get;
    set
    {
        onMassChanged();
        inverseMass = value;
    }
}

¿El código anterior hace una llamada recursiva a la propiedad? Si lo hace, ¿cómo implementar esto?

Answer 1

Eso no se compila, por lo que es difícil decir si es recursivo o no.

No puede especificar solo una parte de una propiedad automática. Necesitará usar un campo de respaldo en este caso:

private float _inverseMass;
public float inverseMass 
{ 
    get { return _inverseMass; }
    set 
    { 
        onMassChanged(); 
        _inverseMass = value; 
    } 
}

Sin embargo, un marco de programación orientado a aspectos como PostSharp puede ayudarlo con esto.

Answer 2

Las respuestas correctas se dieron anteriormente, pero en caso de que quisiera hacer esto rápidamente en Visual Studio, puede usar Fragmentos de código en lugar de generar la propiedad para usted.

Lea este artículo, que debería explicarlo un poco mejor: http://www.roelvanlisdonk.nl/?p=1007

Si lo desea, incluso puede crear su propio fragmento de código para agregar el código repetitivo. Incluso podría usarlo para generar rápidamente la implementación INotifyPropertyChanged como se mencionó anteriormente.

Answer 3

No puedes hacer eso en C #.

Es una propiedad automática o propiedad con campo de respaldo.

Answer 4

Si proporciona su propio get / set, necesita proporcionar su propio almacenamiento para la variable.

private float _inverseMass;

public float inverseMass
{
    get { return _inverseMass; }
    set
    {
        _inverseMass = value;
        onMassChanged();
    }
}

Answer 5

Tendría que dividir lo anterior en miembros privados / públicos para no tener problemas recursivos:

private float _inverseMass;
public float inverseMass
{
  get { return this._inverseMass; }
  set { this._inverseMass = value; onMassChanged(); }
}

Sin embargo, ¿ha buscado en la interfaz INotifyPropertyChanged ? Hace prácticamente todo lo que está buscando y, dependiendo de lo que escriba, se podría admitir de forma nativa.

public class MyClass : INotifyPropertyChanged
{
  public event PropertyChangedEventHandler PropertyChanged;
  private void NotifyPropertyChanged(String property)
  {
    var event = this.PropertyChanged;
    if (event != null)
    {
      event(this, new PropertyChangedEventArgs(property));
    }
  }

  private float _inverseMass;
  public float inverseMass
  {
    get { return this._inverseMass; }
    set { this._inverseMass = value; NotifyPropertyChanged("inverseMass"); }
  }
}

Answer 6

Use una variable privada como su campo de respaldo para la propiedad pública.

private float inverseMass;

public float InverseMass{

   set
   {
        onMassChanged();
        inverseMass=value;
   }
   get
   {
      return inverseMass;
   }

}

Answer 7

Utilice un campo de respaldo en su lugar:

public float inverseMass
{
    get
    {
        return _inverseMass;
    }
    set
    {
        onMassChanged();
        _inverseMass = value;
    }
}

private float _inverseMass;

Una vez leí en alguna parte que los chicos de C # decidieron que querían cubrir la amplia gama de escenarios de uso con esas propiedades automáticas, pero para casos especiales, hay que volver a los campos de respaldo antiguos.

(Para ser honesto, creo que Jon Skeet les dijo cómo implementarlos)

Answer 8

public float inverseMass
{
    get;
    set
    {
        if (inverseMass != value)
        {
            inverseMass = value;
            onMassChanged();
        }
    }
}