[Expand]General Information
[Collapse]WinForms Controls
  .NET Core Support
 [Expand]What's Installed
 [Expand]Build an Application
 [Collapse]Controls and Libraries
  [Expand]Forms and User Controls
  [Expand]Messages, Notifications, and Dialogs
  [Expand]Editors and Simple Controls
  [Expand]Ribbon, Bars and Menu
  [Expand]Application UI Manager
  [Expand]Docking Library
  [Expand]Data Grid
  [Expand]Vertical Grid
  [Expand]Property Grid
  [Expand]Pivot Grid
  [Expand]Tree List
  [Expand]Gantt Control
  [Collapse]Chart Control
   [Expand]Getting Started
   [Expand]Charting Basics
   [Expand]Series Views
   [Expand]Chart Elements
   [Collapse]Providing Data
     Create a Series Manually
     Manually Add Points to a Series
     Specify Series Data Members
     Generate Series from a Data Source
     Integration with a Data Grid, Vertical Grid, Tree List or List Box via ControlRowSource
     Pivot Charting (Integration with a Pivot Grid Control)
     Series Scale Types
     Series Colorizer
     Drill Down
   [Expand]Data Representation
   [Expand]Appearance Customization
   [Expand]End-User Features
   [Expand]Design-Time Features
   [Expand]Visual Elements
   [Expand]Additional Resources
  [Expand]Map Control
  [Expand]Rich Text Editor
  [Expand]Spell Checker
  [Expand]Form Layout Managers
  [Expand]Navigation Controls
  [Expand]PDF Viewer
  [Expand]TreeMap Control
  [Expand]Sunburst Control
 [Expand]Common Features
  Get More Help
 [Expand]API Reference
[Expand]ASP.NET Controls and MVC Extensions
[Expand]ASP.NET Bootstrap Controls
[Expand]ASP.NET Core Bootstrap Controls
[Expand]WPF Controls
[Expand]Xamarin Controls
[Expand]Windows 10 App Controls
[Expand]Office File API
[Expand]Report and Dashboard Server
[Expand]eXpressApp Framework
[Expand]eXpress Persistent Objects
[Expand]CodeRush Classic
[Expand]Cross-Platform Core Libraries
[Expand]Tools and Utilities
 End-User Documentation
View this topic on docs.devexpress.com (Learn more)


A chart's performance directly relates to how many elements it displays: the fewer elements a chart displays, the higher its performance. You can use the data aggregation feature to reduce rendered points when you need to show many data points simultaneously. This topic comprises all the approaches that can help you to maintain chart.

Expanded Data Aggregation

You can use the Data Aggregation functionality to configure a more compact and readable view for a large amount of data. When using data aggregation, the chart splits the x-axis into intervals (according to the measurement unit value), and automatically aggregates data for each interval using an aggregation function. The following images illustrate this feature:

Non-aggregated data Data aggregated by year

Refer to the Data Aggregation document for more details.

Expanded Loading Data

The following approaches can help you to accelerate loading data:

  • If possible, store all data points in a few series. Since the Chart control is optimized for rendering a small number of series that have many points, rather than rendering a large number of series with a few points. For example, a single series with a million points is processed faster than 10 series with 100000 points each.
  • Since v16.1, the Chart Control loads data and applies settings when a chart is being rendered. This means you do not have to use the ChartControl.BeginInit and ChartControl.EndInit methods, or the SeriesPointCollection's ChartCollectionBase.BeginUpdate and ChartCollectionBase.EndUpdate methods to accelerate loading data.
  • Manual series point creation is faster than individual series binding (series points are generated based on a data source) and series template binding (series and points are generated based on a data source). However, data binding does not cause a significant performance loss.

    You can use the Series.DataSourceSorted property to notify the chart that the series's data source is already sorted to prevent the chart's internal sorting procedures.

  • The best way to add points to the series is using a single operation instead of adding each point separately. The code below demonstrates this approach:

Expanded Automatic Calculations

Range, scale type and layout's automatic calculations require additional resources. The following steps can help accelerate rendering a chart:

Expanded Rendering Visual Elements

Follow the steps below to decrease the time needed for rendering a chart's visual elements:

Expanded Interactivity Optimization

The runtime hit testing, selection and tooltips features require additional CPU and RAM resources and may decrease performance.

Expanded Changeable Data

This section contains tips that allow you to increase performance when a chart shows a dataset that changes frequently.

  • Remove an existing point and add a new one instead to update the chart's data. Changing an existing SeriesPoint's argument or value results in unnecessary calculations. For example, changing the SeriesPoint.Values property calls the ChartControl.RefreshData method and updates the chart's data.
  • Since v17.1, the Chart Control completely processes the following event arguments to avoid reloading all the data when the chart is bound to a dataset that updates frequently:

    • System.ComponentModel.ListChangedEventArgs - obtained on the System.ComponentModel.IBindingList.ListChanged;
    • System.Collections.Specialized.NotifyCollectionChangedEventArgs - received on the System.Collections.Specialized.INotifyCollectionChanged.CollectionChanged.

    For this reason, use the System.ComponentModel.IBindingList objects to process data efficiently when a chart frequently updates data.

Is this topic helpful?​​​​​​​