WPF zugriff auf TextBox mit Statischer Methode

[Bärnd (Gast)]

Hi,

ich möchte einen TextBlock aus einer Statischen Methode befüllen. Geht 
sowas überhaupt?

meine erste Idee war ein "Binding" zu erstellen

public static string wert { get; set; }

Text="{Binding wert, RelativeSource={RelativeSource FindAncestor, AncestorType=Window}}"

aber das Binding wird zwar bei der Initialisierung abgefragt, ignoriert 
aber spätere Änderungen...

ein Direktzugriff auf TextBlock1.Text = "blah" bekomme ich ja aus einer 
Statischen Methode nicht...

Vielen Dank für jeden Tipp

bärnd

[Torben (Gast)]

Hallo, wieso statisches Binding?


Wenn du das MVVM Pattern benutzt, dann kannst Du deine Eigenschaft 
einfach binden.

public string Text {get;set;}

Natürlich müsstest Du in dem ViewModel das INotifiyPropertChanged 
implementieren und oben wie in meinem Beispiel Fody.PropertyChanged für 
das AutoProperty.

[Torben (Gast)]

Hier ein Beispiel mit MVVM Light

http://www.codingfreaks.de/2016/03/28/wpf-und-mvvm-richtig-einsetzen-teil-1/

Ich empfehle aber lieber Prism, aber der Einstieg ist nicht so leicht.

https://github.com/PrismLibrary

[Bärnd (Gast)]

naja, es geht nicht um den Static wert, sondern um meine Methode welche 
Statisch sein muss... und von dieser Methode möchte ich ein Textfeld 
beschreiben...

private static StaticMethode() {
   //do anything


   ... write to TextBlock on wpf ...


}

[Ralle (Gast)]

Was ist das für eine statische Methode? Nicht zufällig eine der 
Changed-Callbacks eines Dependency- oder AttachedPropertys? Das könnte 
man schöner lösen.

Ansonsten könntest du ein Singleton-Objekt bauen, dass 
INotifyPropertyChanged implementiert. Auf dieses kannst du das Binding 
beziehen und es innerhalb der statischen Methode manipulieren.

XAML (siehe Binding vom Text-Property des TextBlocks):

<Window x:Class="WpfApplication7.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:local="clr-namespace:WpfApplication7">
    <Grid>
        <TextBlock Text="{Binding Path=Text, Source={x:Static local:SingletonClass.Instance}}" />
        <Button Click="Button_Click" HorizontalAlignment="Right" VerticalAlignment="Bottom">Test</Button>
    </Grid>
</Window>

Code Behind (siehe StaticMethode()):

using System.ComponentModel;
using System.Windows;

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

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            StaticMethode();
        }

        private static void StaticMethode()
        {
            SingletonClass.Instance.Text = "So geht's.";
        }
    }

    public class SingletonClass : INotifyPropertyChanged
    {
        private SingletonClass() { }

        private static SingletonClass instance;
        public static SingletonClass Instance { get { return instance ?? (instance = new SingletonClass()); } }

        private string text;
        public string Text
        {
            get { return text; }
            internal set
            {
                if (text != value)
                {
                    text = value;
                    OnPropertyChanged(new PropertyChangedEventArgs("Text"));
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, e);
            }
        }
    }
}

[Bärnd (Gast)]

unendlich geil...

danke ;) <- genau so läuft das wie ich das will

[Bärnd (Gast)]

Hi,

gibt es eine Möglichkeit das ganze in den 2 Way-Mode zu bekommen?

also ich möchte statt nen TextBlock eine TextBox verwenden und in die 
TextBox geschriebene Informationen in die Singletone-Class zu 
übertragen?

Vielen Dank

[Ralle (Gast)]

Ja, den Setter vom Text-Property public machen und das Binding ändern:

<TextBox Text="{Binding Path=Text, Source={x:Static local:SingletonClass.Instance}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />

Das, was man in die TextBox eingibt, wird in das Text-Property vom 
Singleton geschrieben.

[Bärnd (Gast)]

Hi,

ich habe das Singleton-Object noch etwas erweitert und möchte es auch 
Serialisieren <- damit ich die Daten speichern und laden kann...

das ganze funktioniert aber nicht sooooo gut...
hier mein Singleton:

[Serializable]
public class Singleton : INotifyPropertyChanged
{
  private readonly List<Delegate> _serializableDelegates;

  private static Singleton instance;
  private Singleton()
  {
    _serializableDelegates = new List<Delegate>();
  }

  public static Singleton Instance
  {
    get
    {
      if (instance == null)
      {
        instance = new Singleton();
      }
      return instance;
    }
  }

