Its back up. So you can check that out if you want. But the exampl linked is really more for if you want to create the series based on a template in Xaml. If you are already creating the series collection in your View Model have you tried just binding it to the chart?

I.E if the property holding the SeriesCollection on your DataContext is called Series. Have you tried

<XamWebChart Series="{Binding Series} ...

-Graham

Thank you very much Graham. That works like a charm. If possible, please keep me posted about the bug status.

Thank you.

Hi,

I'm trying to do the same thing for a XamDataChart, but the Series property is marked as read-only. How would one assign the series collection to the control fro mthe view model in this control?

Sorry for the delay, I've been out of the office for a while. Here's something that can should get you started.
The gist is to use an attached property to synchronize your source viewmodel with the series that are populated in the chart.
The viewmodels for the series are produce the concrete series by means of a DataTemplate you provide which should produce a series when loaded.

Here's an example of the Xaml:

<Grid x:Name="LayoutRoot" Background="White">
        <Grid.RowDefinitions>
            <RowDefinition />
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <ig:XamDataChart Name="xamDataChart1" >
            <ig:XamDataChart.Axes>
                <ig:CategoryXAxis x:Name="xAxis"
                          ItemsSource="{Binding Item.Data}"
                          Label="{}{Label}"/>
                <ig:NumericYAxis x:Name="yAxis" />
            </ig:XamDataChart.Axes>
            
            <local:SeriesBinder.BindingInfo>
                <local:SeriesBindingInfo 
                    ItemsSource="{Binding}">
                    <local:SeriesBindingInfo.SeriesTemplate>
                        <DataTemplate>
                            <ig:LineSeries 
                                ItemsSource="{Binding Item.Data}"
                                ValueMemberPath="{Binding Item.ValueMemberPath}"
                                XAxis="{Binding Path=Owner.Axes[0]}"
                                YAxis="{Binding Path=Owner.Axes[1]}"
                                >
                            </ig:LineSeries>
                        </DataTemplate>
                    </local:SeriesBindingInfo.SeriesTemplate>
                </local:SeriesBindingInfo>
            </local:SeriesBinder.BindingInfo>
        </ig:XamDataChart>

        <Button Grid.Row="1" 
                Content="Click" 
                Click="Button_Click"/>
    </Grid>

