Programmatically WPF listbox.ItemsSource update

I am doing a program like messenger that has all the contacts in a listbox with the relative states of the contacts. Cyclic I get a xml with the contacts were updated over time, then updates the states within a class of binding called "Contacts".

The class Contacts has a filter to display only certain contacts by their state, "online, away, busy,.. " but not offline, for example ....

Some code:

public class Contacts : ObservableCollection<ContactData>
{
    private ContactData.States _state = ContactData.States.Online | ContactData.States.Busy;
    public ContactData.States Filter { get { return _state; } set { _state = value; } }
    public IEnumerable<ContactData> FilteredItems
    {
        get { return Items.Where(o => o.State == _state || (_state & o.State) == o.State).ToArray(); }
    }
    public Contacts()
    {
        XDocument doc = XDocument.Load("http://lo开发者_高级运维calhost/contact/xml/contactlist.php");
        foreach (ContactData data in ContactData.ParseXML(doc)) Add(data);
    }
}

Update part:

    void StatusUpdater(object sender, EventArgs e)
    {
        ContactData[] contacts = ((Contacts)contactList.Resources["Contacts"]).ToArray<ContactData>();
        XDocument doc = XDocument.Load("http://localhost/contact/xml/status.php");
        foreach (XElement node in doc.Descendants("update"))
        {
            var item = contacts.Where(i => i.UserID.ToString() == node.Element("uid").Value);
            ContactData[] its = item.ToArray();
            if (its.Length > 0) its[0].Data["state"] = node.Element("state").Value;
        }
        contactList.ListBox.ItemsSource = ((Contacts)contactList.Resources["Contacts"]).FilteredItems;
    }

My problem is that when ItemsSource reassigns the value of the listbox, the program lag for a few seconds, until it has finished updating contacts UI (currently 250 simulated).

How can I avoid this annoying problem?

Edit: I tried with Thread and after with BackgroundWorker but nothing is changed... When i call Dispatcher.Invoke lag happen.

Class ContactData

public class ContactData : INotifyPropertyChanged
{
    public enum States { Offline = 1, Online = 2, Away = 4, Busy = 8 }
    public event PropertyChangedEventHandler PropertyChanged;
    public int UserID 
    {
        get { return int.Parse(Data["uid"]); }
        set { Data["uid"] = value.ToString(); NotifyPropertyChanged("UserID"); }
    }
    public States State 
    {
        get { return (States)Enum.Parse(typeof(States), Data["state"]); }
        //set { Data["state"] = value.ToString(); NotifyPropertyChanged("State"); }
        //correct way to update, i forgot to notify changes of "ColorState" and "BrushState"
        set 
        { 
            Data["state"] = value.ToString(); 
            NotifyPropertyChanged("State");
            NotifyPropertyChanged("ColorState");
            NotifyPropertyChanged("BrushState");
        }
    }
    public Dictionary<string, string> Data { get; set; }
    public void Set(string name, string value) 
    {
        if (Data.Keys.Contains(name)) Data[name] = value;
        else Data.Add(name, value);
        NotifyPropertyChanged("Data");
    }
    public Color ColorState { get { return UserStateToColorState(State); } }
    public Brush BrushState { get { return new SolidColorBrush(ColorState); } }
    public string FullName { get { return Data["name"] + ' ' + Data["surname"]; } }

    public ContactData() {}
    public override string ToString()
    {
        try { return FullName; }
        catch (Exception e) { Console.WriteLine(e.Message); return base.ToString(); }
    }
    Color UserStateToColorState(States state)
    {
        switch (state)
        {
            case States.Online: return Colors.LightGreen;
            case States.Away: return Colors.Orange;
            case States.Busy: return Colors.Red;
            case States.Offline: default: return Colors.Gray;
        }
    }

    public void NotifyPropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }  

    public static ContactData[] ParseXML(XDocument xmlDocument)
    {
        var result = from entry in xmlDocument.Descendants("contact")
        select new ContactData { Data = entry.Elements().ToDictionary(e => e.Name.ToString(), e => e.Value) };
        return result.ToArray<ContactData>();
    }
}

I developed a similar software: a huge contact list with data (presence and other stuff) updating quite frequently. The solution I used is different: instead of updating the whole itemssource everytime, that is quite expensive, implement a ViewModel class for each contact. The ViewModel class should implement INotifiyPropertyChanged. At this point when you parse the XML, you update the ContactViewModel properties and this will trigger the correct NotifyPropertyChanged events that will update the correct piece of UI. It might be expensive if you update a lot of properties for a lot of contacts at the same time, for that you can implement some kind of caching like: contactViewModel.BeginUpdate() contactViewModel.Presence = Presence.Available; ..... other updates contactViewModel.EndUpdate(); // at this point trigger PropertyCHanged events.

Another point: keep a separate ObservableCollection bound to the ListBox and never change the itemssource property: you risk losing the current selection, scrollposition, etc. dynamically add/remove elements from the collection bound to the listbox.

Buon divertimento e in bocca al lupo :-)

Move the downloading and parsing of the contact status information to another thread.

The line where you assigning the ItemsSource I would put in another thread, but remember about invoking or you're gonna have irritating errors.