IValueConverter 인터페이스

정의

바인딩 엔진을 통과할 때 데이터를 수정할 수 있도록 하는 메서드를 노출합니다.

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
파생
특성

Windows 요구 사항

디바이스 패밀리
Windows 10 (10.0.10240.0에서 도입되었습니다.)
API contract
Windows.Foundation.UniversalApiContract (v1.0에서 도입되었습니다.)

예제

다음 예제에서는 IValueConverter 인터페이스를 구현하고 개체 컬렉션에 데이터를 바인딩할 때 변환기를 사용하는 방법을 보여줍니다.

참고

C++/WinRT(또는 C++/CX)를 사용하는 경우 데이터 값 서식 지정 또는 변환을 참조하여 사용자 고유의 값 변환기를 작성하는 더 많은 코드 예제를 표시합니다. 또한 이 항목에서는 C++ 문자열 서식 함수와 함께 ConverterParameter 특성을 사용하는 방법에 대해서도 설명합니다.

<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

설명

IValueConverter에서 상속하여 원본과 대상 간에 데이터 형식을 변환할 수 있는 클래스를 만들 수 있습니다. 예를 들어 RGBA 값으로 저장하는 색 목록을 포함하지만 UI에 색 이름으로 표시할 수 있습니다. ConvertConvertBack을 구현하면 바인딩 엔진에서 대상과 원본 간에 전달될 때 데이터 값의 형식을 변경할 수 있습니다. 항상 함수 구현을 사용하여 Convert 를 구현해야 하지만 구현되지 않은 예외를 보고하도록 ConvertBack을 구현하는 것이 일반적입니다. 양방향 바인딩에 변환기를 사용하거나 직렬화에 XAML을 사용하는 경우에만 변환기에서 ConvertBack 메서드가 필요합니다.

변환기가 원본 값을 변환할 수 없는 경우 데이터 바인딩에서 종속성 속성으로 변환을 제공하는 IValueConverter 구현에서 UnsetValue를 반환해야 합니다. 변환기는 변환에서 해당 사례에 대한 예외를 throw해서는 안 됩니다. 이러한 예외는 UnhandledException 에서 처리를 추가해야 하는 런타임 예외로 표시되거나 더 나빠지지만 실제 런타임 예외로 사용자에게 표시됩니다. 변환기 구현은 실패한 바인딩이 아무 작업도 수행하지 않고 값을 제공하지 않는 일반 바인딩 패턴을 따라야 하며, Null이 아닌 UnsetValue는 바인딩 엔진이 이해하는 경우의 sentinel 값입니다. 자세한 내용은 데이터 바인딩 심층 분석을 참조하세요.

참고

Visual C++ 구성 요소 확장(C++/CX)으로 작성된 사용자 지정 값 변환기로 데이터를 바인딩하려면 IValueConverter 구현 클래스가 정의된 헤더 파일을 코드 숨김 파일 중 하나에 직접 또는 간접적으로 포함해야 합니다. 자세한 내용은 C++를 사용하여 첫 번째 만들기를 참조하세요.

UWP 앱의 기본 프로젝트 템플릿 중 일부는 도우미 클래스인 BooleanToVisibilityConverter를 포함합니다. 이 클래스는 컨트롤 논리 클래스의 부울 값을 사용하여 XAML 컨트롤 템플릿에서 Visibility 값을 설정하는 일반적인 사용자 지정 컨트롤 시나리오를 처리하는 IValueConverter 구현입니다.

마이그레이션 정보

Windows 런타임 IValueConverter 메서드의 언어 매개 변수는 WPF(Windows Presentation Foundation) 및 인터페이스의 Microsoft Silverlight 정의에서와 마찬가지로 CultureInfo 개체를 사용하는 대신 문자열을 사용합니다.

메서드

Convert(Object, TypeName, Object, String)

UI에 표시할 대상에 전달하기 전에 원본 데이터를 수정합니다.

ConvertBack(Object, TypeName, Object, String)

대상 데이터를 원본 개체에 전달하기 전에 수정합니다. 이 메서드는 TwoWay 바인딩에서만 호출됩니다.

적용 대상

추가 정보