Using PointDataSource Online

This sample demonstrates how to create a graphics layer by binding to a source of items that reference location using X and Y values. The PointDataSource property references an ObservableCollection of objects with properties containing X and Y values. The PointDataSource.XCoordinateBinding is set to the property containing X values, and the PointDataSource.YCoordinateBinding is set to the property containing Y values. The appropriate event mechanisms are in place so changes in the items are reflected in the graphics layer. This sample highlights how the functionality can be used in the Model View ViewModel (MVVM) design pattern.

XAML

<UserControl x:Class="ArcGISWPFSDK.UsingPointDataSource"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:esri="http://schemas.esri.com/arcgis/client/2009"
    xmlns:local="clr-namespace:ArcGISWPFSDK">

    <UserControl.Resources>
        <local:MainViewModel x:Key="MyViewModel" />
    </UserControl.Resources>

    <Grid x:Name="LayoutRoot">

        <Grid.Resources>
            <esri:PictureMarkerSymbol x:Key="SelectMarkerSymbol" Source="http://static.arcgis.com/images/Symbols/Basic/YellowFlag.png" 
                  Width="24" Height="24" OffsetX="12" OffsetY="12"/>
        </Grid.Resources>

        <esri:Map x:Name="MyMap" UseAcceleratedDisplay="True" WrapAround="True" >

            <esri:ArcGISTiledMapServiceLayer ID="BaseMap"
				Url="http://services.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer" />

            <esri:GraphicsLayer>
                <esri:GraphicsLayer.GraphicsSource>
                    <esri:PointDataSource
                            ItemsSource="{Binding Source={StaticResource MyViewModel}, 
                            Path=Instance.Data.PointsOfInterest}"
                            XCoordinateBinding="{Binding X}"
                            YCoordinateBinding="{Binding Y}"
                            IsSelectedBinding="{Binding IsSelected}">
                    </esri:PointDataSource>
                </esri:GraphicsLayer.GraphicsSource>

                <esri:GraphicsLayer.Renderer>
                    <esri:SimpleRenderer Symbol="{StaticResource SelectMarkerSymbol}" />
                </esri:GraphicsLayer.Renderer>

                <esri:GraphicsLayer.MapTip>
                    <Grid DataContext="{Binding [DataContext]}" Background="White" esri:GraphicsLayer.MapTipAutoPosition="True">
                        <StackPanel Orientation="Vertical" Margin="5" >
                            <TextBlock Text="{Binding Name}"  />
                        </StackPanel>
                        <Border BorderBrush="Black" BorderThickness="1" />
                    </Grid>
                </esri:GraphicsLayer.MapTip>
            </esri:GraphicsLayer>

        </esri:Map>

        <Border HorizontalAlignment="Right" VerticalAlignment="Top" Margin="10" Padding="5" Background="White" 
                BorderBrush="Black" BorderThickness="1">
            <Border.Effect>
                <DropShadowEffect />
            </Border.Effect>
            <StackPanel DataContext="{Binding Source={StaticResource MyViewModel}, Path=Instance}"
                    Orientation="Horizontal" VerticalAlignment="Top" HorizontalAlignment="Left" 
                    Width="330" Height="50" Margin="5">
                <Button Content="Add item" Command="{Binding AddRandom}" Margin="5" Width="100" />
                <Button Content="Remove item" Command="{Binding RemoveFirst}" Margin="5" Width="100"/>
                <Button Content="Randomize items" Command="{Binding Randomize}" Margin="5" Width="100"/>
            </StackPanel>
        </Border>
    </Grid>
</UserControl>

C#

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows.Controls;
using System.Windows.Input;

namespace ArcGISWPFSDK
{
    public partial class UsingPointDataSource : UserControl
    {
        public UsingPointDataSource()
        {
            InitializeComponent();
        }
    }

    public class MainModel : INotifyPropertyChanged
    {
        private ObservableCollection<DataPoint> _PointsOfInterest;
        public ObservableCollection<DataPoint> PointsOfInterest
        {
            get { return _PointsOfInterest; }
            set
            {
                if (_PointsOfInterest != value)
                {
                    _PointsOfInterest = value;
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("PointsOfInterest"));
                }
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class DataPoint : INotifyPropertyChanged
    {
        private double _X;
        private double _Y;
        private bool _IsSelected;

        public double X
        {
            get { return _X; }
            set
            {
                if (_X != value)
                {
                    _X = value;
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("X"));
                }
            }
        }

        public double Y
        {
            get { return _Y; }
            set
            {
                if (_Y != value)
                {
                    _Y = value;
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("Y"));
                }
            }
        }

