Thanks Rob.

I kept using the CategoryDateTimeXAxis because I cannot guarantee all the points will be equally spaced. It just made my life a little easier if it took care of the spacing for me. I just wish I could tell it to not sort as an optional optimization.

I look forward to anything I can do to optimize the EEG chart as well. I have a C++ guy I work with that is giving me a lot of flack about .NET graphing performance... :)

Hi Mike,

Would it be possible to get your custom implementation of ObservableCollection?  The more I think about it the more I think it actually should be making a difference.  Are you sure that no PropertyChanged notifications are happening when you update the points?

Here is my implementation. Got some of this from the web so I can't really claim it.

I call SuspendNotifications before I start my update then NotifyChanges after. I could have used the AddItem method but in this case when the graph is not visible I do not call NotifyChanges to help with performance.

/*==============================================================================
/ FileName : FastObservableCollection.cs
/
/ Project : Vision.Web
/
/ Compiler(s) : Visual Studio 2012
/
/ Copyright : © 2006-2014 Spectrum Medical Ltd
/
/ Description : This is a custom implementation of an ObservableCollection
* that can be updated on a non UI thread and is supposed to be faster than the
* default implementation of ObservableCollection by allowing a single collection
* changed notification for a series of changes rather than one notification for
* each individual change.
/
/=============================================================================*/
using System.Collections.Specialized;
using System.Collections.ObjectModel;
using System.Collections;
using System;
using System.Windows.Threading;
using System.Collections.Generic;

namespace LiveOR.Classes.Collections
{
/// <summary>
/// This is a custom implementation of an ObservableCollection that can be updated on a non UI thread and is supposed to be faster than the
/// default implementation of ObservableCollection by allowing a single collection changed notification for a series of changes rather than one notification for
/// each individual change
/// </summary>
/// <typeparam name="T"></typeparam>
/// <remarks reqid="0003" type="eng">The LiveOR Classes dll will provide a class to define a custom implementation of an ObservableCollection for handling collections that have many elements modified in groups</remarks>
[Serializable]
public class FastObservableCollection<T> : ObservableCollection<T>
{
/// <summary>
/// This private variable holds the flag to
/// turn on and off the collection changed notification.
/// </summary>
private bool suspendCollectionChangeNotification;

/// <summary>
/// Initializes a new instance of the FastObservableCollection class.
/// </summary>
public FastObservableCollection()
: base()
{
this.suspendCollectionChangeNotification = false;
}

public FastObservableCollection(IEnumerable<T> list)
: base(list)
{
}

/// <summary>
/// This event is overriden CollectionChanged event of the observable collection.
/// </summary>
[field:NonSerialized]
public override event NotifyCollectionChangedEventHandler CollectionChanged;

/// <summary>
/// This method adds the given generic list of items as a range into current collection by casting them as type T.
/// It then notifies once after all items are added.
/// </summary>
/// <param name="items">The source collection.</param>
public void AddItems(IList items)
{
this.SuspendCollectionChangeNotification();
try
{
foreach (var i in items)
{
InsertItem(Count, (T)i);
}
}
catch (Exception ex)
{
throw new InvalidCastException("Please check the type of item.", ex);
}
finally
{
this.NotifyChanges();
}
}

/// <summary>
/// Raises collection change event.
/// </summary>
public void NotifyChanges()
{
this.ResumeCollectionChangeNotification();
var arg = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
this.OnCollectionChanged(arg);
}

/// <summary>
/// This method removes the given generic list of items as a range
/// into current collection by casting them as type T.
/// It then notifies once after all items are removed.
/// </summary>
/// <param name="items">The source collection.</param>
public void RemoveItems(IList items)
{
this.SuspendCollectionChangeNotification();
try
{
foreach (var i in items)
{
Remove((T)i);
}
}
catch (Exception ex)
{
throw new InvalidCastException(
"Please check the type of items getting removed.", ex);
}
finally
{
this.NotifyChanges();
}
}

/// <summary>
/// Resumes collection changed notification.
/// </summary>
public void ResumeCollectionChangeNotification()
{
this.suspendCollectionChangeNotification = false;
}

/// <summary>
/// Suspends collection changed notification.
/// </summary>
public void SuspendCollectionChangeNotification()
{
this.suspendCollectionChangeNotification = true;
}

/// <summary>
/// This collection changed event performs thread safe event raising.
/// </summary>
/// <param name="e">The event argument.</param>
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
// Recommended is to avoid reentry
// in collection changed event while collection
// is getting changed on other thread.
using (BlockReentrancy())
{
if (!this.suspendCollectionChangeNotification)
{
NotifyCollectionChangedEventHandler eventHandler = this.CollectionChanged;
if (eventHandler == null)
{
return;
}

// Walk thru invocation list.
Delegate[] delegates = eventHandler.GetInvocationList();

foreach (NotifyCollectionChangedEventHandler handler in delegates)
{
// If the subscriber is a DispatcherObject and different thread.
DispatcherObject dispatcherObject = handler.Target as DispatcherObject;

try
{
if (dispatcherObject != null && !dispatcherObject.CheckAccess())
{
// Invoke handler in the target dispatcher's thread...
// asynchronously for better responsiveness.
dispatcherObject.Dispatcher.BeginInvoke(DispatcherPriority.DataBind, handler, this, e);
}
else
{
// Execute handler as is.
handler(this, e);
}
}
catch (Exception)
{
// I keep getting null exceptions here for some reason. Throwing them on the floor to see if
// the application still functions properly if I do
}

}
}
}
}
}
}

Hi Valerie,

I just verified that the collection objects do not implement INotifyPropertyChanged so they cannot be firing off any events. Also, I am replacing the collection element, not updating a property of the object, so it shouldn't matter if they did implement that interface right?

I have actually been working on this chart performance for some time. I have implemented a few other chart controls to see if I can get better performance and so far only one has met my expectations (LightningChart). It uses about half the CPU to draw the same graph as Infragistics but as I have started using other Infragistics controls I don't want to include another 3rd party control into our product. I am still hoping we can find a more efficient way to create a sweeping EEG that doesn't kill a tablet.

Thanks,

Mike

Hi Mike,

I was under the impression that you were just updating the data points by updating their values rather than replacing them, based on your initial description of your implementation.  Since you are just replacing the items, INotifyPropertyChanged will have no bearing on this.

While I don't have an EEG example, our engineers have given me code for an EKG and I imagine that the update strategy would be similar so I'm throwing a sample together.  Out of curiosity, what kind of tablet are you using?  And just to make sure, as I have seen other posts by you on the Silverlight forums, this is for WPF correct?  I should have asked this initially.

empty

Hello Mike,

Thanks for clarifying.  The information in this thread should prove useful to the community.

Let me know if you have any further questions.

We have a tablet with an Intel N2600 Atom processor so it is very low power. I believe it has GMA 3600 graphics chip.

Hi Mike,

Interesting.  I'm curious as to what kind of graphics processor the tablet has.  I haven't really seen cases where software rendering is actually better than hardware rendering but if the graphics processor is just that bad then I guess it could give you a boost.  I never even thought about considering that.  Nice find!

I believe I understand. Thanks.

On my desktop I do see acceptable performance. I have been working with the resolution and decreasing the number of points I plot but I do not see significant gains in performance vs. the loss of accuracy in the graph. I did find out that if I force software rendering mode I get a nice performance boost on the tablet so this may make the app acceptable.

Thanks for the help.

Mike