Wie kann ich Ereignis auslösen, bevor Element zur Sammlung in C# hinzugefügt wird?

Question

Ich möchte einige Verarbeitung zu tun, bevor ein Element zu einer BindingList hinzugefügt wird. Ich sehe, dass es ein ListChanged-Ereignis gibt, aber dieses wird ausgelöst, nachdem das Element hinzugefügt wurde. Das AddingNew-Ereignis wird nur ausgelöst, wenn die AddNew-Methode (nicht die Add-Methode) aufgerufen wird. Hat jemand so etwas schon einmal gemacht?

UPDATE:

Ich habe die folgenden Klassen erstellt, und wenn die Add-Methode auf der IList aufgerufen wird, wird meine neue Add-Methode ausgelöst. Habe ich also das Casting-Problem, von dem ich an anderer Stelle gelesen habe? Wenn ich die ISpecialCollection-Schnittstelle aus der Sammlung entfernt habe, wird meine Add-Methode nicht aufgerufen. Kann jemand erklären, warum es sich anders verhält? Habe ich das Casting-Problem, wenn ich die Schnittstelle ISpecialCollection< verwende?

public interface ISpecialCollection<T> : IList<T>
{
}

public class SpecialCollection<T> : BindingList<T>, ISpecialCollection<T>
{
  public new void Add (T item)  
  {
    base.Add(item);    
  }
}

class Program
{
  static void Main(string[] args)
  {
    IList<ItemType> list = new SpecialCollection<ItemType>();
    list.Add(new ItemType());
  }
}

Answer 1

Der einfachste Weg besteht darin, die Unterklasse Collection<T> Klasse. Dies ist die Sammelklasse in der BCL, die entworfen untergeordnet werden und sein Verhalten überschreiben lassen. Das Unterklassifizieren anderer Typen wie BindingList<T> o List<T> wird Ihnen nur Schmerzen bereiten.

Sobald Sie die Unterklasse Collection<T> können Sie Add außer Kraft setzen und ein eigenes Ereignis erstellen, auf das Sie hören.

Answer 2

Sie sollten die geschützte BindingList.InsertItem Methode ( MSDN ). Add , Insert usw. rufen dies alles auf, um das eigentliche Hinzufügen durchzuführen und entsprechende Ereignisse auszulösen. Lösen Sie Ihr Ereignis aus, und rufen Sie dann base.InsertItem um den Rest zu erledigen.

Answer 3

Ich habe etwas Ähnliches gemacht, da ich die Ereignisse ItemAdding und ItemAdded erfassen musste

Der Clou ist das Schlüsselwort new, mit dem die Methode der geerbten Klasse außer Kraft gesetzt wird

// class that inherits generic List and hides the add item
public class ListWithEvents<T> : List<T>
    {
        public event EventHandler ItemAdding;
        public event EventHandler ItemAdded;

        public new void Add(T item)
        {
            if (ItemAdding != null)
                ItemAdding(item, EventArgs.Empty);

            base.Add(item);

            if (ItemAdded != null)
                ItemAdded(item, EventArgs.Empty);

        }
    }

// Using the class
protected override void OnLoad(EventArgs e)
    {

        ListWithEvents<int> lstI = new ListWithEvents<int>();
        lstI.ItemAdded += new EventHandler(lstI_ItemAdded);
        lstI.ItemAdding += new EventHandler(lstI_ItemAdding);
    }

    void lstI_ItemAdding(object sender, EventArgs e)
    {
        throw new NotImplementedException();
    }

    void lstI_ItemAdded(object sender, EventArgs e)
    {
        throw new NotImplementedException();
    }

Answer 4

Etwa so:

  public class PreProcessBindingList<T> : Collection<T>
    {   
        public AddingNewEventHandler AddingNew;

        public override void Add(T item)
        {
            PreProcess(item);
            base.Add(item);

            AddingNewEventHandler addingNew = this.AddingNew;
            if (addingNew != null)
            {
                addingNew(this, new AddingNewEventArgs(item));
            }
        }
    }

Answer 5

Der richtige Weg dazu ist die Erweiterung Collection<T> und überschreiben Sie die InsertItem Methode. Sie können Ihr Ereignis dort auslösen, bevor Sie base.InsertItem aufrufen.