        public string _Name;

        public string Name
        {
            get { return _Name; }
            set
            {
                if (_Name != value)
                {
                    _Name = value;
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("Name"));
                }
            }
        }

        public bool IsSelected
        {
            get { return _IsSelected; }
            set
            {
                if (_IsSelected != value)
                {
                    _IsSelected = value;
                    if (PropertyChanged != null)
                        PropertyChanged(this, new PropertyChangedEventArgs("IsSelected"));
                }
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
    }

    public class MainViewModel
    {
        private const double width = 360;
        private const double height = 180;
        private static Random r = new Random();

        public MainModel Data { get; set; }
        private static MainViewModel instance;
        public MainViewModel Instance
        {
            get
            {
                if (instance == null)
                    instance = new MainViewModel();
                return instance;
            }
        }

        public ICommand Randomize { get; private set; }
        public ICommand AddRandom { get; private set; }
        public ICommand RemoveFirst { get; private set; }

        public MainViewModel()
        {
            Data = new MainModel()
            {
                PointsOfInterest = new
                    System.Collections.ObjectModel.ObservableCollection<DataPoint>()
            };
            GenerateDataSet();

            AddRandom = new DelegateCommand((a) => AddRandomEntry(), (b) => { return true; });

            RemoveFirst = new DelegateCommand((a) =>
            {
                if (Data.PointsOfInterest.Count > 0) Data.PointsOfInterest.RemoveAt(0);
            }, (b) => { return true; });
            
            Randomize = new DelegateCommand((a) => RandomizeEntries(), (b) => { return true; });
        }

        #region Generate random data
        private void GenerateDataSet()
        {
            for (int i = 0; i < 10; i++)
            {
                AddRandomEntry();
            }
        }

        private void AddRandomEntry()
        {
            Data.PointsOfInterest.Add(CreateRandomEntry(Data.PointsOfInterest.Count));
        }

        private DataPoint CreateRandomEntry(int i)
        {
            return new DataPoint()
            {
                X = r.NextDouble() * width - width * .5,
                Y = r.NextDouble() * height - height * .5,
                Name = string.Format("Item #{0}", i)
            };
        }

        private void RandomizeEntries()
        {
            for (int i = 0; i < Data.PointsOfInterest.Count; i++)
            {
                var pnt = Data.PointsOfInterest[r.Next(Data.PointsOfInterest.Count)];
                pnt.X = r.NextDouble() * width - width * .5;
                pnt.Y = r.NextDouble() * height - height * .5;
            }
        }
        #endregion
    }

    public class DelegateCommand : ICommand
    {
        Func<object, bool> canExecute;
        Action<object> executeAction;
        bool canExecuteCache;

        public DelegateCommand(Action<object> executeAction, Func<object, bool> canExecute)
        {
            this.executeAction = executeAction;
            this.canExecute = canExecute;
        }

        public bool CanExecute(object parameter)
        {
            bool temp = canExecute(parameter);
            if (canExecuteCache != temp)
            {
                canExecuteCache = temp;
                if (CanExecuteChanged != null)
                {
                    CanExecuteChanged(this, new EventArgs());
                }
            }

            return canExecuteCache;
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            executeAction(parameter);
        }
    }
}

VB.NET

Imports System
Imports System.Windows.Controls
Imports System.Windows.Input
Imports System.ComponentModel
Imports System.Collections.ObjectModel

Namespace ArcGISWPFSDK

    Partial Public Class UsingPointDataSource
        Inherits UserControl
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class

