Comment actualiser une collection liée aux données en C #?

Question

Im écrivant une application WPF simple, mais je suis coincé. Je voudrais réaliser, que j'ai une classe de filtre, et si l'ID a été modifié dans la classe de filtre par une entrée utilisateur, une liste doit actualiser l'application du filtre. Toutes les liaisons initiales fonctionnent. La liste s'affiche correctement avec le COMPANYID.

La Databinding dans XAML:

<ListBox Height="212" HorizontalAlignment="Left" Margin="211,31,0,0" Name="listBoxProducts" VerticalAlignment="Top" Width="267" ItemsSource="{Binding ElementName=this, Path=Products}" DisplayMemberPath="CompanyId" />  
<TextBox Height="28" HorizontalAlignment="Left" Margin="12,31,0,0" Name="textBoxCompanyId" VerticalAlignment="Top" Width="170" Text="{Binding ElementName=this, Path=Company.Id}" />

Le code-code pour le XAML:

private TestFactory _testFactory  = new TestFactory();

    private Company _company;
    public Company Company
    {
        get { return _company; }
    }

    private IProductList _products;
    public IProductList Products
    {
        get { return _products; }
    }


    public MainWindow()
    {
        _company = _testFactory.Company;
        _products = _testFactory.Products;

        InitializeComponent();
        _company.FilterChanged += _testFactory.FilterChanging;
    }

La classe d'usine (factice):

private IProductList _products;
    public IProductList Products 
    {
        get { return _products; }
    }

    private Company _company = new Company();
    public Company Company
    {
        get { return _company; }
    }

    public TestFactory()
    {
        _company = new Company() { Id = 2, Name = "Test Company" };
        GetProducts();
    }

    public void GetProducts()
    {
        var products = new List<Product>();
        products.Add(new Product() { ProductNumber = 1, CompanyId = 1, Name = "test product 1" });
        products.Add(new Product() { ProductNumber = 2, CompanyId = 1, Name = "test product 2" });
        products.Add(new Product() { ProductNumber = 3, CompanyId = 2, Name = "test product 3" });

        if (Company.Id != 2)
        {
            products = products.Where(p => p.CompanyId == Company.Id).ToList();
        }

        _products = new ProductList(products);
    }

    public void FilterChanging(object sender, EventArgs e)
    {
        GetProducts();
    }

L'interface de la liste de produits:

public interface IProductList : IList<Product>, INotifyCollectionChanged {}

La classe de produit Product:

public class ProductList : IProductList
{
    private readonly IList<Product> _products;

    public ProductList() { }

    public ProductList(IList<Product> products)
    {
        _products = products;
    }


    public IEnumerator<Product> GetEnumerator()
    {
        return _products.GetEnumerator();
    }


    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }


    public void Add(Product item)
    {
        _products.Add(item);
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, item));
    }


    public void Clear()
    {
        _products.Clear();
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }


    public bool Contains(Product item)
    {
        return _products.Contains(item);
    }


    public void CopyTo(Product[] array, int arrayIndex)
    {
        _products.CopyTo(array, arrayIndex);
    }


    public bool Remove(Product item)
    {
        var removed = _products.Remove(item);

        if (removed)
        {
            notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, item));
        }
        return removed;
    }


    public int Count
    {
        get { return _products.Count; }
    }


    public bool IsReadOnly
    {
        get { return _products.IsReadOnly; }
    }


    public int IndexOf(Product item)
    {
        return _products.IndexOf(item);
    }


    public void Insert(int index, Product item)
    {
        _products.Insert(index, item);
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }


    public void RemoveAt(int index)
    {
        _products.RemoveAt(index);
        notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
    }


    public Product this[int index]
    {
        get { return _products[index]; }
        set
        {
            _products[index] = value;
            notifyCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, _products[index]));
        }
    }


    public event NotifyCollectionChangedEventHandler CollectionChanged;
    private void notifyCollectionChanged(NotifyCollectionChangedEventArgs args)
    {
        if (CollectionChanged != null)
        {
            CollectionChanged(this, args);
        }
    }
}

La classe de l'entreprise (classe de filtre):

public class Company : INotifyPropertyChanged
{
    private int _id;
    public int Id
    {
        get { return _id; }
        set 
        {
            if (_id == value)
                return;

            _id = value;
            OnPropertyChanged("Id");

            OnFilterChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
        }
    }

    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value)
                return;

            _name = value;
            OnPropertyChanged("Name");
        }
    }


    public event PropertyChangedEventHandler PropertyChanged;
    public event EventHandler FilterChanged;

    private void OnPropertyChanged(string name)
    {
        if (PropertyChanged == null)
            return;

        var eventArgs = new PropertyChangedEventArgs(name);
        PropertyChanged(this, eventArgs);
    }

    private void OnFilterChanged(NotifyCollectionChangedEventArgs e)
    {
        if (FilterChanged == null)
            return;

        FilterChanged(this, e);
    }
}

La liste est actualisée en usine, mais il n'y a aucun changement dans la vue. Je fais probablement quelque chose de mal, peut-être que toute mon approche n'est pas la meilleure. Peut-être que je dois utiliser le type d'observation de la collection avec ValuConverter? Toute aide serait grandement appréciée. Acclamations!

Answer 1

Utiliser un ObservableCollection<Product> Au lieu de créer votre propre liste en fonction de IList

Le but d'un ObservableCollection est de suivre les modifications de la collection, et il mettra automatiquement à jour l'interface utilisateur lorsque la collection changera.

Answer 2

Vous pouvez également envisager d'utiliser ICOllectionView pour ce cas d'utilisation.

Référer ceci Publier.