89

Readonlyas モードでプロパティにバインドしようとしてOneWayToSourceいますが、これは XAML では実行できないようです:

<controls:FlagThingy IsModified="{Binding FlagIsModified, 
                                          ElementName=container, 
                                          Mode=OneWayToSource}" />

私は得る：

アクセス可能な set アクセサーがないため、プロパティ 'FlagThingy.IsModified' を設定できません。

IsModifiedは読み取り専用DependencyPropertyですFlagThingy。FlagIsModifiedその値をコンテナのプロパティにバインドしたいと思います。

明確にするために：

FlagThingy.IsModified --> container.FlagIsModified
------ READONLY -----     ----- READWRITE --------

これは XAML だけを使用して可能ですか?

更新:まあ、私はバインディングをコンテナではなく に設定することで、このケースを修正しましたFlagThingy。しかし、これが可能かどうかはまだ知りたいです。

4

9 に答える 9

48

OneWayToSourceのいくつかの研究結果...

オプション1。

// Control definition
public partial class FlagThingy : UserControl
{
    public static readonly DependencyProperty IsModifiedProperty = 
            DependencyProperty.Register("IsModified", typeof(bool), typeof(FlagThingy), new PropertyMetadata());
}

<controls:FlagThingy x:Name="_flagThingy" />

// Binding Code
Binding binding = new Binding();
binding.Path = new PropertyPath("FlagIsModified");
binding.ElementName = "container";
binding.Mode = BindingMode.OneWayToSource;
_flagThingy.SetBinding(FlagThingy.IsModifiedProperty, binding);

オプション＃2

// Control definition
public partial class FlagThingy : UserControl
{
    public static readonly DependencyProperty IsModifiedProperty = 
            DependencyProperty.Register("IsModified", typeof(bool), typeof(FlagThingy), new PropertyMetadata());

    public bool IsModified
    {
        get { return (bool)GetValue(IsModifiedProperty); }
        set { throw new Exception("An attempt ot modify Read-Only property"); }
    }
}

<controls:FlagThingy IsModified="{Binding Path=FlagIsModified, 
    ElementName=container, Mode=OneWayToSource}" />

オプション＃3（真の読み取り専用依存関係プロパティ）

System.ArgumentException：'IsModified'プロパティをデータにバインドすることはできません。

// Control definition
public partial class FlagThingy : UserControl
{
    private static readonly DependencyPropertyKey IsModifiedKey =
        DependencyProperty.RegisterReadOnly("IsModified", typeof(bool), typeof(FlagThingy), new PropertyMetadata());

    public static readonly DependencyProperty IsModifiedProperty = 
        IsModifiedKey.DependencyProperty;
}

<controls:FlagThingy x:Name="_flagThingy" />

// Binding Code
Same binding code...

リフレクターは答えを与えます：

internal static BindingExpression CreateBindingExpression(DependencyObject d, DependencyProperty dp, Binding binding, BindingExpressionBase parent)
{
    FrameworkPropertyMetadata fwMetaData = dp.GetMetadata(d.DependencyObjectType) as FrameworkPropertyMetadata;
    if (((fwMetaData != null) && !fwMetaData.IsDataBindingAllowed) || dp.ReadOnly)
    {
        throw new ArgumentException(System.Windows.SR.Get(System.Windows.SRID.PropertyNotBindable, new object[] { dp.Name }), "dp");
    }
 ....
于 2009-03-18T15:11:02.090 に答える
24

これはWPFの制限であり、仕様によるものです。Connect hereで報告されています：
読み取り専用の依存関係プロパティからのOneWayToSourceバインディング

ここでブログPushBindingに書いたソースに読み取り専用の依存関係プロパティを動的にプッシュできるようにするソリューションを作成しました。以下の例では、読み取り専用DPから、およびのWidthプロパティとHeightプロパティへのバインドを実行します。OneWayToSourceActualWidthActualHeightDataContext

<TextBlock Name="myTextBlock">
    <pb:PushBindingManager.PushBindings>
        <pb:PushBinding TargetProperty="ActualHeight" Path="Height"/>
        <pb:PushBinding TargetProperty="ActualWidth" Path="Width"/>
    </pb:PushBindingManager.PushBindings>
</TextBlock>

PushBindingリスナーとミラーの2つの依存関係プロパティを使用して機能します。リスナーはOneWayTargetPropertyにバインドされ、その中で、Bindingで指定されたものにバインドされてPropertyChangedCallbackいるMirrorプロパティを更新します。OneWayToSource

デモプロジェクトはこちらからダウンロードできます。
ソースコードと短いサンプルの使用法が含まれています。

于 2011-08-29T07:29:09.977 に答える
5

これを書いた：

使用法：

<TextBox Text="{Binding Text}"
         p:OneWayToSource.Bind="{p:Paths From={x:Static Validation.HasErrorProperty},
                                         To=SomeDataContextProperty}" />