  public DataTable MyTable { get; set; }
  public bool AdminMode = false;

  private string text;
  public string Text
  {
    get { return text; }
    set
    {
      if (text != value)
      {
        text = value;
        OnPropertyChanged(new PropertyChangedEventArgs("Text"));
      }
    }
  }

  [field: NonSerialized]
  public event PropertyChangedEventHandler PropertyChanged;
  protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
  {
    PropertyChanged?.Invoke(this, e);
  }

  protected void OnPropertyChanged(string propertyName)
  {
    OnPropertyChanged(new PropertyChangedEventArgs(propertyName));
  }

  [OnSerializing]
  private void OnSerializing(StreamingContext context)
  {
    _serializableDelegates.Clear();
    var handler = PropertyChanged;

    if (handler != null)
    {
      foreach (var invocation in handler.GetInvocationList())
      {
        if (invocation.Target.GetType().IsSerializable)
        {
          _serializableDelegates.Add(invocation);
        }
      }
    }
  }

  [OnDeserialized]
  private void OnDeserialized(StreamingContext context)
  {
    foreach (var invocation in _serializableDelegates)
    {
      PropertyChanged += (PropertyChangedEventHandler)invocation;
    }
  }
}

und hier mein Laden und Speichern

private void SaveObject(object obj, string fileName)
{
  try
  {
    using (MemoryStream ms = new MemoryStream())
    {
      BinaryFormatter bf = new BinaryFormatter();
      bf.Serialize(ms, obj);

      using (FileStream file = new FileStream(fileName, FileMode.Create, FileAccess.Write))
      {
        ms.WriteTo(file);
      }
    }
  }
  catch(Exception ex)
  {
    MessageBox.Show(ex.Message);
  }

}

private object LoadObject(string fileName)
{
  if (File.Exists(fileName))
  {
    try
    {
      using (FileStream file = new FileStream(fileName, FileMode.Open, FileAccess.Read))
      {
        byte[] bytes = new byte[file.Length];
        file.Read(bytes, 0, (int)file.Length);

        try
        {
          using (MemoryStream ms = new MemoryStream())
          {
            BinaryFormatter bf = new BinaryFormatter();
            ms.Write(bytes, 0, (int)file.Length);
            ms.Position = 0;

            return bf.Deserialize(ms);
          }
        }
        catch(Exception ex)
        {
          MessageBox.Show("MS: " + ex.Message);
        }
      }
    }
    catch (Exception ex)
    {
      MessageBox.Show("Loader: " + ex.Message);
    }
  }
  return null;
}

der Fehler hier ist, dass er zwar schon einiges speichert, aber beim 
Laden nicht mehr die Felder richtig befüllt (somit befürchte ich, dass 
das Speichern schon nicht ganz Korrekt ist)

Hat jemand eine Idee für mich?

Vielen Dank

[Bärnd (Gast)]

Hi,

also ich habe nochmal die Felder abgegriffen.
=> vom Prinzip wird alles richtig gespeichert und auch geladen.

=> nur mein INotifyPropertyChanged funktioniert dann nicht mehr.
d.h. weder die Felder in der Oberfläche werden befüllt, noch kann ich 
Werte in den Feldern eintragen welche dann Sauber in das Singleton 
geladen werden...

[Ralle (Gast)]

LoadObject liefert ja ein neues Objekt vom Typ Singleton. Dieses wird 
aber nirgends dem static field "instance" zugewiesen.Brächte aber auch 
nichts, da man das static Property "Instance" ja kein PropertyChanged 
feuern lassen kann. Das Binding bezöge sich weiterhin auf das 
Urpsrungs-Singleton-Objekt.

Ich kenn die Umstände nicht näher, aber ich würde an dieser Stelle eher 
versuchen, das alte Singleton-Objekt mit den Daten des neuen Objekts 
upzudaten. Also z.B. so:

...
var deserializedSingleton = (Singleton)LoadObject("dateiname.dat");
Singleton.Instance.Update(deserializedSingleton);
...

Die Update-Methode könnte so aussehen:

private void Update(Singleton newObject)
{
    text = newObject.text; // hier nur Fields zuweisen, keine Properties
    [...] = newObject.[...];

    OnPropertyChange(new PropertyChangedEventArgs(null)); // Komplettänderung melden
}

Bei PropertyChangedEventArgs mit null oder "" eventuell nochmal 
recherchieren. Ich glaub, da gab es eine Empfehlung ab einer bestimmten 
.NET-Version...

[Bärnd (Gast)]

Hi,