And here is the code behind to support this usage:

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

            DataContext = new TestSeries();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            (DataContext as TestSeries).Add(
                new TestSeriesItem());
        }
    }

    public class TestSeries
        : ObservableCollection<TestSeriesItem>
    {
        public TestSeries()
        {
            Add(new TestSeriesItem());
            Add(new TestSeriesItem());
            Add(new TestSeriesItem());
        }
    }

    public class TestSeriesItem
    {
        public TestSeriesItem()
        {
            Data = new TestData();
            ValueMemberPath = "Value";
        }

        public IEnumerable Data { get; set; }
        public string ValueMemberPath { get; set; }
    }

    public class TestData
        : ObservableCollection<TestDataItem>
    {
        private static Random rand = new Random();

        public TestData()
        {
            for (int i = 0; i < 20; i++)
            {
                Add(new TestDataItem()
                {
                    Label = i.ToString(),
                    Value = rand.NextDouble()
                });
            }
        }
    }

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

    public class SeriesDataContext
        : DependencyObject
    {
        public static DependencyProperty ItemProperty =
          DependencyProperty.Register("Item",
          typeof(object), typeof(SeriesDataContext),
          new PropertyMetadata(null,
              (o, e) =>
              {
              }));

        public object Item
        {
            get
            {
                return GetValue(ItemProperty);
            }
            set
            {
                SetValue(ItemProperty, value);
            }
        }

        public static DependencyProperty OuterContextProperty =
         DependencyProperty.Register("OuterContext",
         typeof(object), typeof(SeriesDataContext),
         new PropertyMetadata(null,
             (o, e) =>
             {
             }));

        public object OuterContext
        {
            get
            {
                return GetValue(OuterContextProperty);
            }
            set
            {
                SetValue(OuterContextProperty, value);
            }
        }

        public static DependencyProperty OwnerProperty =
          DependencyProperty.Register("Owner",
          typeof(XamDataChart), typeof(SeriesDataContext),
          new PropertyMetadata(null,
              (o, e) =>
              {
              }));

        public XamDataChart Owner
        {
            get
            {
                return (XamDataChart)GetValue(OwnerProperty);
            }
            set
            {
                SetValue(OwnerProperty, value);
            }
        }
    }

    public class SeriesBindingInfo
       : FrameworkElement
    {
        public static DependencyProperty OwnerProperty =
          DependencyProperty.Register("Owner",
          typeof(XamDataChart), typeof(SeriesBindingInfo),
          new PropertyMetadata(null,
              (o, e) =>
              {
                  (o as SeriesBindingInfo).OnOwnerChanged(e);
              }));

        public XamDataChart Owner
        {
            get
            {
                return (XamDataChart)GetValue(OwnerProperty);
            }
            set
            {
                SetValue(OwnerProperty, value);
            }
        }

        public static DependencyProperty ItemsSourceProperty =
            DependencyProperty.Register("ItemsSource",
            typeof(IEnumerable), typeof(SeriesBindingInfo),
            new PropertyMetadata(null,
                (o, e) =>
                {
                    (o as SeriesBindingInfo).OnItemsSourceChanged(e);
                }));

        public IEnumerable ItemsSource
        {
            get
            {
                return (IEnumerable)GetValue(ItemsSourceProperty);
            }
            set
            {
                SetValue(ItemsSourceProperty, value);
            }
        }

        public static DependencyProperty SeriesTemplateProperty =
            DependencyProperty.Register("SeriesTemplate",
            typeof(DataTemplate), typeof(SeriesBindingInfo),
            new PropertyMetadata(null,
                (o, e) =>
                {
                    (o as SeriesBindingInfo).OnSeriesTemplateChanged(e);
                }
                    ));

        public DataTemplate SeriesTemplate
        {
            get
            {
                return (DataTemplate)GetValue(SeriesTemplateProperty);
            }
            set
            {
                SetValue(SeriesTemplateProperty, value);
            }
        }

        protected void OnItemsSourceChanged(
            DependencyPropertyChangedEventArgs e)
        {
            Clear();

            if (e.OldValue != null)
            {
                UnRegCollection(e.OldValue as IEnumerable);
            }
            if (e.NewValue != null)
            {
                RegCollection(e.NewValue as IEnumerable);
                UpdateFromCollection(e.NewValue as IEnumerable);
            }
        }

        public static DependencyProperty OuterContextProperty =
        DependencyProperty.Register("OuterContext",
        typeof(object), typeof(SeriesBindingInfo),
        new PropertyMetadata(null,
            (o, e) =>
            {
            }));

        public object OuterContext
        {
            get
            {
                return GetValue(OuterContextProperty);
            }
            set
            {
                SetValue(OuterContextProperty, value);
            }
        }

        protected void OnSeriesTemplateChanged(
            DependencyPropertyChangedEventArgs e)
        {
            Clear();
            UpdateFromCollection(ItemsSource);
        }

        private void OnOwnerChanged(
            DependencyPropertyChangedEventArgs e)
        {
            SetBinding(DataContextProperty,
            new Binding("OuterContext")
                    {
                        Source = this
                    });
            Clear();
            UpdateFromCollection(ItemsSource);
        }

        private void Clear()
        {
            if (Owner == null)
            {
                return;
            }
            Owner.Series.Clear();
        }

        private void UpdateFromCollection(
            IEnumerable collection)
        {
            if (collection == null)
            {
                return;
            }
            foreach (object item in collection)
            {
                AddItem(item);
            }
        }

        private void AddItem(
            object item)
        {
            if (SeriesTemplate == null)
            {
                return;
            }

            Series series = SeriesTemplate.LoadContent() as Series;
            if (series != null)
            {
                SeriesDataContext context =
                    new SeriesDataContext()
                        {
                            Item = item,
                            Owner = Owner
                        };
                BindingOperations.SetBinding(
                    context,
                    SeriesDataContext.OuterContextProperty,
                    new Binding("OuterContext")
                    {
                        Source = this
                    });

                series.DataContext = context;
                Axis xAxis = null;
                Axis yAxis = null;
                GetAxes(series, ref xAxis, ref yAxis);

                if (xAxis != null)
                {
                    UpdateAxis(context, xAxis);
                }
                if (yAxis != null)
                {
                    UpdateAxis(context, yAxis);
                }

                Owner.Series.Add(series);
            }
        }

        private void UpdateAxis(SeriesDataContext context, Axis axis)
        {
            axis.DataContext = context;
            if (!Owner.Axes.Contains(axis))
            {
                Owner.Axes.Add(axis);
            }
        }

        private void GetAxes(Series series, ref Axis xAxis, ref Axis yAxis)
        {
            if (series is AnchoredCategorySeries)
            {
                xAxis = (series as AnchoredCategorySeries).XAxis;
                yAxis = (series as AnchoredCategorySeries).YAxis;
            }
            else if (series is RangeCategorySeries)
            {
                xAxis = (series as RangeCategorySeries).XAxis;
                yAxis = (series as RangeCategorySeries).YAxis;
            }
            else if (series is FinancialSeries)
            {
                xAxis = (series as FinancialSeries).XAxis;
                yAxis = (series as FinancialSeries).YAxis;
            }
            else if (series is ScatterBase)
            {
                xAxis = (series as ScatterBase).XAxis;
                yAxis = (series as ScatterBase).YAxis;
            }
        }

        private void RegCollection(
            IEnumerable collection)
        {
            if (collection is INotifyCollectionChanged)
            {
                (collection as INotifyCollectionChanged).CollectionChanged
                    += SeriesBindingInfo_CollectionChanged;
            }
        }

        private void UnRegCollection(
            IEnumerable collection)
        {
            if (collection is INotifyCollectionChanged)
            {
                (collection as INotifyCollectionChanged).CollectionChanged
                    -= SeriesBindingInfo_CollectionChanged;
            }
        }

        void SeriesBindingInfo_CollectionChanged(
            object sender,
            NotifyCollectionChangedEventArgs e)
        {
            if (Owner == null)
            {
                return;
            }
            //this could be made more efficient of course.   
            Clear();
            UpdateFromCollection(ItemsSource);
        }
    }

    public class SeriesBinder
        : DependencyObject
    {
        public static DependencyProperty ContextBridgeProperty =
          DependencyProperty.RegisterAttached("ContextBridge",
          typeof(object), typeof(SeriesBinder),
          new PropertyMetadata(null,
              (o, e) =>
              {
                  SeriesBindingInfo sbi = GetBindingInfo(o);
                  if (sbi != null)
                  {
                      sbi.OuterContext = e.NewValue;
                  }
              }));

        public static DependencyProperty BindingInfoProperty =
            DependencyProperty.RegisterAttached("BindingInfo",
            typeof(SeriesBindingInfo), typeof(SeriesBinder),
            new PropertyMetadata(null,
                (o, e) =>
                {
                    if (o is XamDataChart)
                    {
                        SeriesBindingInfo prev = GetBindingInfo(o);
                        if (prev != null && prev.Owner != null)
                        {
                            prev.Owner = null;
                        }
                        if (e.NewValue != null)
                        {
                            XamDataChart newOwner =
                                o as XamDataChart;
                            newOwner.SetBinding(
                                SeriesBinder.ContextBridgeProperty,
                                new Binding());
                            
                            (e.NewValue as SeriesBindingInfo)
                                .Owner = (XamDataChart)o;

                            if (GetContextBridge(o) != null)
                            {
                                (e.NewValue as SeriesBindingInfo)
                                    .OuterContext = GetContextBridge(o);
                            }
                        }
                    }
                }));


        public static void SetBindingInfo(
            DependencyObject target,
            SeriesBindingInfo info)
        {
            target.SetValue(BindingInfoProperty, info);
        }

        public static SeriesBindingInfo GetBindingInfo(
            DependencyObject target)
        {
            return (SeriesBindingInfo)target.GetValue(BindingInfoProperty);
        }

        public static void SetContextBridge(
            DependencyObject target,
            object context)
        {
            target.SetValue(ContextBridgeProperty, context);
        }

        public static object GetContextBridge(
            DependencyObject target)
        {
            return target.GetValue(ContextBridgeProperty);
        }
    }