コード：

using System;
using System.Windows;
using System.Windows.Data;
using System.Windows.Markup;

public static class OneWayToSource
{
    public static readonly DependencyProperty BindProperty = DependencyProperty.RegisterAttached(
        "Bind",
        typeof(ProxyBinding),
        typeof(OneWayToSource),
        new PropertyMetadata(default(Paths), OnBindChanged));

    public static void SetBind(this UIElement element, ProxyBinding value)
    {
        element.SetValue(BindProperty, value);
    }

    [AttachedPropertyBrowsableForChildren(IncludeDescendants = false)]
    [AttachedPropertyBrowsableForType(typeof(UIElement))]
    public static ProxyBinding GetBind(this UIElement element)
    {
        return (ProxyBinding)element.GetValue(BindProperty);
    }

    private static void OnBindChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        ((ProxyBinding)e.OldValue)?.Dispose();
    }

    public class ProxyBinding : DependencyObject, IDisposable
    {
        private static readonly DependencyProperty SourceProxyProperty = DependencyProperty.Register(
            "SourceProxy",
            typeof(object),
            typeof(ProxyBinding),
            new PropertyMetadata(default(object), OnSourceProxyChanged));

        private static readonly DependencyProperty TargetProxyProperty = DependencyProperty.Register(
            "TargetProxy",
            typeof(object),
            typeof(ProxyBinding),
            new PropertyMetadata(default(object)));

        public ProxyBinding(DependencyObject source, DependencyProperty sourceProperty, string targetProperty)
        {
            var sourceBinding = new Binding
            {
                Path = new PropertyPath(sourceProperty),
                Source = source,
                Mode = BindingMode.OneWay,
            };

            BindingOperations.SetBinding(this, SourceProxyProperty, sourceBinding);

            var targetBinding = new Binding()
            {
                Path = new PropertyPath($"{nameof(FrameworkElement.DataContext)}.{targetProperty}"),
                Mode = BindingMode.OneWayToSource,
                Source = source
            };

            BindingOperations.SetBinding(this, TargetProxyProperty, targetBinding);
        }

        public void Dispose()
        {
            BindingOperations.ClearAllBindings(this);
        }

        private static void OnSourceProxyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            d.SetCurrentValue(TargetProxyProperty, e.NewValue);
        }
    }
}

[MarkupExtensionReturnType(typeof(OneWayToSource.ProxyBinding))]
public class Paths : MarkupExtension
{
    public DependencyProperty From { get; set; }

    public string To { get; set; }

    public override object ProvideValue(IServiceProvider serviceProvider)
    {
        var provideValueTarget = (IProvideValueTarget)serviceProvider.GetService(typeof(IProvideValueTarget));
        var targetObject = (UIElement)provideValueTarget.TargetObject;
        return new OneWayToSource.ProxyBinding(targetObject, this.From, this.To);
    }
}

スタイルとテンプレートでまだテストしていません。特別なケースが必要だと思います。

于 2016-02-03T11:26:29.543 に答える
0

