IValueConverter Schnittstelle

Referenz

Definition

Namespace:: Windows.UI.Xaml.Data

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Bearbeiten

Macht Methoden verfügbar, mit denen die Daten geändert werden können, während sie das Bindungsmodul durchlaufen.

public interface class IValueConverter

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.Guid(3874684656, 1810, 18559, 179, 19, 243, 0, 184, 215, 154, 161)]
struct IValueConverter

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.Guid(3874684656, 1810, 18559, 179, 19, 243, 0, 184, 215, 154, 161)]
public interface IValueConverter

Public Interface IValueConverter

Abgeleitet: Windows.UI.Xaml.Controls.Primitives.JumpListItemBackgroundConverter

Windows.UI.Xaml.Controls.Primitives.JumpListItemForegroundConverter

Attribute: ContractVersionAttribute GuidAttribute

Windows-Anforderungen

Gerätefamilie	Windows 10 (eingeführt in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (eingeführt in v1.0)

Beispiele

Das folgende Beispiel zeigt, wie Sie die IValueConverter-Schnittstelle implementieren und den Konverter bei der Datenbindung an eine Sammlung von -Objekten verwenden.

Hinweis

Wenn Sie C++/WinRT (oder C++/CX) verwenden, finden Sie weitere Codebeispiele zum Erstellen eines eigenen Wertkonverters unter Formatieren oder Konvertieren von Datenwerten für die Anzeige . In diesem Thema wird auch erläutert, wie Sie das ConverterParameter-Attribut mit C++-Zeichenfolgenformatierungsfunktionen verwenden können.

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

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

// pch.h
#include <winrt/Windows.Globalization.h>

// MainPage.idl
namespace ConverterParameterEx
{
    [default_interface]
    runtimeclass MainPage : Windows.UI.Xaml.Controls.Page
    {
        MainPage();
    }
}

<!-- MainPage.xaml -->
<Page
    x:Class="ConverterParameterEx.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:ConverterParameterEx"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

    <local:Page/>
</Page>

// MainPage.h
#pragma once

#include "MainPage.g.h"

namespace winrt::ConverterParameterEx::implementation
{
    struct MainPage : MainPageT<MainPage>
    {
        MainPage();
    };
}

namespace winrt::ConverterParameterEx::factory_implementation
{
    struct MainPage : MainPageT<MainPage, implementation::MainPage>
    {
    };
}

// MainPage.cpp
#include "pch.h"
#include "MainPage.h"
#include "MainPage.g.cpp"

using namespace winrt;
using namespace Windows::UI::Xaml;

namespace winrt::ConverterParameterEx::implementation
{
    MainPage::MainPage()
    {
        InitializeComponent();
    }
}

// Page.idl
namespace ConverterParameterEx
{
    [default_interface]
    runtimeclass Page : Windows.UI.Xaml.Controls.UserControl
    {
        Page();
        Windows.Foundation.Collections.IVector<IInspectable> MyMusic{ get; };
    }
}

<!-- Page.xaml -->
<!-- see listing above -->

// Page.h
#pragma once

#include "winrt/Windows.UI.Xaml.h"
#include "winrt/Windows.UI.Xaml.Markup.h"
#include "winrt/Windows.UI.Xaml.Interop.h"
#include "winrt/Windows.UI.Xaml.Controls.Primitives.h"
#include "Page.g.h"
#include "DateFormatter.h"

namespace winrt::ConverterParameterEx::implementation
{
    struct Page : PageT<Page>
    {
        Page();
        Windows::Foundation::Collections::IVector<Windows::Foundation::IInspectable> MyMusic();

    private:
        Windows::Foundation::Collections::IVector<Windows::Foundation::IInspectable> m_myMusic;
    };
}

namespace winrt::ConverterParameterEx::factory_implementation
{
    struct Page : PageT<Page, implementation::Page>
    {
    };
}

// Page.cpp
#include "pch.h"
#include "Page.h"
#if __has_include("Page.g.cpp")
#include "Page.g.cpp"
#endif
#include "Recording.h"

using namespace winrt;
using namespace Windows::UI::Xaml;

namespace winrt::ConverterParameterEx::implementation
{
    Page::Page()
    {
        InitializeComponent();

        std::vector<Windows::Foundation::IInspectable> recordings;

        Windows::Globalization::Calendar releaseDateTime;
        releaseDateTime.Month(7); releaseDateTime.Day(8); releaseDateTime.Year(1748);
        recordings.push_back(winrt::make<Recording>(L"Johann Sebastian Bach", L"Mass in B minor", releaseDateTime));

        releaseDateTime = Windows::Globalization::Calendar{};
        releaseDateTime.Month(11); releaseDateTime.Day(2); releaseDateTime.Year(1805);
        recordings.push_back(winrt::make<Recording>(L"Ludwig van Beethoven", L"Third Symphony", releaseDateTime));

        releaseDateTime = Windows::Globalization::Calendar{};
        releaseDateTime.Month(3); releaseDateTime.Day(12); releaseDateTime.Year(1737);
        recordings.push_back(winrt::make<Recording>(L"George Frideric Handel", L"Serse", releaseDateTime));

        m_myMusic = winrt::single_threaded_observable_vector<Windows::Foundation::IInspectable>(std::move(recordings));

        MusicCombo().DataContext(m_myMusic);
    }

    Windows::Foundation::Collections::IVector<Windows::Foundation::IInspectable> Page::MyMusic() { return m_myMusic; }
}

// Recording.idl
namespace ConverterParameterEx
{
    [bindable]
    runtimeclass Recording
    {
        Recording(String artist, String name, Windows.Globalization.Calendar releaseDate);
        String Artist{ get; };
        String Name{ get; };
        Windows.Globalization.Calendar ReleaseDate{ get; };
    }
}

// Recording.h
#pragma once
#include "Recording.g.h"

namespace winrt::ConverterParameterEx::implementation
{
    struct Recording : RecordingT<Recording>
    {
        Recording() = default;

        Recording(hstring const& artist, hstring const& name, winrt::Windows::Globalization::Calendar const& releaseDate);
        hstring Artist();
        hstring Name();
        winrt::Windows::Globalization::Calendar ReleaseDate();

    private:
        std::wstring m_artist;
        std::wstring m_name;
        Windows::Globalization::Calendar m_releaseDate;
    };
}
namespace winrt::ConverterParameterEx::factory_implementation
{
    struct Recording : RecordingT<Recording, implementation::Recording>
    {
    };
}

// Recording.cpp
#include "pch.h"
#include "Recording.h"
#include "Recording.g.cpp"

namespace winrt::ConverterParameterEx::implementation
{
    Recording::Recording(hstring const& artist, hstring const& name, Windows::Globalization::Calendar const& releaseDate) :
        m_artist{ artist.c_str() },
        m_name{ name.c_str() },
        m_releaseDate{ releaseDate } {}

    hstring Recording::Artist() { return hstring{ m_artist }; }
    hstring Recording::Name() { return hstring{ m_name }; }
    Windows::Globalization::Calendar Recording::ReleaseDate() { return m_releaseDate; }
}

// DateFormatter.idl
namespace ConverterParameterEx
{
    runtimeclass DateFormatter : [default] Windows.UI.Xaml.Data.IValueConverter
    {
        DateFormatter();
    }
}

// DateFormatter.h
#pragma once
#include "DateFormatter.g.h"

namespace winrt::ConverterParameterEx::implementation
{
    struct DateFormatter : DateFormatterT<DateFormatter>
    {
        DateFormatter() = default;

        winrt::Windows::Foundation::IInspectable Convert(winrt::Windows::Foundation::IInspectable const& value, winrt::Windows::UI::Xaml::Interop::TypeName const& targetType, winrt::Windows::Foundation::IInspectable const& parameter, hstring const& language);
        winrt::Windows::Foundation::IInspectable ConvertBack(winrt::Windows::Foundation::IInspectable const& value, winrt::Windows::UI::Xaml::Interop::TypeName const& targetType, winrt::Windows::Foundation::IInspectable const& parameter, hstring const& language);
    };
}
namespace winrt::ConverterParameterEx::factory_implementation
{
    struct DateFormatter : DateFormatterT<DateFormatter, implementation::DateFormatter>
    {
    };
}

// DateFormatter.cpp
#include "pch.h"
#include "DateFormatter.h"
#include "DateFormatter.g.cpp"

namespace winrt::ConverterParameterEx::implementation
{
    winrt::Windows::Foundation::IInspectable DateFormatter::Convert(winrt::Windows::Foundation::IInspectable const& value, winrt::Windows::UI::Xaml::Interop::TypeName const& targetType, winrt::Windows::Foundation::IInspectable const& parameter, hstring const& language)
    {
        // Retrieve the value as a Calendar.
        Windows::Globalization::Calendar valueAsCalendar{ value.as<Windows::Globalization::Calendar>() };

        std::wstringstream wstringstream;
        wstringstream << valueAsCalendar.MonthAsNumericString().c_str();
        wstringstream << L"/" << valueAsCalendar.DayAsString().c_str();
        wstringstream << L"/" << valueAsCalendar.YearAsString().c_str();
        return winrt::box_value(hstring{ wstringstream.str().c_str() });
    }
    winrt::Windows::Foundation::IInspectable DateFormatter::ConvertBack(winrt::Windows::Foundation::IInspectable const& value, winrt::Windows::UI::Xaml::Interop::TypeName const& targetType, winrt::Windows::Foundation::IInspectable const& parameter, hstring const& language)
    {
        throw hresult_not_implemented();
    }
}

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

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

Hinweise

Sie können eine Klasse erstellen, mit der Sie das Format Ihrer Daten zwischen der Quelle und dem Ziel konvertieren können, indem Sie von IValueConverter erben. Beispielsweise können Sie eine Liste von Farben haben, die Sie als RGBA-Werte speichern, aber diese mit Farbnamen auf der Benutzeroberfläche anzeigen. Durch die Implementierung von Convert und ConvertBack können Sie das Format der Datenwerte ändern, während sie vom Bindungsmodul zwischen dem Ziel und der Quelle übergeben werden. Sie sollten Convert immer mit einer funktionalen Implementierung implementieren, aber es ist ziemlich üblich, ConvertBack zu implementieren, damit eine nicht implementierte Ausnahme gemeldet wird. Sie benötigen nur eine ConvertBack-Methode in Ihrem Konverter, wenn Sie den Konverter für bidirektionale Bindungen oder XAML für die Serialisierung verwenden.

UnsetValue sollte von einer IValueConverter-Implementierung zurückgegeben werden, die eine Konvertierung in einer Datenbindung in eine Abhängigkeitseigenschaft bereitstellt, in jedem Fall, wenn der Konverter keinen Quellwert konvertieren kann. Konverter sollten keine Ausnahmen für diesen Fall in Convert auslösen. diese werden als Laufzeitausnahmen angezeigt, für die Sie die Behandlung in UnhandledException hinzufügen müssen oder schlimmer noch für Benutzer als tatsächliche Laufzeitausnahmen erscheinen. Konverterimplementierungen sollten dem allgemeinen Bindungsmuster folgen, dass jede fehlerhafte Bindung nichts bewirkt und keinen Wert bereitstellt, und UnsetValue anstelle von NULL ist der Sentinelwert für diesen Fall, den das Bindungsmodul versteht. Weitere Informationen finden Sie unter Datenbindung im Detail.

Hinweis

Zum Binden von Daten an einen benutzerdefinierten Wertkonverter, der in Visual C++-Komponentenerweiterungen (C++/CX) geschrieben wird, muss die Headerdatei, in der die IValueConverter-Implementierungsklasse definiert ist, direkt oder indirekt in eine der CodeBehind-Dateien eingeschlossen werden. Weitere Informationen finden Sie unter Erstellen Ihres ersten Mithilfe von C++.

Tipp

Zu den Standardprojektvorlagen für eine UWP-App gehört die Hilfsklasse BooleanToVisibilityConverter. Diese Klasse ist eine IValueConverter-Implementierung, die ein allgemeines Szenario mit benutzerdefinierten Steuerelementen behandelt, in dem Sie boolesche Werte aus Ihrer Steuerelementlogikklasse verwenden, um den Visibility-Wert in XAML-Steuerelementvorlagen festzulegen.

Migrationshinweise

Im Windows-Runtime verwenden die Sprachparameter für IValueConverter-Methoden Zeichenfolgen, im Gegensatz zur Verwendung von CultureInfo-Objekten wie in den Windows Presentation Foundation (WPF) und Microsoft Silverlight-Definitionen der Schnittstelle.

Methoden

Convert(Object, TypeName, Object, String)	Ändert die Quelldaten, bevor sie an das Ziel zur Anzeige auf der Benutzeroberfläche übergeben werden.
ConvertBack(Object, TypeName, Object, String)	Ändert die Zieldaten, bevor sie an das Quellobjekt übergeben werden. Diese Methode wird nur in TwoWay-Bindungen aufgerufen.

Gilt für:

Teilen über