Actualmente estoy creando una aplicación en C# con Visual Studio. Quiero crear algo de código para que cuando una variable tiene un valor de 1, a continuación, una determinada pieza de código se lleva a cabo.
Sé que se puede utilizar una instrucción if, pero el problema es que el valor va a ser cambiado en un proceso asincrónico así que, técnicamente, la declaración de si se podría pasar por alto antes de que el valor ha cambiado.

Es posible crear un controlador de eventos para que cuando el valor de la variable cambios se desencadena un evento? Si es así, ¿cómo puedo hacer esto?

Es completamente posible que yo pudiera haber mal entendido cómo una declaración de si funciona! Cualquier ayuda sería muy apreciada.

  • Para ser claros, la observación de una variable de cambio sólo es posible para una variable (o que ya está IObservable/INotifyPropertyChanged/relacionados con el Evento). No se puede observar un sistema variable de cambio si no fue diseñado para ser observado.
InformationsquelleAutor James Mundy | 2011-04-30

4 Comentarios

  1. 110

    Me parece que usted desea crear una propiedad.

    public int MyProperty
    {
        get { return _myProperty; }
        set
        {
            _myProperty = value;
            if (_myProperty == 1)
            {
                //DO SOMETHING HERE
            }
        }
    }
    
    private int _myProperty;

    Esto le permite ejecutar código en cualquier momento el valor de la propiedad de los cambios. Usted podría subir en un evento aquí, si quería.

  2. 58

    Puede utilizar un establecedor de la propiedad para generar un evento cuando el valor de un campo va a cambiar.

    Usted puede tener su propio delegado EventHandler o usted puede utilizar el famoso Sistema.Delegado EventHandler.

    Generalmente hay un patrón para esto:

    1. Definir un evento público con un delegado del controlador de eventos (que tiene un argumento de tipo EventArgs).
    2. Definir un virtual protegido método llamado OnXXXXX (OnMyPropertyValueChanged por ejemplo). En este método, usted debe comprobar si el controlador de eventos delegado es nulo y si no se le puede llamar (lo que significa que hay uno o más métodos adjunta para el caso de la delegación).
    3. Llamar a este método protegido siempre que usted desee notificar a los suscriptores de que algo ha cambiado.

    He aquí un ejemplo

    private int _age;
    
    //#1
    public event System.EventHandler AgeChanged;
    
    //#2
    protected virtual void OnAgeChanged()
    { 
         if (AgeChanged != null) AgeChanged(this,EventArgs.Empty); 
    }
    
    public int Age
    {
        get
        {
             return _age;
        }
    
        set
        {
             //#3
             _age=value;
             OnAgeChanged();
        }
     }

    La ventaja de este enfoque es que usted deje cualquier otra clase que desea heredar de su clase para cambiar el comportamiento, si es necesario.

    Si quieres coger un evento en un subproceso diferente que ser planteado debe tener cuidado de no cambiar el estado de los objetos que se definen en otro hilo que provocará una cruz hilo de excepción. Para evitar esto se puede utilizar un método de invocación en el objeto que desea cambiar su estado para asegurarse de que el cambio está sucediendo en el mismo hilo que el evento ha sido planteadas o en caso de que usted está tratando con un Formulario Windows forms puede utilizar un BackgourndWorker a hacer las cosas en un hilo paralelo agradable y fácil.

    • Una de las mejores explicaciones de toda la Web. Creo que por fin estoy entendiendo Personalizado de Manejo de Eventos. Agradecido por este post.
  3. 43

    El .NET framework proporciona una interfaz que se puede utilizar para notificar a los suscriptores cuando la propiedad ha cambiado: en el Sistema.ComponentModel.INotifyPropertyChanged. Esta interfaz tiene un evento PropertyChanged. Su utiliza generalmente en WPF para la unión, pero he encontrado que es útil en el negocio de las capas como una manera de estandarizar la notificación de cambio de propiedad.

    En términos de la seguridad de los subprocesos yo pondría un bloqueo bajo en la incubadora para que no se ejecute en cualquier condiciones de carrera.

    Aquí están mis pensamientos en el código 🙂 :

    public class MyClass : INotifyPropertyChanged
    {
        private object _lock;
    
        public int MyProperty
        {
            get
            {
                return _myProperty;
            }
            set
            {
                lock(_lock)
                {
                    //The property changed event will get fired whenever
                    //the value changes. The subscriber will do work if the value is
                    //1. This way you can keep your business logic outside of the setter
                    if(value != _myProperty)
                    {
                        _myProperty = value;
                        NotifyPropertyChanged("MyProperty");
                    }
                }
            }
        }
    
        private NotifyPropertyChanged(string propertyName)
        {
            //Raise PropertyChanged event
        }
        public event PropertyChangedEventHandler PropertyChanged;
    }
    
    
    public class MySubscriber
    {
        private MyClass _myClass;        
    
        void PropertyChangedInMyClass(object sender, PropertyChangedEventArgs e)
        {
            switch(e.PropertyName)
            {
                case "MyProperty":
                    DoWorkOnMyProperty(_myClass.MyProperty);
                    break;
            }
        }
    
        void DoWorkOnMyProperty(int newValue)
        {
            if(newValue == 1)
            {
                 //DO WORK HERE
            }
        }
    }

    Espero que esto sea de ayuda 🙂

    • +1 para la inclusión de la cerradura que las otras respuestas omitir.
    • ¿Cuál es el uso del objeto _lock ?
    • evita cambiar el valor de la propiedad, mientras que el caso está siendo procesado.
    • En mi humilde opinión, este es un lugar extraño para un bloqueo. [A menos que el bloqueo es también utilizado en otros lugares, que es una situación diferente.] Si dos hilos diferentes se encuentran en una condición de carrera para establecer una propiedad compartida, entonces el «final» del estado de la propiedad no es determinista. En lugar de utilizar algún patrón en el que un hilo es «dueño» de la propiedad, y sólo se la puso. QUE el patrón depende de la situación. (Si realmente necesita para cambiar la titularidad entre los hilos, pasar un bastón de mando/token.) Si me encontré con una necesidad de un bloqueo de aquí, me gustaría examinar cuidadosamente el diseño en general. OTOH, un bloqueo de aquí es inofensivo.
  4. 9

    sólo tiene que utilizar una propiedad

    int  _theVariable;
    public int TheVariable{
      get{return _theVariable;}
      set{
        _theVariable = value; 
        if ( _theVariable == 1){
          //Do stuff here.
        }
      }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here