1 Property binden aan meerderen

[HelpElec]

Beste allemaal,

Ik heb een UserControl die een Sensor voor moet stellen. Deze heeft een Property Detected.

 public Boolean Detected
        {
            set
            {
                Dtct = value;
            }
            get
            {
                return Dtct;
            }
        }

Ik heb nog een ander component Test die "verbonden" kan worden met 5 van die Sensoren. In Runtime kan de user tot 5 sensoren kiezen voor een Test. Deze sensoren bewaart Test in een List<Sensor>.

private List<Sensor> LstUsedSens = new List<Sensor>();

Nu ben ik op zoek naar de beste methode voor Test om te controleren of (een van) zijn sensoren iets detecteren.

Ik wilde dit eerst met DataBinding doen, maar hoe maak ik voor Test een property die met 5 sensoren verbonden kan zijn?
Ik kan wel pollen met een Timer, maar het lijkt me dat dat niet de beste methode.
Kan ik met een event controleren of de property van een object in een List een nieuwe waarde heeft?
Of moet ik helemaal geen List gebruiken?

Bedankt!

 

[Bloodshed]

Het idee met databinding is juist dat deze dingen automatisch gebeuren door middel van het implementeren van de INotifyPropertyChanged interface.

Je Sensor class implementeert deze dus, en dan als er een property zoals detected wordt 'geset' zal de UI ook wijzigen.

In plaats van List<T> kun je een ObservableCollection<T> gebruiken. Deze is speciaal voor databinding en zal de events triggeren bij het wijzigen van de lijst.


klein voorbeeld:

public class Sensor : INotifyPropertyChanged
{
	private bool _detected;

	public Sensor()
	{
		_detected = false;
	}

	public bool Detected
	{
		get { return _detected; }
		set
		{
			_detected = value;
			OnPropertyChanged("Detected");
		}
	}

	public event PropertyChangedEventHandler PropertyChanged;

	protected virtual void OnPropertyChanged(string propertyName)
	{
		var handler = PropertyChanged;
		if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
	}
}

public class Test
{
	public Test()
	{
		Sensors = new ObservableCollection<Sensor>();
	}

	public ObservableCollection<Sensor> Sensors { get; set; }
}

Ik hoop dat ik het goed begrepen heb en dit is wat je in gedachte had.

 

[HelpElec]

Okay bedankt Bloodshed!

Heb een PropertyChangedEventHandler aan Test toegevoegd, die aan alle gekozen Sensoren worden toegevoegd, zodat Test kan handelen op het OnPropertyChanged event van z'n sensoren.

    Sensors.Add(Gekozen);
    Gekozen.PropertyChanged +=new PropertyChangedEventHandler(Sensoren_PropertyChanged);

Vraag nog: Waarom zou ik een ObservableCollection gebruiken ipv een List? Bij beide roept hij de PropertyChangedEventHandler aan. Een List accepteert toch ook wijzigingen aan zijn items?

Groeten

 

[Bloodshed]

Oh, je wilt in de test class iets doen. Met databinding ging ik er vanuit dat het om de UI ging.

Dit werkt wel maar misschien niet optimaal voor wat je wilt doen omdat bij elke property wijziging het event triggered (als je dat bij elk property in de sensor class hebt gezet). Dus ook als je het ID of de Name wijzigt (of wat voor properties er nog meer zijn). Je kunt in iedergeval wel een if(e.PropertyName == "xxxx") gebruiken in de event method zodat je alleen iets doet bij een bepaald property.


Voor de wijzigingen in de sensors je die toevoegt kun je een List<T> of een ObservableCollection<T> gebruiken, dit maakt dan niet uit. Maar (er van uitgaande dat het om de UI ging) een ObservableCollection stuurt de propertychanged events van de list zelf ook heen en weer zoals bij add, remove, move, insert. Dan hoef je de lijst in de UI niet te verversen.

 

[HelpElec]

Okay bedankt!

Slechte uitleg van mij dan.
Voor deze situatie is dit prima, alleen het Detect-event is van belang.

Groeten!

 

[Bloodshed]

Ok, prima.

Misschien dat je dan wel een eigen event wilt maken zodat je niet een property name hoeft te gebruiken. Is het in de code ook duidelijker wat er gebeurt. (eventueel nog eigen eventargs gebruiken)

public class Sensor
{
	private bool _detected;

	public Sensor(string name)
	{
		Name = name;
		_detected = false;
	}

	public string Name { get; set; }
	public bool Detected
	{
		get { return _detected; }
		set
		{
			_detected = value;
			OnDetectionChanged();
		}
	}

	public event EventHandler DetectionChanged;

	protected virtual void OnDetectionChanged()
	{
		var handler = DetectionChanged;
		if (handler != null) handler(this, EventArgs.Empty);
	}
}

public class Test
{
	public Test()
	{
		Sensors = new List<Sensor>();
	}

	public List<Sensor> Sensors { get; set; }

	private void Add()
	{
		var sensorA = new Sensor("Sensor A");
		sensorA.DetectionChanged += DetectionChanged;

		Sensors.Add(sensorA);
	}

	private void DetectionChanged(object sender, EventArgs e)
	{
		var sensor = (Sensor)sender;
		Debug.WriteLine("{0} had it's detection state changed to {0}", sensor.Name, sensor.Detected);
	}
}