sorry, dass ich erst jetzt zurückschreibe - war unterwegs...

Erstmal "vielen Dank", das funktioniert Großartig!

nun stellt sich aber die Frage, ob ich wirklich ALLE Objekte erneut 
auflisten muss, oder ob man das irgendwie Automatisieren kann?

meine Idee war eine schleife, welche alle Objekte vom alten Objekt 
durchläuft und mit dem neuen verknüpft (die Objekte können ja [von der 
Struktur] niemals unterschiedlich sein).

foreach(FieldInfo field in this.GetType().GetFields()) 
{
   field = newObject.[field.name]

}

<- aber genau da hat mein Ansatz Lücken.

kann man das Automatisieren?
Vielen Dank

[Roger S. (edge)]

Pack die Daten die Du anzeigen willst in eine eigene Klasse. Spendiere 
Deinem Singleton das du als data model misbrauchst ein Property fuer die 
Daten, also z.B.:

class Singleton : INotifyPropertyChanged
{
        [DataContract]
        public class Data
        {
            [DataMember]
            public string Text { get; set; }
        }

        Data _data;
        public Data Item { get => _data; set { _data = value; NotifyPropertyChanged(); } }

        public void Load()
        {
            /* load data */
            Item = /* deserialized Data object*/
        }
}

im xaml passt du den Pfad an (Item.Text statt Text).

Serialisieren/Deserialisieren tust du nun nur die Klasse mit den Daten 
und nicht das Singleton. Durch den Setter des Item property werden alle 
die auf Item.* binden updated.

NotifyPropertyChanged() zur Vollstaendigkeit:

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

Cheers, Roger

[Bärnd (Gast)]

Danke für die guten und Netten Tipps hier ;)

leider stell ich mich sehr an...

ich habe jetzt das Singleton mal komplett aufgebaut wie von Roger 
beschrieben:

> <TextBox Text="{Binding Path=Item.Text, Source={x:Static 
local:Singleton.Instance}, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />

public class Singleton : INotifyPropertyChanged
{
  public class Data
  {
    public string Text { get; set; }
  }

  private Data _data = new Data();
  public Data Item
  {
    get => _data;
    set
    {
      _data = value;
      NotifyPropertyChanged();
    }
  }

  public event PropertyChangedEventHandler PropertyChanged;
  protected virtual void NotifyPropertyChanged([CallerMemberName] String propertyName = "")
  {
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
  }

  private Singleton() { }

  private static Singleton instance;
  public static Singleton Instance { get { return instance ?? (instance = new Singleton()); } }

}

Das Serialisieren und Deserialisieren habe ich noch nicht implementiert, 
soweit bin ich noch nicht
zwar werden die Eingaben sauber erkannt und dem Singleton übergeben, 
aber die "Backendseitigen" Eingaben und Änderungen werden nicht ans XAML 
übergeben.
=> das TextFeld bleibt leer!

die Markierungen [DataContract] und [DataMember] konnte ich nicht 
übergeben, ebenso musste ich aus Data _data; private Data _data = new 
Data(); machen, damit überhaupt was ging...

*sorry, für die teils "doofen" Fragen*

Vielen Vielen Dank

[Roger S. (edge)]

Bärnd schrieb:

> zwar werden die Eingaben sauber erkannt und dem Singleton übergeben,
> aber die "Backendseitigen" Eingaben und Änderungen werden nicht ans XAML
> übergeben.

was heisst "Backendseitigen" Eingaben?

Initiale Werte kannst du beim erstellen des Data Object mitgeben, also

private Data _data = new Data() { Text = "Blah" };

und das sollte im GUI erscheinen. Wenn Du die Data properties 'im 
Betrieb' veraenderst, dann musst du das dem GUI auch mitteilen -> 
INotifyPropertyChanged.
Entweder die Data Klasse implementiert INotifyPropertyChanged, oder wenn 
du damit leben kannst dass alle Properties auf einmal refresht werden:

public class Singleton : INotifyPropertyChanged
{
        /* ... */

        public void Modify()
        {
            Item.Text = "Modified";
            /* modify some more... */

            NotifyPropertyChanged("Item");
        }
}

> die Markierungen [DataContract] und [DataMember] konnte ich nicht
> übergeben,

[DataContract]/[DataMember] sind Attribute von System.ComponentModel,
helfen beim serialisieren/deserialisieren.

> ebenso musste ich aus Data _data; private Data _data = new
> Data(); machen, damit überhaupt was ging...

Tschuldigung, es braucht natuerlich ein Objekt damit das ganze laeuft.

> *sorry, für die teils "doofen" Fragen*