    Public Class MainModel
        Implements INotifyPropertyChanged
        Private _PointsOfInterest As ObservableCollection(Of DataPoint)
        Public Property PointsOfInterest() As ObservableCollection(Of DataPoint)
            Get
                Return _PointsOfInterest
            End Get
            Set(ByVal value As ObservableCollection(Of DataPoint))
                If _PointsOfInterest IsNot value Then
                    _PointsOfInterest = value
                    RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("PointsOfInterest"))
                End If
            End Set
        End Property
        Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
    End Class

    Public Class DataPoint
        Implements INotifyPropertyChanged
        Private _X As Double
        Private _Y As Double
        Private _IsSelected As Boolean

        Public Property X() As Double
            Get
                Return _X
            End Get
            Set(ByVal value As Double)
                If _X <> value Then
                    _X = value
                    RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("X"))
                End If
            End Set
        End Property

        Public Property Y() As Double
            Get
                Return _Y
            End Get
            Set(ByVal value As Double)
                If _Y <> value Then
                    _Y = value
                    RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("Y"))
                End If
            End Set
        End Property

        Public _Name As String

        Public Property Name() As String
            Get
                Return _Name
            End Get
            Set(ByVal value As String)
                If _Name <> value Then
                    _Name = value
                    RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("Name"))
                End If
            End Set
        End Property

        Public Property IsSelected() As Boolean
            Get
                Return _IsSelected
            End Get
            Set(ByVal value As Boolean)
                If _IsSelected <> value Then
                    _IsSelected = value
                    RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("IsSelected"))
                End If
            End Set
        End Property
        Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged
    End Class

    Public Class MainViewModel
        Private Const width As Double = 360
        Private Const height As Double = 180
        Private Shared r As New Random()

        Public Property Data() As MainModel
        Private Shared mvm_instance As MainViewModel
        Public ReadOnly Property Instance() As MainViewModel
            Get
                If mvm_instance Is Nothing Then
                    mvm_instance = New MainViewModel()
                End If
                Return mvm_instance
            End Get
        End Property
        Private privateRandomize As ICommand
        Public Property Randomize() As ICommand
            Get
                Return privateRandomize
            End Get
            Private Set(ByVal value As ICommand)
                privateRandomize = value
            End Set
        End Property
        Private privateAddRandom As ICommand
        Public Property AddRandom() As ICommand
            Get
                Return privateAddRandom
            End Get
            Private Set(ByVal value As ICommand)
                privateAddRandom = value
            End Set
        End Property
        Private privateRemoveFirst As ICommand
        Public Property RemoveFirst() As ICommand
            Get
                Return privateRemoveFirst
            End Get
            Private Set(ByVal value As ICommand)
                privateRemoveFirst = value
            End Set
        End Property

        Public Sub New()
            Data = New MainModel() With
                   {
                     .PointsOfInterest = New System.Collections.ObjectModel.ObservableCollection(Of DataPoint)()
                   }
            GenerateDataSet()

            AddRandom = New DelegateCommand(Sub(a) AddRandomEntry(), Function(b)
                                                                         Return True
                                                                     End Function)
            RemoveFirst = New DelegateCommand(Sub(a)
                                                  If Data.PointsOfInterest.Count > 0 Then
                                                      Data.PointsOfInterest.RemoveAt(0)
                                                  End If
                                              End Sub, Function(b) True)
            Randomize = New DelegateCommand(Sub(a) RandomizeEntries(), Function(b)
                                                                           Return True
                                                                       End Function)
        End Sub

#Region "Generate random data "
        Private Sub GenerateDataSet()
            For i As Integer = 0 To 9
                AddRandomEntry()
            Next i
        End Sub

        Private Sub AddRandomEntry()
            Data.PointsOfInterest.Add(CreateRandomEntry(Data.PointsOfInterest.Count))
        End Sub

        Private Function CreateRandomEntry(ByVal i As Integer) As DataPoint
            Return New DataPoint() With {.X = r.NextDouble() * width - width * 0.5, .Y = r.NextDouble() * height - height * 0.5, .Name = String.Format("Item #{0}", i)}
        End Function

        Private Sub RandomizeEntries()
            For i As Integer = 0 To Data.PointsOfInterest.Count - 1
                Dim pnt = Data.PointsOfInterest(r.Next(Data.PointsOfInterest.Count))
                pnt.X = r.NextDouble() * width - width * 0.5
                pnt.Y = r.NextDouble() * height - height * 0.5
            Next i
        End Sub
#End Region


    End Class

    Public Class DelegateCommand
        Implements ICommand

        Dim can_Execute As Func(Of Object, Boolean)
        Dim executeAction As Action(Of Object)
        Dim canExecuteCache As Boolean

        Public Sub New(ByVal executeAction As Action(Of Object), ByVal canExecute As Func(Of Object, Boolean))
            Me.executeAction = executeAction
            Me.can_Execute = canExecute
        End Sub


        Public Function CanExecute(ByVal parameter As Object) As Boolean Implements System.Windows.Input.ICommand.CanExecute
            Dim temp As Boolean = can_Execute(parameter)
            If canExecuteCache <> temp Then
                canExecuteCache = temp
                If Not CanExecuteChangedEvent Is Nothing Then
                    RaiseEvent CanExecuteChanged(Me, New EventArgs())
                End If
            End If

            Return canExecuteCache
        End Function
        Public Event CanExecuteChanged(sender As Object, e As System.EventArgs) Implements System.Windows.Input.ICommand.CanExecuteChanged

        Public Sub Execute(parameter As Object) Implements System.Windows.Input.ICommand.Execute
            executeAction(parameter)
        End Sub


    End Class

End Namespace