사용자 지정 종속성 속성

여기서는 C++, C# 또는 Visual Basic을 사용하여 Windows 런타임 앱에 대한 고유한 종속성 속성을 정의하고 구현하는 방법을 설명합니다. 앱 개발자와 구성 요소 작성자가 사용자 지정 종속성 속성을 만들려는 이유를 나열합니다. 사용자 지정 종속성 속성의 구현 단계와 종속성 속성의 성능, 유용성 또는 다양성을 향상시킬 수 있는 몇 가지 모범 사례에 대해 설명합니다.

필수 조건

종속성 속성의 소비자 관점에서 종속성 속성을 이해하고 있으며, 종속성 속성 개요를 읽었다고 가정합니다. 이 항목의 예제를 따르려면 XAML을 이해하고 C++, C# 또는 Visual Basic을 사용하여 기본 Windows 런타임 앱을 작성하는 방법도 알아야 합니다.

종속성 속성이란?

속성에 대한 스타일 지정, 데이터 바인딩, 애니메이션 및 기본값을 지원하려면 종속성 속성으로 구현해야 합니다. 종속성 속성 값은 클래스에 필드로 저장되지 않고 xaml 프레임워크에 의해 저장되며 DependencyProperty.Register 메서드를 호출하여 속성이 Windows 런타임 속성 시스템에 등록될 때 검색되는 키를 사용하여 참조됩니다. 종속성 속성은 DependencyObject에서 파생된 형식에서만 사용할 수 있습니다. 그러나 DependencyObject 는 클래스 계층 구조에서 매우 높으므로 UI 및 프레젠테이션 지원을 위한 대부분의 클래스는 종속성 속성을 지원할 수 있습니다. 종속성 속성 및 이 설명서에서 설명하는 데 사용되는 일부 용어 및 규칙에 대한 자세한 내용은 종속성 속성 개요를 참조하세요.

Windows 런타임의 종속성 속성의 예는 Control.Background, FrameworkElement.Width 및 TextBox.Text입니다.

규칙은 클래스에 의해 노출되는 각 종속성 속성에 종속성 속성에 대한 식별자를 제공하는 동일한 클래스에 노출되는 DependencyProperty 형식의 해당 공용 정적 읽기 전용 속성이 있다는 것입니다. 식별자의 이름은 종속성 속성의 이름과 이름 끝에 "Property" 문자열이 추가되는 규칙을 따릅니다. 예를 들어 Control.Background 속성에 대한 해당 DependencyProperty 식별자는 Control.BackgroundProperty입니다. 식별자는 등록된 종속성 속성에 대한 정보를 저장한 다음 SetValue 호출과 같은 종속성 속성과 관련된 다른 작업에 사용할 수 있습니다.

속성 포장자

종속성 속성에는 일반적으로 래퍼 구현이 있습니다. 래퍼가 없으면 속성을 얻거나 설정하는 유일한 방법은 종속성 속성 유틸리티 메서드 GetValue 및 SetValue 를 사용하고 식별자를 매개 변수로 전달하는 것입니다. 이것은 겉보기에는 속성인 것에 대한 자연스럽지 않은 사용입니다. 그러나 래퍼를 사용하면 코드와 종속성 속성을 참조하는 다른 모든 코드가 사용 중인 언어에 자연스러운 간단한 개체 속성 구문을 사용할 수 있습니다.

사용자 지정 종속성 속성을 직접 구현하고 공용으로 쉽게 호출하려면 속성 래퍼도 정의합니다. 속성 래퍼는 종속성 속성에 대한 기본 정보를 리플렉션 또는 정적 분석 프로세스에 보고하는 데에도 유용합니다. 특히 래퍼(wrapper)는 ContentPropertyAttribute와 같은 특성을 배치하는 위치입니다.

속성을 종속성 속성으로 구현하는 경우

클래스에서 공용 읽기/쓰기 속성을 구현할 때마다, 클래스가 DependencyObject에서 파생된다면, 해당 속성을 종속성 속성으로 설정할 수 있는 옵션이 있습니다. 경우에 따라 속성을 개인 필드로 백업하는 일반적인 기술이 적절할 수 있습니다. 사용자 지정 속성을 종속성 속성으로 정의하는 것이 항상 필요하거나 적절한 것은 아닙니다. 선택은 귀하의 속성이 지원하려는 시나리오에 따라 달라집니다.

Windows 런타임 또는 Windows 런타임 앱의 이러한 기능 중 하나 이상을 지원하려는 경우 속성을 종속성 속성으로 구현하는 것이 좋습니다.

• Style을 통해 속성 설정
• {Binding}을(를) 사용하여 데이터 바인딩에 유효한 대상 속성으로 작동
• Storyboard를 통해 애니메이션 값 지원
• 속성 값이 변경된 경우 보고:
  • 속성 시스템 자체에서 수행한 작업
  • 환경
  • 사용자 작업
  • 읽기 및 쓰기 스타일

종속성 속성 정의에 대한 검사 목록

종속성 속성 정의는 개념 집합으로 간주할 수 있습니다. 구현의 코드 한 줄에서 여러 개념을 해결할 수 있기 때문에 이러한 개념이 반드시 절차적인 단계는 아닙니다. 이 목록은 간단한 개요를 제공합니다. 이 항목의 뒷부분에서 각 개념을 자세히 설명하고 여러 언어로 예제 코드를 보여 드리겠습니다.

• 속성 시스템(Register 호출) 에 속성 이름을 등록하고 소유자 형식 및 속성 값의 형식을 지정합니다.
  • 속성 메타데이터를 예상하는 Register 에 필요한 매개 변수가 있습니다. Null을 지정하거나 속성 변경 동작 또는 ClearValue를 호출하여 복원할 수 있는 메타데이터 기반 기본값을 원하는 경우 PropertyMetadata의 인스턴스를 지정합니다.
• DependencyProperty 식별자를 소유자 형식의 공용 정적 읽기 전용 속성 멤버로 정의합니다.
• 구현하는 언어로 사용되는 속성 접근자 모델에 따라 래퍼 속성을 정의합니다. 래퍼 속성 이름은 Register에서 사용한 이름 문자열과 일치해야 합니다. get 및 set 접근자를 구현하여 래퍼를 래핑하는 종속성 속성과 연결하고, GetValue 및 SetValue 함수를 호출한 다음, 자신의 속성 식별자를 매개변수로 전달합니다.
• (선택 사항) ContentPropertyAttribute 와 같은 특성을 래퍼에 배치합니다.

속성 등록

속성이 종속성 속성이 되려면 Windows 런타임 속성 시스템에서 유지 관리하는 속성 저장소에 속성을 등록해야 합니다. 속성을 등록하려면 Register 메서드를 호출합니다.

Microsoft .NET 언어(C# 및 Microsoft Visual Basic)의 경우 클래스 본문 내에서 Register 를 호출합니다(클래스 내부는 물론 멤버 정의 외부). 식별자는 Register 메서드 호출에서 반환 값으로 제공됩니다. Register 호출은 일반적으로 정적 생성자 또는 클래스의 일부로 DependencyProperty 형식의 공용 정적 읽기 전용 속성 초기화의 일부로 이루어집니다. 이 속성은 종속성 속성에 대한 식별자를 노출합니다. 다음은 Register 호출의 예입니다.

C++/CX의 경우 헤더와 코드 파일 간에 구현을 분할하는 방법에 대한 옵션이 있습니다. 일반적인 분할은 가져오기 구현이지만 설정이 없는 헤더에서 식별자 자체를 공용 정적 속성으로 선언하는 것입니다. get 구현은 초기화되지 않은 DependencyProperty 인스턴스인 프라이빗 필드를 참조합니다. 래퍼와 래퍼의 가져오기 및 설정 구현을 선언할 수도 있습니다. 이 경우 헤더에는 최소한의 구현이 포함됩니다. 래퍼에 Windows 런타임 특성이 필요한 경우, 헤더에도 특성을 지정해야 합니다. 앱이 처음 초기화되는 경우에만 실행되는 도우미 함수 내에서 코드 파일에 Register 호출을 배치합니다. Register의 반환 값을 사용하여 처음에 구현 파일의 루트 범위에서 nullptr로 설정한 헤더에서 선언한 정적이지만 초기화되지 않은 식별자를 채웁니다.

public static readonly DependencyProperty LabelProperty = DependencyProperty.Register(
  nameof(Label),
  typeof(String),
  typeof(ImageWithLabelControl),
  new PropertyMetadata(null)
);

Public Shared ReadOnly LabelProperty As DependencyProperty =
    DependencyProperty.Register("Label",
      GetType(String),
      GetType(ImageWithLabelControl),
      New PropertyMetadata(Nothing))

// ImageWithLabelControl.idl
namespace ImageWithLabelControlApp
{
    runtimeclass ImageWithLabelControl : Windows.UI.Xaml.Controls.Control
    {
        ImageWithLabelControl();
        static Windows.UI.Xaml.DependencyProperty LabelProperty{ get; };
        String Label;
    }
}

// ImageWithLabelControl.h
...
struct ImageWithLabelControl : ImageWithLabelControlT<ImageWithLabelControl>
{
...
public:
    static Windows::UI::Xaml::DependencyProperty LabelProperty()
    {
        return m_labelProperty;
    }

private:
    static Windows::UI::Xaml::DependencyProperty m_labelProperty;
...
};

// ImageWithLabelControl.cpp
...
Windows::UI::Xaml::DependencyProperty ImageWithLabelControl::m_labelProperty =
    Windows::UI::Xaml::DependencyProperty::Register(
        L"Label",
        winrt::xaml_typename<winrt::hstring>(),
        winrt::xaml_typename<ImageWithLabelControlApp::ImageWithLabelControl>(),
        Windows::UI::Xaml::PropertyMetadata{ nullptr }
);
...

//.h file
//using namespace Windows::UI::Xaml::Controls;
//using namespace Windows::UI::Xaml::Interop;
//using namespace Windows::UI::Xaml;
//using namespace Platform;

public ref class ImageWithLabelControl sealed : public Control
{
private:
    static DependencyProperty^ _LabelProperty;
...
public:
    static void RegisterDependencyProperties();
    static property DependencyProperty^ LabelProperty
    {
        DependencyProperty^ get() {return _LabelProperty;}
    }
...
};

//.cpp file
using namespace Windows::UI::Xaml;
using namespace Windows::UI::Xaml.Interop;

DependencyProperty^ ImageWithLabelControl::_LabelProperty = nullptr;

// This function is called from the App constructor in App.xaml.cpp
// to register the properties
void ImageWithLabelControl::RegisterDependencyProperties()
{
    if (_LabelProperty == nullptr)
    {
        _LabelProperty = DependencyProperty::Register(
          "Label", Platform::String::typeid, ImageWithLabelControl::typeid, nullptr);
    }
}

종속성 속성 이름 규칙

종속성 속성에 대한 명명 규칙이 있습니다. 예외적인 상황을 제외한 모든 상황에서 그들을 따르세요. 종속성 속성 자체에는 Register의 첫 번째 매개 변수로 지정된 기본 이름(앞의 예제에서는 "Label")이 있습니다. 이름은 각 등록 형식 내에서 고유해야 하며 고유성 요구 사항은 상속된 멤버에도 적용됩니다. 기본 형식을 통해 상속된 종속성 속성은 이미 등록 형식의 일부로 간주됩니다. 상속된 속성의 이름을 다시 등록할 수 없습니다.

식별자 속성을 만들 때 등록한 속성의 이름을 접미사 "Property"(예: "LabelProperty")와 결합합니다. 이 속성은 종속성 속성의 식별자이며 사용자 고유의 속성 래퍼에서 만드는 SetValue 및 GetValue 호출에 대한 입력으로 사용됩니다. 또한 속성 시스템 및 기타 XAML 프로세서(예: {x:Bind})에서 사용됩니다.

래퍼 구현

속성 래퍼는 get 구현에서 GetValue를 호출하고 SetValue는 집합 구현에서 호출해야 합니다.

public String Label
{
    get { return (String)GetValue(LabelProperty); }
    set { SetValue(LabelProperty, value); }
}

Public Property Label() As String
    Get
        Return DirectCast(GetValue(LabelProperty), String)
    End Get
    Set(ByVal value As String)
        SetValue(LabelProperty, value)
    End Set
End Property

// ImageWithLabelControl.h
...
winrt::hstring Label()
{
    return winrt::unbox_value<winrt::hstring>(GetValue(m_labelProperty));
}

void Label(winrt::hstring const& value)
{
    SetValue(m_labelProperty, winrt::box_value(value));
}
...

//using namespace Platform;
public:
...
  property String^ Label
  {
    String^ get() {
      return (String^)GetValue(LabelProperty);
    }
    void set(String^ value) {
      SetValue(LabelProperty, value);
    }
  }

사용자 지정 종속성 속성에 대한 속성 메타데이터

속성 메타데이터가 종속성 속성에 할당되면 속성 소유자 형식 또는 해당 하위 클래스의 모든 인스턴스에 대해 동일한 메타데이터가 해당 속성에 적용됩니다. 속성 메타데이터에서 다음 두 가지 동작을 지정할 수 있습니다.

• 속성 시스템에서 속성의 모든 사례에 할당하는 기본값입니다.
• 속성 값 변경이 검색될 때마다 속성 시스템 내에서 자동으로 호출되는 정적 콜백 메서드입니다.

속성 메타데이터를 사용하여 Register 호출

DependencyProperty.Register를 호출하는 이전 예제에서는 propertyMetadata 매개 변수에 대해 null 값을 전달했습니다. 종속성 속성이 기본값을 제공하거나 속성 변경 콜백을 사용하도록 설정하려면 이러한 기능 중 하나 또는 둘 다를 제공하는 PropertyMetadata 인스턴스를 정의해야 합니다.

일반적으로 DependencyProperty.Register에 대한 매개 변수 내에서 PropertyMetadata를 인라인으로 만든 인스턴스로 제공합니다.

다음 예제에서는 PropertyChangedCallback 값을 사용하여 PropertyMetadata 인스턴스를 참조하여 이전에 표시된 DependencyProperty.Register 예제를 수정합니다. "OnLabelChanged" 콜백의 구현은 이 섹션의 뒷부분에 나와 있습니다.

public static readonly DependencyProperty LabelProperty = DependencyProperty.Register(
  nameof(Label),
  typeof(String),
  typeof(ImageWithLabelControl),
  new PropertyMetadata(null,new PropertyChangedCallback(OnLabelChanged))
);

Public Shared ReadOnly LabelProperty As DependencyProperty =
    DependencyProperty.Register("Label",
      GetType(String),
      GetType(ImageWithLabelControl),
      New PropertyMetadata(
        Nothing, new PropertyChangedCallback(AddressOf OnLabelChanged)))

// ImageWithLabelControl.cpp
...
Windows::UI::Xaml::DependencyProperty ImageWithLabelControl::m_labelProperty =
    Windows::UI::Xaml::DependencyProperty::Register(
        L"Label",
        winrt::xaml_typename<winrt::hstring>(),
        winrt::xaml_typename<ImageWithLabelControlApp::ImageWithLabelControl>(),
        Windows::UI::Xaml::PropertyMetadata{ nullptr, Windows::UI::Xaml::PropertyChangedCallback{ &ImageWithLabelControl::OnLabelChanged } }
);
...

DependencyProperty^ ImageWithLabelControl::_LabelProperty =
    DependencyProperty::Register("Label",
    Platform::String::typeid,
    ImageWithLabelControl::typeid,
    ref new PropertyMetadata(nullptr,
      ref new PropertyChangedCallback(&ImageWithLabelControl::OnLabelChanged))
    );

기본값

속성이 설정되지 않은 경우 항상 특정 기본값을 반환할 수 있도록 종속성 속성에 대한 기본값을 지정할 수 있습니다. 이 값은 해당 속성의 형식에 대한 내재된 기본값과 다를 수 있습니다.

기본값을 지정하지 않으면 참조 형식의 경우 종속성 속성의 기본값이 null이거나 값 형식 또는 언어 기본 형식에 대한 형식의 기본값(예: 정수의 경우 0 또는 문자열의 빈 문자열)입니다. 기본값을 설정하는 주된 이유는 속성에서 ClearValue 를 호출할 때 이 값이 복원되기 때문입니다. 속성별로 기본값을 설정하는 것이 생성자, 특히 값 형식의 기본값을 설정하는 것보다 더 편리할 수 있습니다. 그러나 참조 형식의 경우 기본값을 설정해도 의도하지 않은 싱글톤 패턴이 만들어지지 않는지 확인합니다. 자세한 내용은 이 항목의 뒷 부분에 있는 모범 사례를 참조하세요.

// ImageWithLabelControl.cpp
...
Windows::UI::Xaml::DependencyProperty ImageWithLabelControl::m_labelProperty =
    Windows::UI::Xaml::DependencyProperty::Register(
        L"Label",
        winrt::xaml_typename<winrt::hstring>(),
        winrt::xaml_typename<ImageWithLabelControlApp::ImageWithLabelControl>(),
        Windows::UI::Xaml::PropertyMetadata{ winrt::box_value(L"default label"), Windows::UI::Xaml::PropertyChangedCallback{ &ImageWithLabelControl::OnLabelChanged } }
);
...

CreateDefaultValueCallback (기본값 콜백 생성)

일부 시나리오에서는 둘 이상의 UI 스레드에서 사용되는 개체에 대한 종속성 속성을 정의합니다. 여러 앱에서 사용되는 데이터 개체 또는 둘 이상의 앱에서 사용하는 컨트롤을 정의하는 경우일 수 있습니다. 속성을 등록한 스레드에 연결된 기본값 인스턴스가 아닌 CreateDefaultValueCallback 구현을 제공하여 서로 다른 UI 스레드 간에 개체 교환을 사용하도록 설정할 수 있습니다. 기본적으로 CreateDefaultValueCallback 은 기본값에 대한 팩터리를 정의합니다. CreateDefaultValueCallback에서 반환되는 값은 항상 개체를 사용하는 현재 UI CreateDefaultValueCallback 스레드와 연결됩니다.

CreateDefaultValueCallback을 지정하는 메타데이터를 정의하려면 PropertyMetadata.Create를 호출하여 메타데이터 인스턴스를 반환해야 합니다. PropertyMetadata 생성자에 CreateDefaultValueCallback 매개 변수를 포함하는 서명이 없습니다.

CreateDefaultValueCallback의 일반적인 구현 패턴은 새 DependencyObject 클래스를 만들고 DependencyObject의 각 속성의 특정 속성 값을 의도한 기본값으로 설정한 다음 CreateDefaultValueCallback 메서드의 반환 값을 통해 새 클래스를 Object 참조로 반환하는 것입니다.

속성 변경 콜백 메서드

속성이 변경된 콜백 메서드를 정의하여 속성과 다른 종속성 속성의 상호 작용을 정의하거나 속성이 변경될 때마다 개체의 내부 속성 또는 상태를 업데이트할 수 있습니다. 콜백이 호출되면 속성 시스템에서 유효한 속성 값 변경이 있음을 확인했습니다. 콜백 메서드는 정적이므로 콜백의 d 매개 변수는 변경 사항을 보고한 클래스의 인스턴스를 알려주기 때문에 중요합니다. 일반적인 구현에서는 이벤트 데이터의 NewValue 속성을 사용하며, 일반적으로 d로 전달된 개체에 대해 다른 변경 작업을 수행하여 해당 값을 어떤 방식으로 처리합니다. 속성 변경에 대한 추가 응답은 NewValue에서 보고한 값을 거부하거나 OldValue를 복원하거나 NewValue에 적용된 프로그래밍 방식 제약 조건으로 값을 설정하는 것입니다.

다음 예제에서는 PropertyChangedCallback 구현을 보여줍니다. 이전 Register 예제에서 참조한 메서드를 PropertyMetadata에 대한 생성 인수의 일부로 구현합니다. 이 콜백에서 해결된 시나리오는 클래스에 "HasLabelValue"라는 계산된 읽기 전용 속성도 있다는 것입니다(구현은 표시되지 않음). "Label" 속성이 다시 평가될 때마다 이 콜백 메서드가 호출되고 콜백을 사용하면 종속 계산 값이 종속성 속성의 변경 내용과 동기화 상태로 유지됩니다.

private static void OnLabelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
    ImageWithLabelControl iwlc = d as ImageWithLabelControl; //null checks omitted
    String s = e.NewValue as String; //null checks omitted
    if (s == String.Empty)
    {
        iwlc.HasLabelValue = false;
    } else {
        iwlc.HasLabelValue = true;
    }
}

    Private Shared Sub OnLabelChanged(d As DependencyObject, e As DependencyPropertyChangedEventArgs)
        Dim iwlc As ImageWithLabelControl = CType(d, ImageWithLabelControl) ' null checks omitted
        Dim s As String = CType(e.NewValue,String) ' null checks omitted
        If s Is String.Empty Then
            iwlc.HasLabelValue = False
        Else
            iwlc.HasLabelValue = True
        End If
    End Sub

void ImageWithLabelControl::OnLabelChanged(Windows::UI::Xaml::DependencyObject const& d, Windows::UI::Xaml::DependencyPropertyChangedEventArgs const& e)
{
    auto iwlc{ d.as<ImageWithLabelControlApp::ImageWithLabelControl>() };
    auto s{ winrt::unbox_value<winrt::hstring>(e.NewValue()) };
    iwlc.HasLabelValue(s.size() != 0);
}

static void OnLabelChanged(DependencyObject^ d, DependencyPropertyChangedEventArgs^ e)
{
    ImageWithLabelControl^ iwlc = (ImageWithLabelControl^)d;
    Platform::String^ s = (Platform::String^)(e->NewValue);
    if (s->IsEmpty()) {
        iwlc->HasLabelValue=false;
    }
}

구조체 및 열거형에 대한 동작 속성 변경

DependencyProperty의 형식이 열거형 또는 구조체인 경우 구조체의 내부 값이나 열거형 값이 변경되지 않은 경우에도 콜백이 호출될 수 있습니다. 값이 변경된 경우에만 호출되는 문자열과 같은 시스템 기본 형식과 다릅니다. 내부적으로 수행되는 이러한 값에 대한 box 및 unbox 작업의 부작용입니다. 값이 열거형 또는 구조인 속성에 대한 PropertyChangedCallback 메서드가 있는 경우 값을 직접 캐스팅하고 현재 캐스트 값에 사용할 수 있는 오버로드된 비교 연산자를 사용하여 OldValue 와 NewValue 를 비교해야 합니다. 또는 이러한 연산자를 사용할 수 없는 경우(사용자 지정 구조의 경우일 수 있음) 개별 값을 비교해야 할 수 있습니다. 일반적으로 값이 변경되지 않은 경우 아무 것도 수행하지 않도록 선택합니다.

private static void OnVisibilityValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
    if ((Visibility)e.NewValue != (Visibility)e.OldValue)
    {
        //value really changed, invoke your changed logic here
    } // else this was invoked because of boxing, do nothing
}

Private Shared Sub OnVisibilityValueChanged(d As DependencyObject, e As DependencyPropertyChangedEventArgs)
    If CType(e.NewValue,Visibility) != CType(e.OldValue,Visibility) Then
        '  value really changed, invoke your changed logic here
    End If
    '  else this was invoked because of boxing, do nothing
End Sub

static void OnVisibilityValueChanged(Windows::UI::Xaml::DependencyObject const& d, Windows::UI::Xaml::DependencyPropertyChangedEventArgs const& e)
{
    auto oldVisibility{ winrt::unbox_value<Windows::UI::Xaml::Visibility>(e.OldValue()) };
    auto newVisibility{ winrt::unbox_value<Windows::UI::Xaml::Visibility>(e.NewValue()) };

    if (newVisibility != oldVisibility)
    {
        // The value really changed; invoke your property-changed logic here.
    }
    // Otherwise, OnVisibilityValueChanged was invoked because of boxing; do nothing.
}

static void OnVisibilityValueChanged(DependencyObject^ d, DependencyPropertyChangedEventArgs^ e)
{
    if ((Visibility)e->NewValue != (Visibility)e->OldValue)
    {
        //value really changed, invoke your changed logic here
    }
    // else this was invoked because of boxing, do nothing
    }
}

모범 사례

사용자 지정 종속성 속성을 정의할 때 다음 고려 사항을 모범 사례로 염두에 두어야 합니다.

DependencyObject 및 스레드 처리

모든 DependencyObject 인스턴스는 Windows 런타임 앱에 표시되는 현재 창 과 연결된 UI 스레드에서 만들어야 합니다. 기본 UI 스레드에서 각 DependencyObject 를 만들어야 하지만 디스패처를 호출하여 다른 스레드의 디스패처 참조를 사용하여 개체에 액세스할 수 있습니다.

DependencyObject의 스레딩 측면은 일반적으로 UI 스레드에서 실행되는 코드만 종속성 속성의 값을 변경하거나 읽을 수 있음을 의미하기 때문에 관련이 있습니다. 일반적으로 비 동 기 패턴 및 백그라운드 작업자 스레드를 올바르게 사용하는 일반적인 UI 코드에서는 스레딩 문제를 방지할 수 있습니다. 일반적으로 DependencyObject 형식을 정의하고 데이터 원본 또는 DependencyObject 가 반드시 적절하지 않은 다른 시나리오에 사용하려고 하는 경우에만 DependencyObject 관련 스레딩 문제가 발생합니다.

의도하지 않은 싱글톤 방지

참조 형식을 사용하는 종속성 속성을 선언하고 해당 참조 형식에 대한 생성자를 PropertyMetadata를 설정하는 코드의 일부로 호출하는 경우 의도하지 않은 싱글톤이 발생할 수 있습니다. 종속성 속성의 모든 사용은 PropertyMetadata 의 인스턴스를 하나만 공유하므로 생성한 단일 참조 형식을 공유하려고 합니다. 종속성 속성을 통해 설정한 해당 값 형식의 하위 속성은 의도하지 않은 방식으로 다른 개체로 전파됩니다.

null이 아닌 값을 원하는 경우 클래스 생성자를 사용하여 참조 형식 종속성 속성에 대한 초기 값을 설정할 수 있지만 종 속성 속성 개요를 위해 로컬 값으로 간주된다는 점에 유의하세요. 클래스에서 템플릿을 지원하는 경우 이 목적을 위해 템플릿을 사용하는 것이 더 적절할 수 있습니다. 단일 패턴을 방지하지만 여전히 유용한 기본값을 제공하는 또 다른 방법은 해당 클래스의 값에 적합한 기본값을 제공하는 참조 형식에 정적 속성을 노출하는 것입니다.

컬렉션 형식 종속성 속성

컬렉션 형식 종속성 속성에는 고려해야 할 몇 가지 추가 구현 문제가 있습니다.

컬렉션 형식 종속성 속성은 Windows 런타임 API에서 비교적 드뭅니다. 대부분의 경우 항목이 DependencyObject 하위 클래스인 컬렉션을 사용할 수 있지만 컬렉션 속성 자체는 기존 CLR 또는 C++ 속성으로 구현됩니다. 이는 컬렉션이 종속성 속성이 관련된 몇 가지 일반적인 시나리오에 반드시 적합하지 않기 때문입니다. 다음은 그 예입니다.

• 일반적으로 컬렉션에 애니메이션 효과를 주지 않습니다.
• 일반적으로 스타일이나 템플릿을 사용하여 컬렉션의 항목을 미리 채운 것은 아닙니다.
• 컬렉션에 대한 바인딩은 주요 시나리오이지만 컬렉션이 바인딩 원본이 되도록 종속성 속성일 필요는 없습니다. 바인딩 대상의 경우 ItemsControl 또는 DataTemplate 의 하위 클래스를 사용하여 컬렉션 항목을 지원하거나 뷰 모델 패턴을 사용하는 것이 더 일반적입니다. 컬렉션에 바인딩하는 방법에 대한 자세한 내용은 데이터 바인딩을 자세히 참조하세요.
• 컬렉션 변경에 대한 알림은 INotifyPropertyChanged 또는 INotifyCollectionChanged와 같은 인터페이스를 통해 또는 >에서 컬렉션 형식을 파생하여 더 잘 해결됩니다.

그럼에도 불구하고 컬렉션 형식 종속성 속성에 대한 시나리오가 존재합니다. 다음 세 섹션에서는 컬렉션 형식 종속성 속성을 구현하는 방법에 대한 몇 가지 지침을 제공합니다.

컬렉션 초기화

종속성 속성을 만들 때 종속성 속성 메타데이터를 통해 기본값을 설정할 수 있습니다. 그러나 싱글톤 정적 컬렉션을 기본값으로 사용하지 않도록 주의해야 합니다. 대신 컬렉션 속성의 소유자 클래스에 대한 클래스 생성자 논리의 일부로 컬렉션 값을 고유(인스턴스) 컬렉션으로 의도적으로 설정해야 합니다.

// WARNING - DO NOT DO THIS
public static readonly DependencyProperty ItemsProperty = DependencyProperty.Register(
  nameof(Items),
  typeof(IList<object>),
  typeof(ImageWithLabelControl),
  new PropertyMetadata(new List<object>())
);

// DO THIS Instead
public static readonly DependencyProperty ItemsProperty = DependencyProperty.Register(
  nameof(Items),
  typeof(IList<object>),
  typeof(ImageWithLabelControl),
  new PropertyMetadata(null)
);

public ImageWithLabelControl()
{
    // Need to initialize in constructor instead
    Items = new List<object>();
}

DependencyProperty 및 해당 PropertyMetadata의 기본값은 DependencyProperty의 정적 정의에 속합니다. 기본 컬렉션(또는 다른 인스턴스화된) 값을 기본값으로 제공하면 일반적으로 원하는 대로 각 클래스가 자체 컬렉션을 갖는 대신 클래스의 모든 인스턴스에서 공유됩니다.

알림 변경