The above example was assuming a situation where you wanted to share axes between all the series in the chart
However, you could also use an approach like this to define seperate axes per item in your viewmodel collection, e.g:

<Grid x:Name="LayoutRoot" Background="White">
        <Grid.RowDefinitions>
            <RowDefinition />
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <ig:XamDataChart Name="xamDataChart1" >
            <ig:XamDataChart.Axes>
                <ig:NumericYAxis x:Name="yAxis" />
            </ig:XamDataChart.Axes>
            
            <local:SeriesBinder.BindingInfo>
                <local:SeriesBindingInfo 
                    ItemsSource="{Binding}">
                    <local:SeriesBindingInfo.SeriesTemplate>
                        <DataTemplate>
                            <ig:LineSeries 
                                ItemsSource="{Binding Item.Data}"
                                ValueMemberPath="{Binding Item.ValueMemberPath}"
                                YAxis="{Binding Path=Owner.Axes[0]}"
                                >
                                <ig:LineSeries.XAxis>
                                    <ig:CategoryXAxis
                                        ItemsSource="{Binding Item.Data}"
                                        Label="{}{Label}"/>
                                </ig:LineSeries.XAxis>
                            </ig:LineSeries>
                        </DataTemplate>
                    </local:SeriesBindingInfo.SeriesTemplate>
                </local:SeriesBindingInfo>
            </local:SeriesBinder.BindingInfo>
        </ig:XamDataChart>

        <Button Grid.Row="1" 
                Content="Click" 
                Click="Button_Click"/>
    </Grid>

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

-Graham

Hello Graham,

  I have been trying to use your example with the latest version of Infragistics Wpf release. However in the function GetAxes, you have code such as this:

 xAxis = (series as AnchoredCategorySeries).XAxis;
But there is no property called XAxis defined anymore. It seems that they have removed this property. How do I modify the code to get this example to work with the new version of infragistics 2012 version.

Hello,

Thank you for your post. I have been looking into it, but since in the thread there are a coouple of samples and links to other threads with samples, could pelase send me the one that you have issues with.

Looking forward for your reply.

I am referring to the post made by:

[Infragistics] Graham Murray on 07-26-2010 5:31 PM

Is there a slightly easier way to achieve databinding rather than use what Graham has suggested?