XamDataChart AutoRefresh | Infragistics Forums

The xamDataChart is designed to gracefully bind to live updating data with millisecond refresh rates, but depending your your requirements you may want to throttle the chart refreshes even so. Below is a sample that shows the experience of the xamDataChart when updating the data every 20 milliseconds. You can change the itemsource bindings in the Xaml to point at the property Throttled to see how things look if you throttle the chart refreshes to occur only every half second, while the data source continues to refresch every 20 milliseconds.

The xamDataChart doesnt attempt to internalize the notion of when it should be updating and when not, it just responds to the datasource events provided and tries to keep the chart visual updated in as efficient as possible a way.

The Xaml:

<Grid x:Name="LayoutRoot" Background="White">
        <igChart:XamDataChart x:Name="theChart">
            <igChart:XamDataChart.Axes>
                <igChart:CategoryXAxis x:Name="xAxis" 
                                       ItemsSource="{Binding Data}"
                                       Label="{}{Label:hh:mm:ss}"/>
                <igChart:NumericYAxis x:Name="yAxis" />
            </igChart:XamDataChart.Axes>
            
            <igChart:XamDataChart.Series>
                <igChart:LineSeries x:Name="line"
                                    XAxis="{Binding ElementName=xAxis}"
                                    YAxis="{Binding ElementName=yAxis}"
                                    ValueMemberPath="Value"
                                    ItemsSource="{Binding Data}"
                                    />
            </igChart:XamDataChart.Series>
        </igChart:XamDataChart>
    </Grid>

And the code behind:

public partial class MainPage 
        : UserControl, INotifyPropertyChanged
    {
        public MainPage()
        {
            InitializeComponent();

            DataContext = this;
            Data = new ObservableCollection<TestDataItem>();
            Throttled =
                new EventThrottlingCollection<TestDataItem>(
                    Data,
                    TimeSpan.FromSeconds(.5));
            _timer.Interval = TimeSpan.FromMilliseconds(
                _millisecondRefreshInterval);
            _timer.Tick += Timer_Tick;
            _timer.Start();
        }

        private int _millisecondRefreshInterval = 20;
        private Random _rand = new Random();
        private double _currVal = 10.0;
        void Timer_Tick(object sender, EventArgs e)
        {
            if (_rand.NextDouble() > .5)
            {
                _currVal += _rand.NextDouble() * 1.0;
            }
            else
            {
                _currVal -= _rand.NextDouble() * 1.0;
            }

            DateTime now = DateTime.Now;
            Data.Add(
                new TestDataItem()
                {
                    Label = now,
                    Value = _currVal
                });

            if (Data.Count >
                (TimeSpan.FromSeconds(30).TotalMilliseconds /
                _millisecondRefreshInterval))
            {
                Data.RemoveAt(0);
            }
        }

        private DispatcherTimer _timer = new DispatcherTimer();

        private ObservableCollection<TestDataItem> _data;
        public ObservableCollection<TestDataItem> Data
        {
            get { return _data; }
            set 
            { 
                _data = value; 
                RaisePropertyChanged("Data");
            }
        }

        private EventThrottlingCollection<TestDataItem> _dataView;
        public EventThrottlingCollection<TestDataItem> Throttled
        {
            get { return _dataView; }
            set 
            {
                _dataView = value; 
                RaisePropertyChanged("Throttled"); 
            }
        }

        private void RaisePropertyChanged(string p)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(
                    this,
                    new PropertyChangedEventArgs(p));
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class EventThrottlingCollection<T>
        : IEnumerable<T>, INotifyCollectionChanged
    {
        private IEnumerable<T> _inner;
        private DateTime _lastEvent;
        TimeSpan _batchInterval;
        public EventThrottlingCollection(
            IEnumerable<T> inner, 
            TimeSpan batchInterval)
        {
            _inner = inner;
            INotifyCollectionChanged _coll =
                _inner as INotifyCollectionChanged;
            _lastEvent = DateTime.Now;
            _batchInterval = batchInterval;

            if (_coll != null)
            {
                _coll.CollectionChanged += Coll_CollectionChanged;
            }
        }

        void Coll_CollectionChanged(
            object sender, 
            NotifyCollectionChangedEventArgs e)
        {
            if (DateTime.Now - _lastEvent > _batchInterval)
            {
                _lastEvent = DateTime.Now;
                if (CollectionChanged != null)
                {
                    CollectionChanged(this, 
                        new NotifyCollectionChangedEventArgs(
                            NotifyCollectionChangedAction.Reset));
                }
            }
        }

        public IEnumerator<T> GetEnumerator()
        {
            return _inner.GetEnumerator();
        }

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

        public event NotifyCollectionChangedEventHandler CollectionChanged;
    }

    public class TestDataItem
    {
        public DateTime Label { get; set; }
        public double Value { get; set; }
    }

Hope this helps! Let me know if you have any questions.

-Graham