RadChartView supports data binding and manual population with data out of the box. The data binding feature is exposed by the different series and can be utilized by assigning a value to the ItemsSource property of a series object.
Each series has a collection of data points, that is, a data source which it displays according to the series type. For more information on chart series, please refer to our Chart Series topic.
ItemsSource is of type IEnumerable and can therefore be bound to anything. If the data source is a collection of custom objects, users will have to provide a ValueBinding which will be used by the series to determine to which property the data points of the chart will be bound to.
If the data source consists of primitive numeric types (byte, short, int, float , double, decimal) the objects in the data source will be used directly as values for the data points.
Here are two examples of how to bind RadChartView to a data source of primitive types and to a data source of custom objects:

Binding to primitive types

For any series object the data source can be set to an enumerable of primitive numerical types.
In this case the data points' values will the values in the enumerable themselves. For example for any series object the following code binds it :

Public Class Product
Private _name As String
Private _quantitySold As Double
Public Property Name As String
Get
Return Me._name
End Get
Set(value As String)
Me._name = value
End Set
End Property
Public Property QuantitySold As Double
Get
Return Me._quantitySold
End Get
Set(value As Double)
Me._quantitySold = value
End Set
End Property
End Class

we can bind a bar series object to a collection of our products like so:

The two binding classes, ValueBinding and CategoryBinding are set so that the series knows which property to bind to the value of a data point and which property to bind
to the category of a data point. RadChart supports two types of binding objects out of the box and these are PropertyNameDataPointBinding and GenericDataPointBinding.
The two binding classes do the same thing but they have different performance characteristics. PropertyNameDataPointBinding uses reflection internally to lookup values which can be slow and is not recommended for real-time charts where the items in the data source are updated frequently. For static charts it is preferred because they are very easy to use.
Also if binding is done through XAML, the PropertyNameDataPointBinding is the only approach. GenericDataPointBinding on the other hand has to be setup through code and is a lot faster because the user typically knows which property needs to be bound to the category or the value of the data points and can do the binding with a simple variable assignment, avoiding the slower reflection based approach.

If a series is bound to an observable collection, the series will update as soon as a property of a data item changes.
If we needed to track the selling of our products in real-time, we can simply put the product types in an observable collection
and whenever we update a product's sold quantity, the chart will be updated. For example: