Liaison à une propriété statique

J'ai du mal à lier une simple propriété de chaîne statique à un TextBox.

Voici la classe avec la propriété static:

public class VersionManager
{
    private static string filterString;

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

Dans mon xaml, je veux juste lier cette propriété statique à un TextBox:

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

Tout se compile, mais au moment de l'exécution, j'obtiens l'exception suivante:

Impossible de convertir la valeur de l'attribut «Source» en objet de type «System.Windows.Markup.StaticExtension». Erreur à l'objet 'System.Windows.Data.Binding' dans le fichier de balisage 'BurnDisk; component / selectversionpagefunction.xaml' Ligne 57 Position 29.

Une idée de ce que je fais mal?

Si la liaison doit être bidirectionnelle, vous devez fournir un chemin.

Il existe une astuce pour effectuer une liaison bidirectionnelle sur une propriété statique, à condition que la classe ne soit pas statique: déclarez une instance factice de la classe dans les ressources et utilisez-la comme source de la liaison.

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

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

Vous ne pouvez pas vous lier à une statique comme celle-là. Il n'y a aucun moyen pour l'infrastructure de liaison d'être notifiée des mises à jour, car aucune DependencyObjectinstance (ou instance d'objet implémentée INotifyPropertyChanged) n'est impliquée.

Si cette valeur ne change pas, abandonnez simplement la liaison et utilisez x:Staticdirectement à l'intérieur de la Textpropriété. Définissez appci-dessous l'emplacement de l'espace de noms (et de l'assembly) de la classe VersionManager.

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

Si la valeur change, je suggère de créer un singleton pour contenir la valeur et s'y lier.

Un exemple du 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}"/>

Dans .NET 4.5, il est possible de se lier à des propriétés statiques, en savoir plus

Vous pouvez utiliser des propriétés statiques comme source d'une liaison de données. Le moteur de liaison de données reconnaît quand la valeur de la propriété change si un événement statique est déclenché. Par exemple, si la classe SomeClass définit une propriété statique appelée MyProperty, SomeClass peut définir un événement statique qui est déclenché lorsque la valeur de MyProperty change. L'événement statique peut utiliser l'une des signatures suivantes:

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

Notez que dans le premier cas, la classe expose un événement statique nommé PropertyNameChanged qui transmet EventArgs au gestionnaire d'événements. Dans le second cas, la classe expose un événement statique nommé StaticPropertyChanged qui transmet PropertyChangedEventArgs au gestionnaire d'événements. Une classe qui implémente la propriété statique peut choisir de déclencher des notifications de modification de propriété à l'aide de l'une ou l'autre méthode.

À partir de WPF 4.5, vous pouvez vous lier directement aux propriétés statiques et mettre à jour automatiquement la liaison lorsque votre propriété est modifiée. Vous devez câbler manuellement un événement de modification pour déclencher les mises à jour de liaison.

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; };
    }

}

Vous pouvez maintenant lier votre propriété statique comme n'importe quelle autre:

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

Il peut y avoir deux manières / syntaxe de lier une staticpropriété. Si p est une staticpropriété de la classe MainWindow, alors bindingfor textboxsera:

1.

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

2.

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

Vous pouvez utiliser la ObjectDataProviderclasse et sa MethodNamepropriété. Cela peut ressembler à ceci:

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

Le fournisseur de données d'objets déclaré peut être utilisé comme ceci:

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

Si vous utilisez des ressources locales, vous pouvez vous y référer comme ci-dessous:

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

Variante appropriée pour .NET 4.5 +

Code 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;
}

Liaison XAML (attention aux accolades qu'ils sont (), pas {})

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

Regardez mon projet CalcBinding , qui vous permet d'écrire des expressions complexes dans la valeur de la propriété Path, y compris les propriétés statiques, les propriétés source, Math et autres. Donc, vous pouvez écrire ceci:

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

Bonne chance!

Ces réponses sont toutes bonnes si vous voulez suivre de bonnes conventions mais que l'OP voulait quelque chose de simple , ce que je voulais aussi au lieu de traiter des modèles de conception d'interface graphique. Si tout ce que vous voulez faire est d'avoir une chaîne dans une application graphique de base, vous pouvez mettre à jour ad hoc sans rien de compliqué, vous pouvez simplement y accéder directement dans votre source C #.

Disons que vous avez une application WPF vraiment basique MainWindow XAML comme celle-ci,

<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>

Cela ressemblera à quelque chose comme ceci:

Dans la source de votre MainWindow XAML, vous pourriez avoir quelque chose comme ceci où tout ce que nous faisons pour changer la valeur directement via textBlock.Text's get/ setfeature:

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----";
        }
    }
}

Ensuite, lorsque vous déclenchez cet événement de clic en cliquant sur le bouton, le tour est joué! Kilroy apparaît :)

Une autre solution consiste à créer une classe normale qui implémente PropertyChanger comme ceci

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

Ensuite, créez une instance statique de la classe quelque part que vous ne voudrez pas

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

Et maintenant, utilisez-le comme propriété statique

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

Et voici l'implémentation de PropertyChanger si nécessaire

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));
    }
}

Réponse la plus simple (.net 4.5 et versions ultérieures):

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

et XAML:

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

Ne négligez pas les parenthèses