Associazione a proprietà statiche

Sto facendo fatica a collegare una semplice proprietà di stringa statica a una TextBox.

Ecco la classe con la proprietà statica:

public class VersionManager
{
    private static string filterString;

    public static string FilterString
    {
        get { return filterString; }
        set { filterString = value; }
    }
}

Nel mio xaml, voglio solo associare questa proprietà statica a una TextBox:

<TextBox>
    <TextBox.Text>
        <Binding Source="{x:Static local:VersionManager.FilterString}"/>
    </TextBox.Text>
</TextBox>

Tutto viene compilato, ma in fase di esecuzione ottengo la seguente eccezione:

Impossibile convertire il valore nell'attributo 'Origine' in oggetto di tipo 'System.Windows.Markup.StaticExtension'. Errore nell'oggetto "System.Windows.Data.Binding" nel file di markup "BurnDisk; component / selectversionpagefunction.xaml" Riga 57 Posizione 29.

Hai idea di cosa sto facendo di sbagliato?

Se l'associazione deve essere bidirezionale, è necessario fornire un percorso. Esiste un trucco per eseguire l'associazione bidirezionale su una proprietà statica, a condizione che la classe non sia statica: dichiarare un'istanza fittizia della classe nelle risorse e utilizzarla come origine dell'associazione.

<Window.Resources>
    <local:VersionManager x:Key="versionManager"/>
</Window.Resources>
...

<TextBox Text="{Binding Source={StaticResource versionManager}, Path=FilterString}"/>

Non puoi legare a una statica del genere. Non è possibile che l'infrastruttura di binding venga informata degli aggiornamenti poiché non sono coinvolti DependencyObject(o istanze di oggetti che implementano INotifyPropertyChanged).

Se quel valore non cambia, basta abbandonare l'associazione e utilizzare x:Staticdirettamente all'interno della Textproprietà. Definire di appseguito la posizione dello spazio dei nomi (e dell'assembly) della classe VersionManager.

<TextBox Text="{x:Static app:VersionManager.FilterString}" />

Se il valore cambia, suggerirei di creare un singleton per contenere il valore e associarlo a quello.

Un esempio del singleton:

public class VersionManager : DependencyObject {
    public static readonly DependencyProperty FilterStringProperty =
        DependencyProperty.Register( "FilterString", typeof( string ),
        typeof( VersionManager ), new UIPropertyMetadata( "no version!" ) );
    public string FilterString {
        get { return (string) GetValue( FilterStringProperty ); }
        set { SetValue( FilterStringProperty, value ); }
    }

    public static VersionManager Instance { get; private set; }

    static VersionManager() {
        Instance = new VersionManager();
    }
}

<TextBox Text="{Binding Source={x:Static local:VersionManager.Instance},
                        Path=FilterString}"/>

In .NET 4.5 è possibile associare proprietà statiche, leggi di più

È possibile utilizzare le proprietà statiche come origine di un'associazione dati. Il motore di associazione dei dati riconosce quando il valore della proprietà cambia se viene generato un evento statico. Ad esempio, se la classe SomeClass definisce una proprietà statica chiamata MyProperty, SomeClass può definire un evento statico che viene generato quando cambia il valore di MyProperty. L'evento statico può utilizzare una delle seguenti firme:

public static event EventHandler MyPropertyChanged; 
public static event EventHandler<PropertyChangedEventArgs> StaticPropertyChanged; 

Si noti che nel primo caso, la classe espone un evento statico denominato PropertyNameChanged che passa EventArgs al gestore eventi. Nel secondo caso, la classe espone un evento statico denominato StaticPropertyChanged che passa PropertyChangedEventArgs al gestore eventi. Una classe che implementa la proprietà statica può scegliere di aumentare le notifiche di modifica della proprietà usando entrambi i metodi.

A partire da WPF 4.5 è possibile associare direttamente a proprietà statiche e fare in modo che l'associazione si aggiorni automaticamente quando si modifica la proprietà. È necessario collegare manualmente un evento di modifica per attivare gli aggiornamenti dell'associazione.

public class VersionManager
{
    private static String _filterString;        

    /// <summary>
    /// A static property which you'd like to bind to
    /// </summary>
    public static String FilterString
    {
        get
        {
            return _filterString;
        }

        set
        {
            _filterString = value;

            // Raise a change event
            OnFilterStringChanged(EventArgs.Empty);
        }
    }

    // Declare a static event representing changes to your static property
    public static event EventHandler FilterStringChanged;

    // Raise the change event through this static method
    protected static void OnFilterStringChanged(EventArgs e)
    {
        EventHandler handler = FilterStringChanged;

        if (handler != null)
        {
            handler(null, e);
        }
    }

    static VersionManager()
    {
        // Set up an empty event handler
        FilterStringChanged += (sender, e) => { return; };
    }

}

Ora puoi associare la tua proprietà statica come qualsiasi altra:

<TextBox Text="{Binding Path=(local:VersionManager.FilterString)}"/>

Potrebbero esserci due modi / sintassi per associare una staticproprietà. Se p è una staticproprietà nella classe MainWindow, allora bindingper textboxsarà:

1.

<TextBox Text="{x:Static local:MainWindow.p}" />

2.

<TextBox Text="{Binding Source={x:Static local:MainWindow.p},Mode=OneTime}" />

Puoi usare la ObjectDataProviderclasse e la sua MethodNameproprietà. Può assomigliare a questo:

