Comment savoir si l'utilisateur a modifié les données à l'aide de bindingsource?

Si votre objet dans la Liste de soutien de la INotifyPropertyChanged événement et que vous remplacez le List<T> par un BindingList<T> vous pouvez vous abonner à la ListChanged cas de la BindingList d'être informés des éventuelles modifications apportées par l'utilisateur.

Si vous êtes lié à un ensemble de données, alors vous avez de la chance: il a un HasChanges de la Propriété. Vous pouvez obtenir les changements réels en appelant GetChanges sur le jeu de données. Cela renvoie d'un nouveau jeu de données, contenant une copie de toutes les lignes modifiées

- Je configurer un assez simple mécanisme, comme suit:

1. Après la liaison mes contrôles, je exécuter une méthode qui trouve toutes les lie
   contrôle et enregistre leurs valeurs actuelles (je fais un ReadValue() juste pour
   assurez-vous que j'ai les valeurs de la source de données) dans un Dictionnaire
   que des cartes de contrôle à sa valeur (il y a une petite méthode qui est
   la valeur appropriée pour chaque type de contrôle que j'ai).
2. J'ai aussi ajouter un changement de gestionnaire d'événement pour chacun (encore une fois, les
   l'événement est déterminé par le type de contrôle, mais ils ont tous le point de
   le gestionnaire de même)
3. Le changement de gestionnaire vérifie la valeur actuelle contre la Dictionnaire
   de la valeur. Si c'est différent, alors il agit en conséquence (dans mon cas, c'
   les commutateurs de la Près bouton pour le Annuler bouton). Si c'est la même
   il vérifie tous les autres contrôles liés, de sorte que, si rien n'est
   différentes, il peut passer de Annuler retour à Près; c'est une caractéristique intéressante de
   cette méthode, il reconnaît également que lorsqu'une modification a été annulée,
   même si c'est en entrant à nouveau la valeur d'origine.
4. Avant de partir, si il y a des changements pour être sauvé, je boucle à travers le
   les contrôles liés encore à faire WriteValue(), juste au cas où WinForms n'a pas
   obtenir autour de la propagation de certains changements.

Je peux partager la source si quelqu'un est intéressé.

Après avoir essayé autre chose j'ai fini avec ce morceau de code:

private MyClass currentItem = null;
private bool itemDirty = false; //can be used for "do you want to save?"

private void bindingSource_CurrentChanged(object sender, EventArgs e)
{
    var handler = new PropertyChangedEventHandler((s, e2) => itemDirty = true);

    var crnt = currentItem as INotifyPropertyChanged;
    if(crnt != null) crnt.PropertyChanged -= handler;

    currentItem = (MyClass)bindingSource.Current;

    crnt = currentItem as INotifyPropertyChanged;
    if(crnt != null) crnt.PropertyChanged += handler;

    itemDirty = false;
}

Il fonctionne très bien pour moi, même si je économiser beaucoup d'informations d'état dans le Formulaire Windows de champs d'instance. Cependant, en se tournant avec CurrentChanged et CurrentItemChanged ne m'aide pas.

Ce que je fais toujours, c'est de capturer l'individu "changé" les événements des contrôles. Dans l'exemple ci-dessous j'ai utilisé un tabcontrol dans cet exemple. Le Try/Catch est une solution sale pour ne pas avoir à traiter avec toutes sortes d'exceptions 😉

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
    '
    ' some code        
    '
    BindingNavigatorSaveItem.Enabled = False
    For Each tabctl As Control In Me.TabControl1.Controls
        For Each ctl As Control In tabctl.Controls
            Try
                If ctl.GetType Is GetType(TextBox) Then
                    AddHandler DirectCast(ctl, TextBox).TextChanged, AddressOf GenDataChanged
                ElseIf ctl.GetType Is GetType(NumericUpDown) Then
                    AddHandler DirectCast(ctl, NumericUpDown).ValueChanged, AddressOf GenDataChanged
                ElseIf ctl.GetType Is GetType(ComboBox) Then
                    AddHandler DirectCast(ctl, ComboBox).SelectedValueChanged, AddressOf GenDataChanged
                ElseIf ctl.GetType Is GetType(CheckBox) Then
                    AddHandler DirectCast(ctl, CheckBox).CheckStateChanged, AddressOf GenDataChanged
                End If
            Catch ex As Exception
            End Try
        Next
    Next
End Sub

Private Sub GenDataChanged(sender As System.Object, e As System.EventArgs)
    BindingNavigatorSaveItem.Enabled = True
End Sub

Je sais que c'est un vieux post mais ici, c'est une longue BindingSource avec IsDirtyFlag - vous pouvez l'adapter comme vous le souhaitez - j'ai tiré ce code à partir d'un autre poster quelque part sur le net il y a des années - fait quelques modifications très mineures, je pense qu'il a été à l'origine de VB - je me suis converti à C# ..

using System.ComponentModel.Design;
using System.Windows.Forms;
using System.ComponentModel;
using System.Data;
using System;
public class BindingSourceExIsDirty : System.Windows.Forms.BindingSource, INotifyPropertyChanged
{
#region "DECLARATIONS AND PROPERTIES"
private string _displayMember;
private DataTable _dataTable;
private DataSet _dataSet;
private BindingSource _parentBindingSource;
private System.Windows.Forms.Form _form;
private System.Windows.Forms.Control _usercontrol;
private bool _isCurrentDirtyFlag = false;
public bool IsCurrentDirty {
get { return _isCurrentDirtyFlag; }
set {
if (_isCurrentDirtyFlag != value) {
_isCurrentDirtyFlag = value;
this.OnPropertyChanged(value.ToString());
//call the event when flag is set
if (value == true) {
OnCurrentIsDirty(new EventArgs());
}
}
}
}
private string _objectSource;
public string ObjectSource {
get { return _objectSource; }
set {
_objectSource = value;
this.OnPropertyChanged(value);
}
}
private bool _autoSaveFlag;
public bool AutoSave {
get { return _autoSaveFlag; }
set {
_autoSaveFlag = value;
this.OnPropertyChanged(value.ToString());
}
} 
#endregion
#region "EVENTS"
//Current Is Dirty Event
public event CurrentIsDirtyEventHandler CurrentIsDirty;
//Delegate declaration.
public delegate void CurrentIsDirtyEventHandler(object sender, EventArgs e);
protected virtual void OnCurrentIsDirty(EventArgs e)
{
if (CurrentIsDirty != null) {
CurrentIsDirty(this, e);
}
}
//PropertyChanged Event 
// public event PropertyChangedEventHandler INotifyPropertyChanged.PropertyChanged;
public event PropertyChangedEventHandler PropertyChanged;
protected virtual void OnPropertyChanged(string info)
{
PropertyChangedEventHandler handler = PropertyChanged;
if (handler != null)
{
handler(this, new PropertyChangedEventArgs(info));
}       
}
#endregion
#region "METHODS"
private void _BindingComplete(System.Object sender, System.Windows.Forms.BindingCompleteEventArgs e)
{
if (e.BindingCompleteContext == BindingCompleteContext.DataSourceUpdate) {
if (e.BindingCompleteState == BindingCompleteState.Success & !e.Binding.Control.BindingContext.IsReadOnly) {
//Make sure the data source value is refreshed (fixes problem mousing off control)
e.Binding.ReadValue();
//if not focused then not a user edit.
if (!e.Binding.Control.Focused)
return;
//check for the lookup type of combobox that changes position instead of value
if (e.Binding.Control as ComboBox != null) {
//if the combo box has the same data member table as the binding source, ignore it
if (((ComboBox)e.Binding.Control).DataSource != null) {
if (((ComboBox)e.Binding.Control).DataSource as BindingSource != null) {
if (((BindingSource)((ComboBox)e.Binding.Control).DataSource).DataMember == (this.DataMember)) {
return;
}
}
}
}
IsCurrentDirty = true;
//set the dirty flag because data was changed
}
}
}
private void _DataSourceChanged(System.Object sender, System.EventArgs e)
{
_parentBindingSource = null;
if (this.DataSource == null) {
_dataSet = null;
} else {
//get a reference to the dataset
BindingSource bsTest = this;
Type dsType = bsTest.DataSource.GetType();
//try to cast the data source as a binding source
while ((bsTest.DataSource as BindingSource != null)) {
//set the parent binding source reference
if (_parentBindingSource == null)
_parentBindingSource = bsTest;
//if cast was successful, walk up the chain until dataset is reached
bsTest = (BindingSource)bsTest.DataSource;
}
//since it is no longer a binding source, it must be a dataset or something else
if (bsTest.DataSource as DataSet == null) {
//Cast as dataset did not work
if (dsType.IsClass == false) {
throw new ApplicationException("Invalid Binding Source ");
} else {
_dataSet = null;
}
} else {
_dataSet = (DataSet)bsTest.DataSource;
}
//is there a data member - find the datatable
if (!string.IsNullOrEmpty(this.DataMember)) {
_DataMemberChanged(sender, e);
}
//CType(value.GetService(GetType(IDesignerHost)), IDesignerHost)
if (_form == null)
GetFormInstance();
if (_usercontrol == null)
GetUserControlInstance();
}
}
private void _DataMemberChanged(System.Object sender, System.EventArgs e)
{
if (string.IsNullOrEmpty(this.DataMember) | _dataSet == null) {
_dataTable = null;
} else {
//check to see if the Data Member is the name of a table in the dataset
if (_dataSet.Tables(this.DataMember) == null) {
//it must be a relationship instead of a table
System.Data.DataRelation rel = _dataSet.Relations(this.DataMember);
if ((rel != null)) {
_dataTable = rel.ChildTable;
} else {
throw new ApplicationException("Invalid Data Member");
}
} else {
_dataTable = _dataSet.Tables(this.DataMember);
}
}
}
public override System.ComponentModel.ISite Site {
get { return base.Site; }
set {
//runs at design time to initiate ContainerControl
base.Site = value;
if (value == null)
return;
//Requests an IDesignerHost service using Component.Site.GetService()
IDesignerHost service = (IDesignerHost)value.GetService(typeof(IDesignerHost));
if (service == null)
return;
if ((service.RootComponent as Form != null)) {
_form = (Form)service.RootComponent;
} else if ((service.RootComponent as UserControl != null)) {
_usercontrol = (UserControl)service.RootComponent;
}
}
}
public System.Windows.Forms.Form GetFormInstance()
{
if (_form == null & this.CurrencyManager.Bindings.Count > 0) {
_form = this.CurrencyManager.Bindings[0].Control.FindForm();
}
return _form;
}
///<summary>
///Returns the First Instance of the specified User Control
///</summary>
///<returns>System.Windows.Forms.Control</returns>
public System.Windows.Forms.Control GetUserControlInstance()
{
if (_usercontrol == null & this.CurrencyManager.Bindings.Count > 0) {
System.Windows.Forms.Control[] _uControls = null;
_uControls = this.CurrencyManager.Bindings[0].Control.FindForm().Controls.Find(this.Site.Name.ToString(), true);
_usercontrol = _uControls[0];
}
return _usercontrol;
}
public BindingSourceExIsDirty()
{
DataMemberChanged += _DataMemberChanged;
DataSourceChanged += _DataSourceChanged;
BindingComplete += _BindingComplete;
}
//PositionChanged
private override void _PositionChanged(object sender, EventArgs e)
{
if (IsCurrentDirty) {
//IsAutoSavingEvent
if (AutoSave | MessageBox.Show(_msg, "Confirm Save", MessageBoxButtons.YesNo) == DialogResult.Yes) {
try {
//cast table as ITableUpdate to get the Update method
// CType(_dataTable, ITableUpdate).Update()
} catch (Exception ex) {
MessageBox.Show(ex, "Position Changed Error");
//- needs to raise an event 
}
} else {
this.CancelEdit();
_dataTable.RejectChanges();
}
IsCurrentDirty = false;
}
base(e);
}
#endregion
}