컬렉션을 종속성 속성으로 정의해도 "PropertyChanged" 콜백 메서드를 호출하는 속성 시스템 덕분에 컬렉션의 항목에 대한 변경 알림이 자동으로 제공되지는 않습니다. 컬렉션 또는 컬렉션 항목에 대한 알림(예: 데이터 바인딩 시나리오)을 원하는 경우 INotifyPropertyChanged 또는 INotifyCollectionChanged 인터페이스를 구현합니다. 자세한 내용은 데이터 바인딩심층 부분을 참조하세요.

종속성 속성 보안 고려 사항

종속성 속성을 공용 속성으로 선언합니다. 종속성 속성 식별자를 공용 정적 읽기 전용 멤버로 선언합니다. 언어에서 허용하는 다른 액세스 수준(예: 보호됨)을 선언하려는 경우에도 종속성 속성은 항상 속성 시스템 API와 함께 식별자를 통해 액세스할 수 있습니다. 종속성 속성 식별자를 내부 또는 프라이빗으로 선언하면 속성 시스템이 제대로 작동할 수 없으므로 작동하지 않습니다.

래퍼 속성은 실제로 편의성을 위한 것이며, GetValue 또는 SetValue를 호출하면 래퍼에 적용된 보안 메커니즘을 우회할 수 있습니다. 따라서 래퍼 속성을 공용으로 유지합니다. 그렇지 않으면 실제 보안 혜택을 제공하지 않고 합법적인 호출자가 사용하기 위해 속성을 더 어렵게 만듭니다.

Windows 런타임은 사용자 지정 종속성 속성을 읽기 전용으로 등록하는 방법을 제공하지 않습니다.

종속성 속성 및 클래스 생성자

클래스 생성자가 가상 메서드를 호출해서는 안 된다는 일반적인 원칙이 있습니다. 이는 생성자를 호출하여 파생 클래스 생성자의 기본 초기화를 수행할 수 있으며 생성자를 통해 가상 메서드를 입력하면 생성되는 개체 인스턴스가 아직 완전히 초기화되지 않았을 때 발생할 수 있기 때문입니다. DependencyObject에서 이미 파생된 클래스에서 파생되는 경우 속성 시스템 자체가 가상 메서드를 호출하고 내부적으로 해당 서비스의 일부로 노출합니다. 런타임 초기화에 잠재적인 문제를 방지하려면 클래스의 생성자 내에서 종속성 속성 값을 설정하지 마세요.

C++/CX 앱에 대한 종속성 속성 등록

C++/CX에서 속성을 등록하기 위한 구현은 헤더 및 구현 파일로의 분리와 구현 파일의 루트 범위에서 초기화가 잘못된 사례이기 때문에 C#보다 까다롭습니다. (Visual C++ 구성 요소 확장(C++/CX)은 루트 범위의 정적 이니셜라이저 코드를 DllMain에 직접 배치하는 반면, C# 컴파일러는 정적 이니셜라이저를 클래스에 할당하므로 DllMain 부하 잠금 문제를 방지합니다. 여기서 모범 사례는 클래스에 대한 모든 종속성 속성 등록을 수행하는 도우미 함수를 선언하는 것입니다. 클래스당 하나의 함수입니다. 그런 다음 앱에서 사용하는 각 사용자 지정 클래스에 대해 사용하려는 각 사용자 지정 클래스에 의해 노출되는 도우미 등록 함수를 참조해야 합니다. 각 도우미 등록 함수를 애플리케이션 생성자 ()App::App()의 일부로 한 번 호출합니다 InitializeComponent. 이 생성자는 앱이 실제로 처음으로 참조될 때만 실행되며, 일시 중단된 앱이 다시 시작되는 경우 다시 실행되지 않습니다. 또한 이전 C++ 등록 예제에서 볼 수 있듯이 각 레지스터 호출에 대한 nullptr 검사는 중요합니다. 함수의 호출자가 속성을 두 번 등록할 수 없다는 것은 보험입니다. 두 번째 등록 호출은 속성 이름이 중복되므로 이러한 검사 없이 앱이 충돌할 수 있습니다. 샘플의 C++/CX 버전에 대한 코드를 살펴보면 XAML 사용자 및 사용자 지정 컨트롤 샘플 에서 이 구현 패턴을 볼 수 있습니다.

관련 항목

• DependencyObject
• DependencyProperty.Register
• 종속성 속성 개요
• XAML 사용자 및 사용자 지정 컨트롤 샘플