Wsrtjtyk

I have a WPF application using Caliburn.Micro.

The DataGrid has an attribute SelectedItem="{Binding Path=SelectedUsageRecord}"

As you can see, SelectedItem is bound to SelectedUsageRecord property. But I need to be able to handle selecting multiple records. Is this possible to bind multiple records to a collection property? I don't see anything like "SelectedItems"...
Thanks.

Here's what I did after striking the same scenario as you. In short handle the selection change event directly and pull the selected rows from the event args.
Assuming a source collection of "Rows" each one being a RowViewModel, and a collection for the "_selectedRows".

<DataGrid RowsSource="{Binding Rows}" x:Name="Rows"                  

          SelectionMode="Extended" SelectionUnit="FullRow">

    <i:Interaction.Triggers>

        <i:EventTrigger EventName="SelectionChanged">

            <cal:ActionMessage MethodName="SelectedRowsChangeEvent">

                <cal:Parameter Value="$eventArgs" />

            </cal:ActionMessage>

        </i:EventTrigger>

    </i:Interaction.Triggers>

</DataGrid>

public void SelectedRowsChangeEvent(SelectionChangedEventArgs e)

{

    foreach (var addedRow in e.AddedRows)

    {

        _selectedRows.Add(addedRow as RowViewModel);

    }



    foreach (var removedRow in e.RemovedRows)

    {

        _selectedRows.Remove(removedRow as RowViewModel);

    }

}

I just wanted to post my solution. In Caliburn micro there is no need to set the source as long as you stay true to the naming convention.

Xaml

<DataGrid x:Name="Rows" SelectionMode="Extended" cal:Message.Attach="[Event SelectionChanged] = [Row_SelectionChanged($eventArgs)]">

C#

public List<MyObject> Rows { get; set; }



public MyObject SelectedRow { get; set; } //Will be set by Caliburn Micro. No need to use "SelectedItem={...}"



List<MyObject> _selectedObjects = new List<MyObject>();    



public void Row_SelectionChanged(SelectionChangedEventArgs obj)

{

  _selectedObjects.AddRange(obj.AddedItems.Cast<MyObject>());

  obj.RemovedItems.Cast<MyObject>().ToList().ForEach(w => _selectedObjects.Remove(w));

}

Both solutions posted here work fine but they rely on adding a view (wpf) assembly in your viewmodel because of the "SelectionChangedEventArgs" property. This, i think, is not good for cross platform solutions in case you intend to reuse the viewmodels in different platforms.

So, i'm posting my solution that it's more in line with the MVVM pattern. I'm using syncfusion SfDataGrid in this example but this should work fine with a normal DataGrid:

First we need to extend the DataGrid class, so we create a class. I named it "CustomSfDataGrid.cs". Note that i'm also subscribing to the SelectionChanged event and just obtaining the data directly from the "SelectedItems" property.

using System.Windows;

using Caliburn.Micro;

using Syncfusion.UI.Xaml.Grid;



namespace DesktopClient.WPF.Controls

{

    public class CustomSfDataGrid : SfDataGrid

    {

        ///Bindable collection of objects property linked to the DependencyProperty called: "CustomSelectedItems"

        ///We can use "CustomSelectedItems" as a Binding Property in WPF

        public BindableCollection<object> CustomSelectedItems

        {

            get

            {

                return (BindableCollection<object>)GetValue(CustomSelectedItemsProperty);

            }

            set

            {

                SetValue(CustomSelectedItemsProperty, value);

            }

        }



        // Using a DependencyProperty as the backing store for SelectedItem.  This enables animation, styling, binding, etc...

        public static readonly DependencyProperty CustomSelectedItemsProperty = DependencyProperty.Register("CustomSelectedItems", typeof(BindableCollection<object>), typeof(CustomSfDataGrid), new PropertyMetadata(null));



        public CustomSfDataGrid()

        {

            SelectionChanged += CustomSfDataGrid_SelectionChanged;

        }



        private void CustomSfDataGrid_SelectionChanged(object sender, GridSelectionChangedEventArgs e)

        {

            this.CustomSelectedItems = new BindableCollection<object>(this.SelectedItems);

        }

    }

}

In the .xaml file i added a header called "custom" that is pointing to the namespace of my "CustomSfDataGrid.cs". Then, i'm binding the new "CustomSelectedItems" property to "MyViewModelProperty". Finally, i'm using the "SelectionChanged" event.

<UserControl

    xmlns:syncfusion="http://schemas.syncfusion.com/wpf"

    xmlns:cal="http://www.caliburnproject.org"

    xmlns:custom="clr-namespace:DesktopClient.WPF.Controls">

    <Grid>

        <custom:CustomSfDataGrid x:Name="dataGrid" ItemsSource="{Binding Models}" 

                                    SelectionMode="Extended" SelectionChanged="OnSelectionChanged"

                                    CustomSelectedItems="{Binding MyViewModelProperty, Mode=OneWayToSource}">

            <syncfusion:SfDataGrid.Columns>

                <!-- Column Schema -->

            </syncfusion:SfDataGrid.Columns>

        </custom:CustomSfDataGrid>

    </Grid>

Finally, in the ViewModel i have a "BindableCollection" property.

using using System.Linq;

//

//...

        private BindableCollection<object> _myViewModelProperty;



        public BindableCollection<object> MyViewModelProperty

        {

            get

            {

                return _myViewModelProperty;

            }

            set

            {

                _myViewModelProperty = value;

            }

        }



        //

        public void UsingMyViewModel()

        {

            //cast the collection of objects to a different type using linq

            BindableCollection<MyCastedType> x = new BindableCollection<BrandModel>(MyViewModelProperty.OfType<BrandModel>());



            //alternative casting method

            BindableCollection<MyCastedType> y = new BindableCollection<MyCastedType>();

            foreach (var item in MyViewModelProperty)

            {

                y.Add(item as MyCastedType);

            }

        }