IValueConverter.Convert(Object, TypeName, Object, String) Méthode

public:
 Platform::Object ^ Convert(Platform::Object ^ value, TypeName targetType, Platform::Object ^ parameter, Platform::String ^ language);

IInspectable Convert(IInspectable const& value, TypeName const& targetType, IInspectable const& parameter, winrt::hstring const& language);

public object Convert(object value, System.Type targetType, object parameter, string language);

function convert(value, targetType, parameter, language)

Public Function Convert (value As Object, targetType As Type, parameter As Object, language As String) As Object

Paramètres

Retours

Valeur à passer à la propriété de dépendance cible.

Exemples

L’exemple suivant montre comment implémenter la méthode Convert à l’aide des paramètres de paramètre et de langage .

//
// 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();
        }
    }
}

Imports System.Collections.ObjectModel
Imports System.Windows.Data
Imports System.Globalization

Partial Public Class Page
    Inherits UserControl

    Public MyMusic As New ObservableCollection(Of Recording)()
    Public Sub New()
        InitializeComponent()

        ' Add items to the collection.
        MyMusic.Add(New Recording("Sheryl Crow", "Detours", New DateTime(2008, 2, 5)))
        MyMusic.Add(New Recording("Brandi Carlisle", "The Story", New DateTime(2007, 4, 3)))
        MyMusic.Add(New Recording("Patty Griffin", "Children Running Through", New DateTime(2007, 2, 6)))

        ' Set the data context for the combo box.
        MusicCombo.DataContext = MyMusic
    End Sub
End Class

' Simple business object. 
Public Class Recording
    Public Sub New()
    End Sub
    Public Sub New(ByVal artistName As String, ByVal cdName As String, _
       ByVal release As DateTime)
        Artist = artistName
        Name = cdName
        ReleaseDate = release
    End Sub
    Private artistValue As String
    Private nameValue As String
    Private releaseDateValue As DateTime
    Public Property Artist() As String
        Get
            Return artistValue
        End Get
        Set(ByVal value As String)
            artistValue = value
        End Set
    End Property
    Public Property Name() As String
        Get
            Return nameValue
        End Get
        Set(ByVal value As String)
            nameValue = value
        End Set
    End Property
    Public Property ReleaseDate() As DateTime
        Get
            Return releaseDateValue
        End Get
        Set(ByVal value As DateTime)
            releaseDateValue = value
        End Set
    End Property
End Class

Public Class DateFormatter
    Implements IValueConverter

    ' This converts the DateTime object to the string to display. 
    Public Function Convert(ByVal value As Object, ByVal targetType As Type, _
        ByVal parameter As Object, ByVal language As System.String) As Object _
        Implements IValueConverter.Convert

        ' Retrieve the format string and use it to format the value. 
        Dim formatString As String = TryCast(parameter, String)
        If Not String.IsNullOrEmpty(formatString) Then

            Return String.Format(New CultureInfo(language), formatString, value)
        End If

        ' If the format string is null or empty, simply call ToString() 
        ' on the value. 
        Return value.ToString()
    End Function

    ' No need to implement converting back on a one-way binding.
    Public Function ConvertBack(ByVal value As Object, ByVal targetType As Type, _
        ByVal parameter As Object, _
        ByVal language As System.String) As Object _
        Implements IValueConverter.ConvertBack
        Throw New NotImplementedException()
    End Function
End Class

Remarques

Le paramètre targetType de la méthode Convert utilise différentes techniques pour signaler les informations système de type, selon que vous programmez avec Microsoft .NET ou C++.

• Pour Microsoft .NET, ce paramètre transmet une instance du type System.Type.
• Pour C++/CX et C++/WinRT, ce paramètre transmet une valeur de structure TypeName . TypeName::Kindcontient le nom de chaîne simple du type, similaire à Microsoft . net.Type.Name Lorsque le convertisseur est appelé par le moteur de liaison, la valeur targetType est passée en recherchant le type de propriété de la propriété de dépendance cible. Vous pouvez utiliser cette valeur dans votre implémentation Convert pour l’une des deux raisons suivantes :
• Votre convertisseur s’attend à ce qu’il retourne toujours des objets d’un type spécifique, et vous souhaitez vérifier que la liaison pour laquelle le convertisseur est appelé utilise correctement le convertisseur. Si ce n’est pas le cas, vous pouvez retourner une valeur de secours ou lever une exception (mais voir « Exceptions des convertisseurs » ci-dessous).
• Votre convertisseur peut retourner plusieurs types, et vous souhaitez que l’utilisation indique à votre convertisseur le type qu’il doit retourner. Par exemple, vous pouvez implémenter une conversion objet-objet et une conversion objet-chaîne dans le même code de convertisseur.

la langue provient de la valeur ConverterLanguage d’une liaison spécifique, et non des valeurs système. Vous devez donc vous attendre à ce qu’il s’agit d’une chaîne vide.

Le paramètre provient de la valeur ConverterParameter d’une liaison spécifique et a la valeur Null par défaut. Si votre convertisseur utilise des paramètres pour modifier ce qu’il retourne, cela nécessite généralement une convention pour valider ce qui est passé par la liaison et géré par le convertisseur. Une convention courante consiste à passer des chaînes qui nomment les modes de votre convertisseur qui entraînent des valeurs de retour différentes. Par exemple, vous pouvez avoir des modes « Simple » et « Détaillé » qui retournent des chaînes de longueur différentes qui conviennent chacune à l’affichage dans différents types de contrôles et dispositions d’interface utilisateur.

Exceptions des convertisseurs

Le moteur de liaison de données n’intercepte pas les exceptions levées par un convertisseur fourni par l’utilisateur. Toute exception levée par la méthode Convert, ou toute exception non interceptée levée par des méthodes appelées par la méthode Convert, sont traitées comme des erreurs d’exécution. Si vous utilisez le convertisseur dans des situations où la liaison peut utiliser des secours ou afficher des résultats raisonnables même si un échec de conversion se produit, envisagez de demander à votre convertisseur de retourner DependencyProperty.UnsetValue et de ne pas lever d’exceptions. DependencyProperty.UnsetValue est une valeur sentinelle qui a une signification particulière dans le système de propriétés de dépendance, et les liaisons qui sont passées à cette valeur utilisent FallbackValue.

Une autre alternative à la levée d’exceptions consiste à retourner la valeur d’origine inchangée et à laisser la liaison instance gérer ce qu’elle peut faire avec cette valeur. Dans la plupart des cas, les liaisons d’interface utilisateur qui échouent ne sont pas des cas d’erreur. Ils n’utilisent simplement pas la valeur source et utilisent plutôt DependencyProperty.UnsetValue pour ne rien afficher ou utiliser des secours.

try/catch basé sur l’exécution d’une valeur est un modèle d’implémentation courant pour la méthode Convert, mais vous ne devez pas rethrow, pour les raisons mentionnées ci-dessus.

Pour obtenir un exemple montrant comment implémenter la méthode Convert à l’aide du paramètre et des paramètres de langage , consultez l’interface IValueConverter .

S’applique à

Voir aussi

• ConvertBack(Object, TypeName, Object, String)
• Exemple de liaison de données XAML
• Présentation détaillée de la liaison de données