うーん...これらの解決策のいずれにも同意できるかどうかわかりません。外部の変更を無視するプロパティ登録で強制コールバックを指定するのはどうですか? たとえば、読み取り専用の Position 依存関係プロパティを実装して、ユーザー コントロール内の MediaElement コントロールの位置を取得する必要がありました。これが私がそれをした方法です：

    public static readonly DependencyProperty PositionProperty = DependencyProperty.Register("Position", typeof(double), typeof(MediaViewer),
        new FrameworkPropertyMetadata(0d, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault | FrameworkPropertyMetadataOptions.Journal, OnPositionChanged, OnPositionCoerce));

    private static void OnPositionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        var ctrl = d as MediaViewer;
    }

    private static object OnPositionCoerce(DependencyObject d, object value)
    {
        var ctrl = d as MediaViewer;
        var position = ctrl.MediaRenderer.Position.TotalSeconds;

        if (ctrl.MediaRenderer.NaturalDuration.HasTimeSpan == false)
            return 0d;
        else
            return Math.Min(position, ctrl.Duration);
    }

    public double Position
    {
        get { return (double)GetValue(PositionProperty); }
        set { SetValue(PositionProperty, value); }
    }

つまり、単に変更を無視して、public 修飾子を持たない別のメンバーに基づく値を返します。-- 上記の例では、MediaRenderer は実際にはプライベート MediaElement コントロールです。

于 2013-03-27T22:10:22.927 に答える
0

WPF は CLR プロパティ セッターを使用しませんが、それに基づいていくつかの奇妙な検証を行うようです。

あなたの状況でこれは大丈夫かもしれません：

    public bool IsModified
    {
        get { return (bool)GetValue(IsModifiedProperty); }
        set { throw new Exception("An attempt ot modify Read-Only property"); }
    }
于 2009-03-18T13:28:49.060 に答える
0

この制限を回避する方法は、クラスで Binding プロパティのみを公開し、DependencyProperty を完全に非公開にすることでした。xaml でバインド値に設定できる "PropertyBindingToSource" 書き込み専用プロパティ (これは DependencyProperty ではありません) を実装しました。この書き込み専用プロパティのセッターで、BindingOperations.SetBinding を呼び出して、バインディングを DependencyProperty にリンクします。

OP の特定の例では、次のようになります。

FlatThingy の実装:

public partial class FlatThingy : UserControl
{
    public FlatThingy()
    {
        InitializeComponent();
    }

    public Binding IsModifiedBindingToSource
    {
        set
        {
            if (value?.Mode != BindingMode.OneWayToSource)
            {
                throw new InvalidOperationException("IsModifiedBindingToSource must be set to a OneWayToSource binding");
            }

            BindingOperations.SetBinding(this, IsModifiedProperty, value);
        }
    }

    public bool IsModified
    {
        get { return (bool)GetValue(IsModifiedProperty); }
        private set { SetValue(IsModifiedProperty, value); }
    }

    private static readonly DependencyProperty IsModifiedProperty =
        DependencyProperty.Register("IsModified", typeof(bool), typeof(FlatThingy), new PropertyMetadata(false));

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        IsModified = !IsModified;
    }
}

読み取り専用の静的な DependencyProperty オブジェクトは非公開であることに注意してください。コントロールに、クリックが Button_Click によって処理されるボタンを追加しました。私の window.xaml での FlatThingy コントロールの使用:

<Window x:Class="ReadOnlyBinding.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:local="clr-namespace:ReadOnlyBinding"
    mc:Ignorable="d"
    DataContext="{x:Static local:ViewModel.Instance}"
    Title="MainWindow" Height="450" Width="800">
<Grid>
    <Grid.RowDefinitions>
        <RowDefinition />
        <RowDefinition />
    </Grid.RowDefinitions>

    <TextBlock Text="{Binding FlagIsModified}" Grid.Row="0" />
    <local:FlatThingy IsModifiedBindingToSource="{Binding FlagIsModified, Mode=OneWayToSource}" Grid.Row="1" />
</Grid>

ここでは示されていませんが、バインド用の ViewModel も実装したことに注意してください。上記のソースから収集できるように、「FlagIsModified」という名前の DependencyProperty を公開します。

これはうまく機能し、情報フローの方向を明示的に定義して、疎結合の方法で View から ViewModel に情報をプッシュして戻すことができます。

于 2020-07-23T20:36:06.533 に答える