Keine Ursache.

Cheers, Roger

[Bärnd (Gast)]

Hm, okay

ja,...

ich versteh aber nicht, warum das in meinem Item nicht funktioniert?

        private Data _data = new Data();
        public Data Item
        {
            get => _data;
            set
            {
                _data = value;
                NotifyPropertyChanged("Item");
            }
        }

        public void Modify(Singleton item, string value)
        {
            //Item.Text = "Modified";
            Item.Text = "as";

            NotifyPropertyChanged("Item");
        }

wenn ich über mein Main den Aufruf:
> Singleton.Instance.Item.Text = "WertA";

starte, wird dieser in der GUI nicht angezeigt, der Wert aber sauber im 
Singleton vorhanden

wenn ich das Modify aufrufe, wird das sauber auch im GUI angezeigt
> Singleton.Instance.Modify();


ich dachte, wenn ich die _data = value setz.. dann ruft er das 
NotifyPropertyChanged ebenso mit auf?
=> schließlich will ich viele Aktionen über mein "Hauptprogramm" 
aufrufen mit Oberfläche meinte ich die GUI ;)

Serialisieren muss ich dann auch nur
Singleton.Item ? <- dort sind alle meine "Werte"?

beim De-serialisieren, muss ich meine Items updaten, das mach ich über 
die beschriebene Load-Methode...

> Entweder die Data Klasse implementiert INotifyPropertyChanged
was ist damit gemeint?

> wenn du damit leben kannst dass alle Properties auf einmal refresht werden
klingt ein Bisschen so, alsob hiermit "größere" nachteile verbunden 
wären?

Im Endprodukt sollen mal 15 Textfelder und ein paar Datatables, wenige 
Checkboxen und so vorhanden sein... wenn ich jetzt gleichzeitig 30 
Felder refresh sollte auch ein Rechner mit unterer Ausstattung das ohne 
größerer Latzenz verarbeiten können!?

[Roger S. (edge)]

Bärnd schrieb:

> wenn ich über mein Main den Aufruf:
>> Singleton.Instance.Item.Text = "WertA";
>
> starte, wird dieser in der GUI nicht angezeigt, der Wert aber sauber im
> Singleton vorhanden

ja, weil eben nur das Text property in Item veraendert wird, und dies
ist ein simples CLR property, es gibt keine notification zum binding.

das funktioniert aber:

Singleton.Instance.Item = new Singleton.Data { Text = "WertA" };

weil eben das Item property von Singleton das binding ueber 
NotifyPropertyChanged() informiert dass die Werte sich geaendert haben. 
(Ein komplett neues Objekt)


> ich dachte, wenn ich die _data = value setz.. dann ruft er das
> NotifyPropertyChanged ebenso mit auf?

das

> => schließlich will ich viele Aktionen über mein "Hauptprogramm"
> aufrufen mit Oberfläche meinte ich die GUI ;)
>
> Serialisieren muss ich dann auch nur
> Singleton.Item ? <- dort sind alle meine "Werte"?

ja, du deserialiserst ein Data Objekt und dann mittels

Singleton.Instance.Item = deserialisiertesObjekt;

machst du das update des GUI.

>
>> Entweder die Data Klasse implementiert INotifyPropertyChanged
> was ist damit gemeint?

Wenn du willst dass Property-Setter der Data Klasse automatisch die GUI 
updaten,
dann muss die Data Klasse das INotifyPropertyChanged interface 
implementieren und jeder
setter den PropertyChanged event triggern. Analog dem Singleton.

>> wenn du damit leben kannst dass alle Properties auf einmal refresht werden
> klingt ein Bisschen so, alsob hiermit "größere" nachteile verbunden
> wären?

Koennte ein Performance Problem sein wenn du Tausende Bindings hast und 
nur
eines updaten willst.

> Im Endprodukt sollen mal 15 Textfelder und ein paar Datatables, wenige
> Checkboxen und so vorhanden sein... wenn ich jetzt gleichzeitig 30
> Felder refresh sollte auch ein Rechner mit unterer Ausstattung das ohne
> größerer Latzenz verarbeiten können!?

Ja, ohne Problem.

Cheers, Roger

[Bärnd (Gast)]

vielen Dank...

ein kleines Problem existiert noch

zwar kann ich so:

Singleton.Instance.Item = new Singleton.Data { Text = "WertA" };

das Feld Text updaten, würde aber das Feld Text2 logischerweise 
überschreiben...

gibt es auch eine einfache Möglichkeit "nur ein Feld" zu verändern? Oder 
muss ich bei Update von Text auch die alten werte mit übergeben?

Singleton.Instance.Item = new Singleton.Data { 
Text = "WertA",
Text2 = Singleton.Instance.Item.Text2
};

[Bärnd (Gast)]

Singleton.Instance.Item.Text = "Wert3";
//update
Singleton.Instance.Item = Singleton.Instance.Item;

man könnte auch hier eine Updatezeile einfügen...
=> die Frage ist, kann man das auch automatisieren? <- z.B. aus der 
Klasse heraus? <- leider muss die Klasse aber serialisierbar sein

[Roger S. (edge)]

Bärnd schrieb:
> ein kleines Problem existiert noch
>
> gibt es auch eine einfache Möglichkeit "nur ein Feld" zu verändern? Oder
> muss ich bei Update von Text auch die alten werte mit übergeben?

JA, alles oder nichts:

Singleton.Instance.Item = new Singleton.Data {
 Text = "WertA",
 Text2 = Singleton.Instance.Item.Text2
};

Aber da endest du wieder an der Ausgangslage, wo du alle Elemente 
aufzaehlen musst die du kopieren willst. Evtl. macht es Sinn das ein 
wenig zu Abstrahieren und in der Singleton Klasse anzubieten:

class Singleton : /*...*/
{
  /* ... */

  public void UpdateTextForSomeReason(string text)
  {
    Item.Text = text;
    NotifyPropertyChanged("Item");
  }

  public void UpdateName(string first, string last)
  {
    Item.FirstName = first;
    Item.LastName = last;
    NotifyPropertyChanged("Item");
  }
}

Cheers, Roger

[Roger S. (edge)]

Bärnd schrieb:
>

Singleton.Instance.Item.Text = "Wert3";
> //update
> Singleton.Instance.Item = Singleton.Instance.Item;
>

>

Eine Update Methode die NotifyPropertyChanged("Item"); aufruft, waere 
'cleaner':

public void UpdateBinding()
{
    NotifyPropertyChanged("Item");
}

Aber wie gesagt, die use cases im Singleton zu implementieren macht mehr 
sinn.

Cheers, Roger

[Bärnd (Gast)]

  public void UpdateTextForSomeReason(string text)
  {
    Item.Text = text;
    NotifyPropertyChanged("Item");
  }

dann wäre es Fast klug nur das Feld upzudaten, welches ich wirklich 
brauche?

meine Idee war:

        public void Text(string value)
        {
            Item.Text = value;
            NotifyPropertyChanged("Item.Text");
        }

leider ohne erfolg...
Weder nur "Text" als auch "Item.Text" funktioniert.

[Roger S. (edge)]

Bärnd schrieb:

> meine Idee war:
>

        public void Text(string value)
>         {
>             Item.Text = value;
>             NotifyPropertyChanged("Item.Text");
>         }

>
> leider ohne erfolg...
> Weder nur "Text" als auch "Item.Text" funktioniert.

Weil Singleton, welches INotifyPropertyChanged implementiert, eben nur 
ein Property Namens 'Item' beherbergt und nicht 'Item.Text' oder 'Text'. 
Somit ist das binding auf Item (oder in dem Fall Item.*) nur 
angesprochen wenn auch ein notify auf 'Item' erfolgt.

Cheers, Roger

[Hani (Gast)]

Hi Zusammen...

=> super Thread hier,...

ich habe aber ein kleines Problem! Bei mir ist die Singletone-Class in 
einem "Ordner"

Services/Singelton ...

Text="{Binding Path=Item.An, Source={x:Static 
local:Services.Singleton.Init}, Mode=TwoWay, 
UpdateSourceTrigger=PropertyChanged}"

Der Fehler ist "Geschachtelte Typen werden nicht unterstützt"

Lustiger weise funktioniert es trotzdem, aber natürlich will ich den 
Fehler nicht haben

=> Muss ich die Singleton ins Main Verzeichnis schieben? oder kann man 
das irgendwie trotzdem richtig machen?

Vielen Dank
hani

[Roger S. (edge)]

Der Ordner ist hier wurscht, es geht um den namespace.
Du kannst entweder das Singleton in den Namspace wo
local: hinzeigt 'verschieben' (also namespace definition anpassen).
oder, die bevorzugte Loesung, eine XAML namespace definition fuer den
Services CLR namespace einrichten (analog dem local) und die verwenden.

xmlns:services="clr-namespace:[Namespace von local].Services"

...

Text="{Binding Path=Item.An, Source={x:Static services:Singleton.Init}, Mode=TwoWay, 
UpdateSourceTrigger=PropertyChanged}"

Cheers, Roger