Как я могу создать пользовательское свойство зависимости * только для записи *?

Вы не можете, это, кажется, по замыслу. Хотя я могу понять ваш подход к упомянутой книге и никоим образом не ставлю под сомнение ее качество, я все же предполагаю, что это своего рода копирование и вставка или подобная проблема. Вот мои рассуждения:

Код системы свойств WPF

• Как вы уже упоминали, общедоступный API класса DependencyProperty поддерживает только RegisterReadOnly() и RegisterAttachedReadOnly().
• Ввод внутренних элементов класса через Reflector показывает только специальный код для обработки этих Свойства зависимостей только для чтения ничего не видно о функциях только для записи.
• Другим вариантом могли быть метаданные, но ни метаданные свойства зависимостей, ни в определенные метаданные свойства Framework с помощью Перечисление FrameworkPropertyMetadataOptions предоставляет что-либо вроде только для записи.

Дизайн системы свойств WPF

• Что еще более важно, 'Текущая реализация процессора XAML в WPF по своей сути учитывает свойства зависимостей. Процессор WPF XAML использует методы системы свойств для свойств зависимостей при загрузке двоичного XAML и обработке атрибутов, которые являются свойствами зависимостей. Это эффективно обходит обертки свойств». см. Загрузка XAML и зависимость Свойства.
• Самое главное, 'Свойства зависимостей обычно следует рассматривать как общедоступные свойства. Природа системы свойств Windows Presentation Foundation (WPF) не позволяет гарантировать безопасность значения свойства зависимостей». см. Безопасность свойств зависимостей.

В частности, последние два пункта определяют ограничение проекта, заключающееся в том, что значения свойств зависимостей всегда доступны через GetValue()/SetValue(), независимо от того, ограничен ли доступ к их оболочкам CLR или они вообще доступны, за единственным исключением, специально учитываемым для Свойства зависимостей только для чтения.

Следовательно, как Jeffs Ответ уже подразумевает, простое удаление геттера, например, на самом деле не мешает любому получить доступ к свойству через GetValue(), хотя это может по крайней мере 'уменьшить непосредственно доступное пространство имен пользовательского класса'. Полезность любого такого семантического обходного пути, позволяющего сделать значение свойства несколько менее видимым/доступным, а полученное значение по своей сути бесполезным для клиентов, как это предлагается Jeff, конечно, зависит от вашего конкретного сценария.

Интересно, это определенно редкий сценарий, мне было бы интересно узнать больше о том, что он позволяет.

Вы бы рассмотрели идею предоставления недопустимого значения (например, null) для чтения через привязку или GetValue, просто не имея получателя CLR?

Либо используйте частное свойство DependencyProperty для хранения "реального" значения, которое вам нужно, или просто частную переменную-член.

В обратном вызове измененного свойства всегда возвращайте значение обратно к исходному значению, сохраняя при этом новое значение, которое было установлено.

Сейчас я трачу большую часть своего времени на разработку элементов управления Silverlight, поэтому это свойство работает в WPF и Silverlight-land и не использует принуждение или что-то в этом роде. Хотя, возможно, это направит вас на верный путь.

    /// <summary>
    /// Sets the write-only dependency property.
    /// </summary>
    public string MyWriteOnlyDependencyProperty
    {
        set { SetValue(MyWriteOnlyDependencyPropertyProperty, value); }
    }

    private string _theRealSetValue;

    private bool _ignorePropertyChange;

    /// <summary>
    /// Identifies the MyWriteOnlyDependencyProperty dependency property.
    /// </summary>
    public static readonly DependencyProperty MyWriteOnlyDependencyPropertyProperty =
        DependencyProperty.Register(
            "MyWriteOnlyDependencyProperty",
            typeof(string),
            typeof(TemplatedControl1),
            new PropertyMetadata(null, OnMyWriteOnlyDependencyPropertyPropertyChanged));

    /// <summary>
    /// MyWriteOnlyDependencyPropertyProperty property changed handler.
    /// </summary>
    /// <param name="d">TemplatedControl1 that changed its MyWriteOnlyDependencyProperty.</param>
    /// <param name="e">Event arguments.</param>
    private static void OnMyWriteOnlyDependencyPropertyPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        TemplatedControl1 source = d as TemplatedControl1;
        if (source._ignorePropertyChange)
        {
            source._ignorePropertyChange = false;
            return;
        }
        string value = e.NewValue as string;

        source._theRealSetValue = value;

        // Revert, since this should never be accessible through a read
        source._ignorePropertyChange = true;
        source.SetValue(e.Property, e.OldValue);
    }

Похоже, вы можете использовать CoerceValueCallback, связанный со свойством, через FrameworkPropertyMetadata, примененный в определении свойства зависимостей. Просто установите обратный вызов, который принимает второй аргумент, новое значение, передает его объекту через ваш собственный механизм только для записи, а затем возвращает null (или для типов значений default(T)).

Это правда, что «.NET запоминает исходное значение до приведения», но оно не будет распространяться через привязку данных. Вызовы GetValue вернут принудительное значение, которое ничего не пропускает.

Я использую это для реализации односторонних удобных установщиков для значения моего основного свойства, которое представляет собой последовательность байтов. Пользователь может привязать строку, например, чтобы задать в качестве основного свойства закодированные байты (ASCII или UTF-8, в зависимости от того, какое свойство установлено). Но не все последовательности байтов допустимы в UTF-8, поэтому невозможно отменить преобразование и прочитать строку обратно через свойство удобства.

public string AsciiData
{
    set { BinaryArray = Encoding.ASCII.GetBytes(value); }
}

public static readonly DependencyProperty AsciiDataProperty =
    DependencyProperty.Register("AsciiData",
        typeof(string),
        typeof(HexView),
        new FrameworkPropertyMetadata(null, CoerceAsciiData));

private static object CoerceAsciiData(DependencyObject target, object value)
{
    (target as HexView).AsciiData = value as string;
    return null;
}

Обработчик принуждения можно удалить с помощью замены метаданных, так что это не обеспечивает безопасность, но предотвращает случайное создание связи разработчиками неправильным образом.

Я не понимаю, почему вы не можете просто получить ничего полезного?

Но, кроме того, возможно, вы просто не реализуете «OnMyWriteOnlyDependencyPropertyPropertyChanged» в примере Джеффа.

Нет реальной причины проводить мероприятие, если никто не может его прочитать, верно?