IValueConverter Interface

Référence

Définition

Espace de noms:: Microsoft.UI.Xaml.Data

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Modifier

Expose des méthodes qui permettent de modifier les données à mesure qu’elles passent par le moteur de liaison.

public interface class IValueConverter

/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.UI.Xaml.WinUIContract, 65536)]
/// [Windows.Foundation.Metadata.Guid(2950507519, 4341, 20851, 183, 192, 53, 144, 189, 150, 203, 53)]
struct IValueConverter

[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.Guid(2950507519, 4341, 20851, 183, 192, 53, 144, 189, 150, 203, 53)]
public interface IValueConverter

Public Interface IValueConverter

Dérivé: Microsoft.UI.Xaml.Controls.Primitives.CornerRadiusFilterConverter

Microsoft.UI.Xaml.Controls.Primitives.CornerRadiusToThicknessConverter

Microsoft.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter

Microsoft.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter

Attributs: ContractVersionAttribute GuidAttribute

Exemples

L’exemple suivant montre comment implémenter l’interface IValueConverter et utiliser le convertisseur lors de la liaison de données à une collection d’objets.

Notes

Si vous utilisez C++/WinRT (ou C++/CX), consultez Mise en forme ou conversion de valeurs de données pour l’affichage pour obtenir d’autres exemples de code de création de votre propre convertisseur de valeurs. Cette rubrique explique également comment utiliser l’attribut ConverterParameter avec les fonctions de mise en forme de chaîne C++.

<UserControl x:Class="ConverterParameterEx.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:local="using:ConverterParameterEx" 
    Width="400" Height="300">
    <Grid x:Name="LayoutRoot" >
        <Grid.Resources>
           <local:DateFormatter x:Key="FormatConverter" />
        </Grid.Resources>
        
        <ComboBox Height="60" Width="250" x:Name="MusicCombo" 
            ItemsSource="{Binding}">
            <ComboBox.ItemTemplate>
                <DataTemplate>
                    <StackPanel>
                        <TextBlock FontWeight="Bold" Text="{Binding Path=Name, Mode=OneWay}" />
                        <TextBlock Text="{Binding Path=Artist, Mode=OneWay}" />
                        <TextBlock Text="{Binding Path=ReleaseDate, Mode=OneWay,
                            Converter={StaticResource FormatConverter}, 
                            ConverterParameter=\{0:d\}}" />
                   </StackPanel>
                </DataTemplate>
            </ComboBox.ItemTemplate>
        </ComboBox>
    </Grid>
</UserControl>

//
// MainPage.xaml.h
// Declaration of the MainPage class.
// 

#pragma once

#include "MainPage.g.h"

namespace IValueConverterExample
{

    // Simple business object.
    [Windows::UI::Xaml::Data::Bindable]
    public ref class Recording sealed 
    {
    public: 
        Recording (Platform::String^ artistName, Platform::String^ cdName, Windows::Foundation::DateTime release)
        {
            Artist = artistName;
            Name = cdName;
            ReleaseDate = release;
        }
        property Platform::String^ Artist;
        property Platform::String^ Name;
        property Windows::Foundation::DateTime ReleaseDate;
    };

    public ref class DateFormatter  sealed : Windows::UI::Xaml::Data::IValueConverter 
    {
        // This converts the DateTime object to the Platform::String^ to display.
    public:
        virtual Platform::Object^ Convert(Platform::Object^ value, Windows::UI::Xaml::Interop::TypeName targetType, 
            Platform::Object^ parameter, Platform::String^ language)
        {
            Windows::Foundation::DateTime dt = safe_cast<Windows::Foundation::DateTime>(value); 
            Windows::Globalization::DateTimeFormatting::DateTimeFormatter^ dtf =
                Windows::Globalization::DateTimeFormatting::DateTimeFormatter::ShortDate;
            return dtf->Format(dt); 
        }

        // No need to implement converting back on a one-way binding 
        virtual Platform::Object^ ConvertBack(Platform::Object^ value, Windows::UI::Xaml::Interop::TypeName targetType, 
            Platform::Object^ parameter, Platform::String^ language)
        {
            throw ref new Platform::NotImplementedException();
        }
    };

    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public ref class MainPage sealed
    {
    public:
        MainPage()
        {	
            m_myMusic = ref new Platform::Collections::Vector<Recording^>();

            // Add items to the collection.

            // You can use a Calendar object to create a Windows::Foundation::DateTime
            auto c = ref new Windows::Globalization::Calendar();
            c->Year = 2008;
            c->Month = 2;
            c->Day = 5;
            m_myMusic->Append(ref new Recording("Chris Sells", "Chris Sells Live",
                c->GetDateTime()));

            c->Year = 2007;
            c->Month = 4;
            c->Day = 3;
            m_myMusic->Append(ref new Recording("Luka Abrus",
                "The Road to Redmond", c->GetDateTime()));
            
            c->Year = 2007;
            c->Month = 2;
            c->Day = 3;
            m_myMusic->Append(ref new Recording("Jim Hance",
                "The Best of Jim Hance", dt));
            InitializeComponent();

            // Set the data context for the combo box.
            MusicCombo->DataContext = m_myMusic;	
        }


    protected:
        virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override;

    private:
        Windows::Foundation::Collections::IVector<Recording^>^ m_myMusic;
    };
}

