WPF ListView - détecter lorsque l'élément sélectionné est cliqué

Utiliser la ListView.ItemContainerStyle bien pour donner à votre ListViewItems un EventSetter qui va gérer l'PreviewMouseLeftButtonDown événement. Ensuite, dans le gestionnaire, vérifier pour voir si l'élément sélectionné est sélectionné.

XAML:

<ListView ItemsSource={Binding MyItems}>
    <ListView.View>
        <GridView>
            <!-- declare a GridViewColumn for each property -->
        </GridView>
    </ListView.View>
    <ListView.ItemContainerStyle>
        <Style TargetType="ListViewItem">
            <EventSetter Event="PreviewMouseLeftButtonDown" Handler="ListViewItem_PreviewMouseLeftButtonDown" />
        </Style>
    </ListView.ItemContainerStyle>
</ListView>

Code-behind:

private void ListViewItem_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    var item = sender as ListViewItem;
    if (item != null && item.IsSelected)
    {
        //Do your stuff
    }
}

Ce sont toutes d'excellentes suggestions, mais si j'étais vous, je voudrais faire cela dans votre modèle de vue. À l'intérieur de votre modèle d'affichage, vous pouvez créer un relais de commande que vous pouvez ensuite lier à l'événement click dans votre modèle d'élément. Pour déterminer si le même élément a été sélectionné, vous pouvez stocker une référence à l'objet sélectionné dans votre modèle de vue. J'aime utiliser MVVM Light pour gérer la liaison. Cela permet à votre projet de bien plus facile à modifier dans l'avenir, et permet de définir la liaison dans le Mélange.

Quand tout est dit et fait, votre XAML ressemblera à ce que Sergey suggéré. Je voudrais éviter d'utiliser le code-behind dans votre point de vue. Je vais éviter d'écrire du code dans cette réponse, car il ya une tonne d'exemples.

Voici un:
Comment utiliser RelayCommand avec le framework MVVM Light

Si vous avez besoin d'un exemple, s'il vous plaît commentaire, et je vais en ajouter un.

~Acclamations

J'ai dit que je n'allais pas faire un exemple, mais je le suis. Ici vous allez.

1) Dans votre projet, ajoutez MVVM Light Uniquement les Bibliothèques.

2) Créer une classe pour votre point de vue. En général, vous avez un modèle d'affichage pour chaque vue (view: MainWindow.xaml && viewModel: MainWindowViewModel.cs)

3) Voici le code pour la très, très, très vue de base modèle:

Tout inclus de l'espace de noms (si elles se présentent ici, je suis en supposant que vous avez déjà ajouté la référence à eux. MVVM Light est Nuget)

using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.CommandWpf;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

Maintenant ajouter une base de classe public:

///<summary>
///Very basic model for example
///</summary>
public class BasicModel 
{
    public string Id { get; set; }
    public string Text { get; set; }

    ///<summary>
    ///Constructor
    ///</summary>
    ///<param name="text"></param>
    public BasicModel(string text)
    {
        this.Id = Guid.NewGuid().ToString();
        this.Text = text;
    }
}

Maintenant créer votre viewmodel:

public class MainWindowViewModel : ViewModelBase
{
    public MainWindowViewModel()
    {
        ModelsCollection = new ObservableCollection<BasicModel>(new List<BasicModel>() {
            new BasicModel("Model one")
            , new BasicModel("Model two")
            , new BasicModel("Model three")
        });
    }

    private BasicModel _selectedBasicModel;

    ///<summary>
    ///Stores the selected mode.
    ///</summary>
    ///<remarks>This is just an example, may be different.</remarks>
    public BasicModel SelectedBasicModel 
    {
        get { return _selectedBasicModel; }
        set { Set(() => SelectedBasicModel, ref _selectedBasicModel, value); }
    }

    private ObservableCollection<BasicModel> _modelsCollection;

    ///<summary>
    ///List to bind to
    ///</summary>
    public ObservableCollection<BasicModel> ModelsCollection
    {
        get { return _modelsCollection; }
        set { Set(() => ModelsCollection, ref _modelsCollection, value); }
    }        
}

