IValueConverter Interfaccia

Riferimento

Definizione

Spazio dei nomi:: Microsoft.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

Espone i metodi che consentono di modificare i dati man mano che passano attraverso il motore di associazione.

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

Derivato: Microsoft.UI.Xaml.Controls.Primitives.CornerRadiusFilterConverter

Microsoft.UI.Xaml.Controls.Primitives.CornerRadiusToThicknessConverter

Microsoft.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter

Microsoft.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter

Attributi: ContractVersionAttribute GuidAttribute

Esempio

Nell'esempio seguente viene illustrato come implementare l'interfaccia IValueConverter e usare il convertitore quando si esegue il data binding a una raccolta di oggetti.

Nota

Se usi C++/WinRT (o C++/CX), vedi Formattazione o conversione dei valori di dati per la visualizzazione per altri esempi di codice relativi alla creazione di un convertitore di valori personalizzato. Questo argomento illustra anche come usare l'attributo ConverterParameter con le funzioni di formattazione delle stringhe 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();
        }
    }
}

Commenti

È possibile creare una classe che consente di convertire il formato dei dati tra l'origine e la destinazione ereditando da IValueConverter. Ad esempio, potrebbe essere necessario avere un elenco di colori archiviati come valori RGBA , ma visualizzarli con nomi di colore nell'interfaccia utente. Implementando Convert e ConvertBack, è possibile modificare il formato dei valori dei dati man mano che vengono passati tra la destinazione e l'origine dal motore di associazione. È consigliabile implementare sempre Converti con un'implementazione funzionale, ma è piuttosto comune implementare ConvertBack in modo che restituisca un'eccezione non implementata. È necessario un metodo ConvertBack nel convertitore solo se si usa il convertitore per le associazioni bidirezionali o se si usa XAML per la serializzazione.

UnsetValue deve essere restituito da un'implementazione IValueConverter che fornisce la conversione in un data binding in una proprietà di dipendenza, in qualsiasi caso in cui il convertitore non è in grado di convertire un valore di origine. I convertitori non devono generare eccezioni per quel caso in Converti; queste verranno visualizzate come eccezioni in fase di esecuzione che è necessario aggiungere la gestione per in UnhandledException o peggio ancora appaiono agli utenti come eccezioni di runtime effettive. Le implementazioni del convertitore devono seguire il modello di associazione generale che qualsiasi associazione non riuscita non esegue alcuna operazione e non fornisce un valore e UnsetValue anziché Null è il valore sentinel per quel caso che il motore di associazione riconosce. Per altre info, vedi Informazioni approfondite sul data binding.

Nota

Per eseguire il binding dei dati a un convertitore di valori personalizzato scritto nelle estensioni del componente Visual C++ (C++/CX), il file di intestazione in cui è definita la classe di implementazione IValueConverter deve essere incluso, direttamente o indirettamente, in uno dei file code-behind. Per altre informazioni, vedi Creare il primo usando C++.

Suggerimento

Alcuni dei modelli di progetto predefiniti per un'app UWP includono una classe helper BooleanToVisibilityConverter. Questa classe è un'implementazione IValueConverter che gestisce uno scenario comune di controllo personalizzato in cui si usano valori booleani della classe della logica di controllo per impostare il valore Visibility nei modelli di controllo XAML.

Note sulla migrazione

Nella Windows Runtime i parametri del linguaggio per i metodi IValueConverter usano stringhe, anziché usare oggetti CultureInfo come fanno nelle definizioni Windows Presentation Foundation (WPF) e Microsoft Silverlight dell'interfaccia.

Metodi

Convert(Object, TypeName, Object, String)	Modifica i dati di origine prima di passarlo alla destinazione per la visualizzazione nell'interfaccia utente.
ConvertBack(Object, TypeName, Object, String)	Modifica i dati di destinazione prima di passarlo all'oggetto di origine. Questo metodo viene chiamato solo nelle associazioni TwoWay .

Si applica a

Condividi tramite