<Window.Resources>
   <ObjectDataProvider x:Key="versionManager" ObjectType="{x:Type VersionManager}" MethodName="get_FilterString"></ObjectDataProvider>
</Window.Resources>

Il fornitore di dati oggetto dichiarato può essere utilizzato in questo modo:

<TextBox Text="{Binding Source={StaticResource versionManager}}" />

Se si utilizzano risorse locali, è possibile fare riferimento a queste come di seguito:

<TextBlock Text="{Binding Source={x:Static prop:Resources.PerUnitOfMeasure}}" TextWrapping="Wrap" TextAlignment="Center"/>

Variante giusta per .NET 4.5 +

Codice C #

public class VersionManager
{
    private static string filterString;

    public static string FilterString
    {
        get => filterString;
        set
        {
            if (filterString == value)
                return;

            filterString = value;

            StaticPropertyChanged?.Invoke(null, FilterStringPropertyEventArgs);
        }
    }

    private static readonly PropertyChangedEventArgs FilterStringPropertyEventArgs = new PropertyChangedEventArgs (nameof(FilterString));
    public static event PropertyChangedEventHandler StaticPropertyChanged;
}

Rilegatura XAML (attenzione alle parentesi graffe che sono (), non {})

<TextBox Text="{Binding Path=(yournamespace:VersionManager.FilterString)}" />

Guarda il mio progetto CalcBinding , che ti fornisce la scrittura di espressioni complesse nel valore della proprietà Path, tra cui proprietà statiche, proprietà di origine, matematica e altro. Quindi, puoi scrivere questo:

<TextBox Text="{c:Binding local:VersionManager.FilterString}"/>

In bocca al lupo!

Queste risposte sono tutte buone se vuoi seguire buone convenzioni, ma l'OP voleva qualcosa di semplice , che è anche quello che volevo invece di occuparmi dei modelli di progettazione della GUI. Se tutto quello che vuoi fare è avere una stringa in un'app GUI di base che puoi aggiornare ad hoc senza nulla di speciale, puoi semplicemente accedervi direttamente nel tuo sorgente C #.

Supponiamo che tu abbia un'app WPF davvero semplice MainWindow XAML come questa,

<Window x:Class="MyWPFApp.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:MyWPFApp"
            mc:Ignorable="d"
            Title="MainWindow"
            Height="200"
            Width="400"
            Background="White" >
    <Grid>
        <TextBlock x:Name="textBlock"                   
                       Text=".."
                       HorizontalAlignment="Center"
                       VerticalAlignment="Top"
                       FontWeight="Bold"
                       FontFamily="Helvetica"
                       FontSize="16"
                       Foreground="Blue" Margin="0,10,0,0"
             />
        <Button x:Name="Find_Kilroy"
                    Content="Poke Kilroy"
                    Click="Button_Click_Poke_Kilroy"
                    HorizontalAlignment="Center"
                    VerticalAlignment="Center"
                    FontFamily="Helvetica"
                    FontWeight="Bold"
                    FontSize="14"
                    Width="280"
            />
    </Grid>
</Window>

Sarà simile a questo:

Nella fonte XAML di MainWindow, potresti avere qualcosa del genere in cui tutto ciò che facciamo nel modificare il valore direttamente tramite textBlock.Textla funzionalità get/ set:

using System.Windows;

namespace MyWPFApp
{
    public partial class MainWindow : Window
    {
        public MainWindow() { InitializeComponent(); }

        private void Button_Click_Poke_Kilroy(object sender, RoutedEventArgs e)
        {
            textBlock.Text = "              \\|||/\r\n" +
                             "              (o o) \r\n" +
                             "----ooO- (_) -Ooo----";
        }
    }
}

Quindi quando attivi quell'evento click facendo clic sul pulsante, voilà! Kilroy appare :)

Un'altra soluzione è quella di creare una classe normale che implementa PropertyChanger in questo modo

public class ViewProps : PropertyChanger
{
    private string _MyValue = string.Empty;
    public string MyValue
    {
        get { 
            return _MyValue
        }
        set
        {
            if (_MyValue == value)
            {
                return;
            }
            SetProperty(ref _MyValue, value);
        }
    }
}

Quindi crea un'istanza statica della classe da qualche parte che non vuoi

public class MyClass
{
    private static ViewProps _ViewProps = null;
    public static ViewProps ViewProps
    {
        get
        {
            if (_ViewProps == null)
            {
                _ViewProps = new ViewProps();
            }
            return _ViewProps;
        }
    }
}

E ora usalo come proprietà statica

<TextBlock  Text="{x:Bind local:MyClass.ViewProps.MyValue, Mode=OneWay}"  />

Ed ecco l'implementazione di PropertyChanger, se necessario

public abstract class PropertyChanger : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected bool SetProperty<T>(ref T storage, T value, [CallerMemberName] string propertyName = null)
    {
        if (object.Equals(storage, value)) return false;

        storage = value;
        OnPropertyChanged(propertyName);
        return true;
    }

    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

Risposta più snella (.net 4.5 e successive):

    static public event EventHandler FilterStringChanged;
    static string _filterString;
    static public string FilterString
    {
        get { return _filterString; }
        set
        {
            _filterString= value;
            FilterStringChanged?.Invoke(null, EventArgs.Empty);
        }
    }

e XAML:

    <TextBox Text="{Binding Path=(local:VersionManager.FilterString)}"/>

Non trascurare le parentesi