Dans votre viewmodel, ajouter un relaycommand. Veuillez noter que j'ai fait ce async et qu'il avait passer un paramètre.

    private RelayCommand<string> _selectItemRelayCommand;
    ///<summary>
    ///Relay command associated with the selection of an item in the observablecollection
    ///</summary>
    public RelayCommand<string> SelectItemRelayCommand
    {
        get
        {
            if (_selectItemRelayCommand == null)
            {
                _selectItemRelayCommand = new RelayCommand<string>(async (id) =>
                {
                    await selectItem(id);
                });
            }

            return _selectItemRelayCommand;
        }
        set { _selectItemRelayCommand = value; }
    }

    ///<summary>
    ///I went with async in case you sub is a long task, and you don't want to lock you UI
    ///</summary>
    ///<returns></returns>
    private async Task<int> selectItem(string id)
    {
        this.SelectedBasicModel = ModelsCollection.FirstOrDefault(x => x.Id == id);
        Console.WriteLine(String.Concat("You just clicked:", SelectedBasicModel.Text));
        //Do async work

        return await Task.FromResult(1);
    }

Dans le code-behind pour vous d'afficher, de créer une propriété pour vous viewmodel et définissez le datacontext de la vue, pour le viewmodel (veuillez noter, il y a d'autres façons de le faire, mais je suis en train de faire ce simple exemple.)

public partial class MainWindow : Window
{
    public MainWindowViewModel MyViewModel { get; set; }
    public MainWindow()
    {
        InitializeComponent();

        MyViewModel = new MainWindowViewModel();
        this.DataContext = MyViewModel;
    }
}

Dans votre XAML, vous devez ajouter des espaces de noms en haut de votre code

<Window x:Class="Basic_Binding.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
    xmlns:Custom="clr-namespace:GalaSoft.MvvmLight;assembly=GalaSoft.MvvmLight"
    Title="MainWindow" Height="350" Width="525">

J'ai ajouté "je" et "Personnalisé".

Voici la liste:

<ListView 
        Grid.Row="0" 
        Grid.Column="0" 
        HorizontalContentAlignment="Stretch"
        ItemsSource="{Binding ModelsCollection}"
        ItemTemplate="{DynamicResource BasicModelDataTemplate}">
    </ListView>

Ici est l'ItemTemplate pour la liste:

<DataTemplate x:Key="BasicModelDataTemplate">
        <Grid>
            <TextBlock Text="{Binding Text}">
                <i:Interaction.Triggers>
                    <i:EventTrigger EventName="MouseLeftButtonUp">
                        <i:InvokeCommandAction 
                            Command="{Binding DataContext.SelectItemRelayCommand, 
                                RelativeSource={RelativeSource FindAncestor, 
                                        AncestorType={x:Type ItemsControl}}}"
                            CommandParameter="{Binding Id}">                                
                        </i:InvokeCommandAction>
                    </i:EventTrigger>
                </i:Interaction.Triggers>
            </TextBlock>
        </Grid>
    </DataTemplate>

Exécuter votre application, et de vérifier la fenêtre de sortie. Vous pouvez utiliser un convertisseur pour gérer le style de l'élément sélectionné.

Cela peut sembler très compliqué, mais il rend la vie beaucoup plus facile en bas de la route lorsque vous avez besoin de séparer votre point de vue à partir de votre ViewModel (par exemple, développer un ViewModel pour de multiples plates-formes.) En outre, il permet de travailler dans le Mélange 10x plus facile. Une fois que vous développer votre ViewModel, vous pouvez le remettre à un designer qui peut le faire paraître très arty :). MVVM Light ajoute certaines fonctionnalités pour rendre le Mélange reconnaître votre ViewModel. Pour la plupart, vous pouvez faire à peu près tout ce que vous voulez dans le ViewModel affecter la vue.

Si quelqu'un lit ce, j'espère que vous trouverez ce utile. Si vous avez des questions, s'il vous plaît laissez-moi savoir. J'ai utilisé MVVM Light dans cet exemple, mais vous pouvez le faire sans MVVM Light.

~Acclamations

Je vous suggère aussi de la désélection d'un élément, après qu'il a été cliqué et utiliser le MouseDoubleClick événement

private void listBox_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
    try {
        //Do your stuff here
        listBox.SelectedItem = null;
        listBox.SelectedIndex = -1;
    } catch (Exception ex) {
        System.Diagnostics.Debug.WriteLine(ex.Message);
    }
}