IValueConverter.Convert(Object, TypeName, Object, String) Metodo

Riferimento

Definizione

Spazio dei nomi:: Windows.UI.Xaml.Data

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Modifica

Modifica i dati di origine prima di passarlo alla destinazione per la visualizzazione nell'interfaccia utente.

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

Parametri

value: Object
Platform::Object

IInspectable

I dati di origine passati alla destinazione.

targetType: TypeName Type

Tipo della proprietà di destinazione, come riferimento al tipo (System.Type per Microsoft .NET, uno struct helper TypeName per C++/CX e C++/WinRT).

parameter: Object
Platform::Object

IInspectable

Parametro facoltativo da usare nella logica del convertitore.

language: String
Platform::String

winrt::hstring

Lingua della conversione.

Restituisce

Object

Platform::Object

IInspectable

Valore da passare alla proprietà di dipendenza di destinazione.

Esempio

Nell'esempio seguente viene illustrato come implementare il metodo Convert usando i parametri del parametro e del linguaggio .

//
// 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

Commenti

Il parametro targetType del metodo Convert usa tecniche diverse per segnalare le informazioni di sistema del tipo, a seconda che si stia programmando con Microsoft .NET o C++.

Per Microsoft .NET, questo parametro passa un'istanza del tipo System.Type .
Per C++/CX e C++/WinRT, questo parametro passa un valore di struttura TypeName . TypeName::Kind contiene il nome stringa semplice del tipo, simile a Microsoft . NET è Type.Name. Quando il convertitore viene richiamato dal motore di associazione, il valore targetType viene passato cercando il tipo di proprietà della proprietà di dipendenza di destinazione. È possibile usare questo valore nell'implementazione converte per uno dei due motivi seguenti:
Il convertitore ha l'aspettativa che restituisca sempre oggetti di un tipo specifico e si vuole verificare che l'associazione per cui viene chiamato il convertitore usi correttamente il convertitore. In caso contrario, è possibile restituire un valore di fallback o generare un'eccezione (ma vedere "Eccezioni dai convertitori" di seguito).
Il convertitore può restituire più di un tipo e si vuole che l'utilizzo informi il convertitore quale tipo deve restituire. Ad esempio, è possibile implementare una conversione da oggetto a oggetto e una conversione da oggetto a stringa all'interno dello stesso codice convertitore.

il linguaggio proviene dal valore ConverterLanguage di un'associazione specifica, non dai valori di sistema, quindi si dovrebbe aspettare che possa essere una stringa vuota.

il parametro proviene dal valore ConverterParameter di un'associazione specifica ed è null per impostazione predefinita. Se il convertitore usa i parametri per modificare ciò che restituisce, questo richiede in genere una convenzione per convalidare ciò che viene passato dall'associazione e gestito dal convertitore. Una convenzione comune consiste nel passare stringhe che consentono al convertitore di passare stringhe che comportano valori restituiti diversi. Ad esempio, è possibile che siano disponibili modalità "Simple" e "Verbose" che restituiscono stringhe di lunghezza diverse appropriate per la visualizzazione in diversi tipi di controllo dell'interfaccia utente e layout.

Eccezioni dai convertitori

Il motore di associazione dati non rileva eccezioni generate da un convertitore fornito dall'utente. Qualsiasi eccezione generata dal metodo Convert o eventuali eccezioni non eseguite generate dai metodi che chiamano il metodo Convert vengono considerati errori di runtime. Se si usa il convertitore in situazioni in cui l'associazione può usare fallback o in caso contrario mostrare risultati ragionevoli anche se si verifica un errore di conversione, prendere in considerazione la restituzione del convertitore DependencyProperty.UnsetValue e non generare eccezioni. DependencyProperty.UnsetValue è un valore sentinel che ha un significato speciale nel sistema delle proprietà di dipendenza e le associazioni passate a questo valore useranno FallbackValue.

Un'altra alternativa alla generazione di eccezioni consiste nel restituire il valore originale invariato e consentire all'istanza di associazione di gestire ciò che potrebbe fare con tale valore . Nella maggior parte dei casi, le associazioni dell'interfaccia utente che non hanno esito negativo non saranno casi di errore. Non useranno solo il valore di origine e useranno invece DependencyProperty.UnsetValue per visualizzare nulla o usare i fallback.

try/catch in base all'esecuzione di un valore è un modello di implementazione comune per il metodo Convert, ma non è consigliabile rethrow, per i motivi indicati in precedenza.

Per un esempio che illustra come implementare il metodo Convert usando i parametri del parametro e del linguaggio , vedere l'interfaccia IValueConverter .

Si applica a