using System;
using System.Collections.ObjectModel;
using System.Globalization;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Data;

namespace ConverterParameterEx
{
    public partial class Page : UserControl
    {

        public ObservableCollection<Recording> MyMusic =
            new ObservableCollection<Recording>();
        public Page()
        {
            InitializeComponent();

            // Add items to the collection.
            MyMusic.Add(new Recording("Chris Sells", "Chris Sells Live",
                new DateTime(2008, 2, 5)));
            MyMusic.Add(new Recording("Luka Abrus",
                "The Road to Redmond", new DateTime(2007, 4, 3)));
            MyMusic.Add(new Recording("Jim Hance",
                "The Best of Jim Hance", new DateTime(2007, 2, 6)));

            // Set the data context for the combo box.
            MusicCombo.DataContext = MyMusic;
        }
    }

    // Simple business object.
    public class Recording
    {
        public Recording() { }
        public Recording(string artistName, string cdName, DateTime release)
        {
            Artist = artistName;
            Name = cdName;
            ReleaseDate = release;
        }
        public string Artist { get; set; }
        public string Name { get; set; }
        public DateTime ReleaseDate { get; set; }
    }

    public class DateFormatter : IValueConverter
    {
        // This converts the DateTime object to the string to display.
        public object Convert(object value, Type targetType, 
            object parameter, string language)
        {
            // Retrieve the format string and use it to format the value.
            string formatString = parameter as string;
            if (!string.IsNullOrEmpty(formatString))
            {
                return string.Format(
                    new CultureInfo(language), formatString, value);
            }
            // If the format string is null or empty, simply call ToString()
            // on the value.
            return value.ToString();
        }

        // No need to implement converting back on a one-way binding 
        public object ConvertBack(object value, Type targetType, 
            object parameter, string language)
        {
            throw new NotImplementedException();
        }
    }
}

Remarques

Vous pouvez créer une classe qui vous permet de convertir le format de vos données entre la source et la cible en héritant de IValueConverter. Par exemple, vous souhaiterez peut-être avoir une liste de couleurs que vous stockez sous forme de valeurs RVBA , mais qui s’affichent avec des noms de couleurs dans l’interface utilisateur. En implémentant Convert et ConvertBack, vous pouvez modifier le format des valeurs de données à mesure qu’elles sont passées entre la cible et la source par le moteur de liaison. Vous devez toujours implémenter Convert avec une implémentation fonctionnelle, mais il est assez courant d’implémenter ConvertBack afin qu’il signale une exception non implémentée. Vous n’avez besoin d’une méthode ConvertBack dans votre convertisseur que si vous utilisez le convertisseur pour les liaisons bidirectionnelle ou si vous utilisez XAML pour la sérialisation.

UnsetValue doit être retourné à partir d’une implémentation IValueConverter qui fournit la conversion d’une liaison de données en propriété de dépendance, dans tous les cas où le convertisseur ne peut pas convertir une valeur source. Les convertisseurs ne doivent pas lever d’exceptions pour ce cas dans Convert ; celles-ci apparaissent sous forme d’exceptions au moment de l’exécution pour lesquelles vous devez ajouter une gestion dans UnhandledException ou pire encore apparaissent pour les utilisateurs comme des exceptions d’exécution réelles. Les implémentations de convertisseur doivent suivre le modèle de liaison général que toute liaison ayant échoué ne fait rien et ne fournit pas de valeur, et UnsetValue plutôt que null est la valeur sentinelle pour ce cas que le moteur de liaison comprend. Pour plus d’informations, voir Présentation détaillée de la liaison de données.

Notes

Pour lier des données à un convertisseur de valeurs personnalisé écrit dans des extensions de composant Visual C++ (C++/CX), le fichier d’en-tête dans lequel la classe d’implémentation IValueConverter est définie doit être inclus, directement ou indirectement, dans l’un des fichiers code-behind. Pour plus d’informations, consultez Créer votre première à l’aide de C++.

Conseil

Certains des modèles de projet par défaut pour une application UWP incluent une classe d’assistance BooleanToVisibilityConverter. Cette classe est une implémentation IValueConverter qui gère un scénario de contrôle personnalisé courant dans lequel vous utilisez des valeurs booléennes de votre classe logique de contrôle pour définir la valeur Visibility dans les modèles de contrôle XAML.

Notes de migration

Dans le Windows Runtime, les paramètres de langage pour les méthodes IValueConverter utilisent des chaînes, au lieu d’utiliser des objets CultureInfo comme ils le font dans les définitions Windows Presentation Foundation (WPF) et Microsoft Silverlight de l’interface.

Méthodes

Convert(Object, TypeName, Object, String)	Modifie les données sources avant de les transmettre à la cible pour affichage dans l’interface utilisateur.
ConvertBack(Object, TypeName, Object, String)	Modifie les données cibles avant de les transmettre à l’objet source. Cette méthode est appelée uniquement dans les liaisons TwoWay .

S’applique à

Partager via