Du darfst das ItemsTemplate nicht setzen sondern das Hierarchical aussuchen lassen anhand des DataTypes 😉

<TreeView ItemsSource="{Binding objSerie}">
    <TreeView.Resources>
        <!-- Zeige Serie knoten, childs in Staffeln -->
        <HierarchicalDataTemplate DataType="{x:Type Local:Serie}" ItemsSource="{Binding Staffeln}">
            <TextBlock Text="{Binding Name}" />
        </HierarchicalDataTemplate>
        <!-- Zeige Staffel knoten, childs in Episoden -->
        <HierarchicalDataTemplate DataType="{x:Type Local:Staffel}" ItemsSource="{Binding Episoden}">
            <TextBlock Text="{Binding Name}" />
        </HierarchicalDataTemplate>
        <!-- Zeige Episode knoten, da es keine childs gibt wird ein normales DataTemplate verwendet ohne child items -->
        <DataTemplate DataType="{x:Type Local:Episode}">
            <TextBlock Text="{Binding Name}" />
        </DataTemplate>
    </TreeView.Resources>
</TreeView>

Das ItemsTemplate wird sobald es nicht gesetzt ist automatisch anhand des DataType ermittelt.

IsSynchronizedWithCurrentItem auf true gesetzt in der ListBox?

Das ist das problem des TextBlock Controls, das kann so nicht umbrechen. Da wüsst ich keine elegante lösung außer zwei TextBlocks übereinander zu packen.

Weil du dich irgendwie anstellst ^^

xaml.cs:

public class MyWindow : Window
{
    public MyWindow()
    {
        InitializeComponent();
        DataContext = this; // Damit das Binding weiß wo es suchen muss

        Contacts = new ObservableCollection<Contact>();
        foreach (var contact in FromXml())
            Contacts.Add(contact);
    }

    public ObservableCollection<Contact> Contacts { get; set; }
}

xaml:

<Window ...>
    <ListBox ItemsSource="{Binding Contacts}">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <TextBlock Text="{Binding Name}" /> <!-- Contact.Name anzeigen -->
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>
</Window>

Dafür musst du das Temaple überschreiben und den Button selber sein Aussehen verleihen.

Entwickel doch die Applikation als Windows Widget, die haben deine gewünschte Eigenschaften bereits.

Wenn sich das ContextMenu nicht in einer ItemsCollection befindet, dann kann das Binding aufgelöst werden wenn du das ContextMenu in den Window/UserControl Resourcen definierst.

PS, falls du sehen willst wie ich es mache, der Source ist offen

Das ContextMenu ist nicht im Visual Tree des Fensters, daher schlagen alle Bindings fehl.

<Advertising>
Nimm einfach mein ContextMenuItem
</Advertising>

Aaah, ups, dann liegt kein Problem vor 😁

Habe es in:

• Chrome Version 9.0.597.98. (http://downloads.my-libraries.de/Underline/Chrome.png)
• Firefox 3.6.13 (http://downloads.my-libraries.de/Underline/FF.png)
• IE 8.0.7600.16385 (http://downloads.my-libraries.de/Underline/IE.png)
• Auf 2 verschiedenen PCs
• Windows 7 Home Premoum Deutsch (Daheim)
• Windows 7 Ultimate Englisch (Arbeit)
• Caches usw lösche ich regelmäßig (Eben direkt mal gemacht)

Es werden generell alle Links unterstrichen in:

• Hier

• Heise

• TC Forum

• Golem

• <mehr noch nicht getestet>

• C++ dagegen nicht

Ich würde nicht unbedingt sagen das das ein Bug ist nur auf dieser Seite, evtl ist das by-design auf Win7?
Ich weiß gar nicht ob das schon immer so war, nie darauf geachtet, stört mich aber auch nicht.

In Chrome (neueste Version) ist es auch unterstrichen.

<snip>

public void GetLatest(string path)
{
    Get(path, VersionSpec.Latest);
}

public void GetLabeled(string path, string labelName)
{
    Get(path, new LabelVersionSpec(labelName));
}

private void Get(string path, VersionSpec versionSpec)
{
    var request = new GetRequest(new ItemSpec(path, RecursionType.Full), versionSpec);
    var status = _workspace.Get(request, GetOptions.GetAll | GetOptions.Overwrite);
}

</snip>

//Tags vergessen

Davon ist nicht nur Linq betroffen, sondern Extension Methods im allgemeinen.
Macht auch sinn, wenn es möglich wäre, dann müsste VS alle dlls und namespaces bei allen Klassen nach potentiellen Extension Methods durchsuchen ^^

Die InputBindings sind erst ab .Net 4 Bindbar.

http://msdn.microsoft.com/en-us/library/bb613588.aspx Siehe Binding

Also der Fehler wird auftreten wenn er das Control nicht erstellen kann - warum das wissen nur die Götter ^^

Brauchst du diesen Designer denn unbedingt? Viele WPF Entwickler haben nur noch die Full Xaml View und ignorieren den Designer völlig, so auch ich.

Konstruktor (ctor ist der Snippet zum erstellen ^^)

Wenn die Klasse im selben Projekt ist, dann braucht man ";assembly" nicht angeben, dann wäre es (glaub ich) sogar falsch es zu tun, hab da was dunkel in erinnerung.

Du schreibst was es im Laufenden Betrieb geht, passiert etwas im ctor der HierarchicalItemView Klasse? Der Designer durchläuft den kompletten initialisierungscode beim aufbau der View.

"Für XAML-Dateien, die nicht Bestandteil eines Projekts sind, muss eine Assembly angegeben werden"
Das sagt doch eindeutig das das "assembly;bla" fehlt
Wenn deine dll Datei ein Leerzeichen enthält ist das kein Problem.

VS hilft dir normalerweise auch immer beim auflösen des namespaces, man muss es eigentlich nie komplett von Hand schreiben.

Egal wie ich es referenziere

Es gibt mehrere Wege?

1. Die dll bei den Projekt referenzen hinzufügen
2. das xmlns hinzufügen
   xmlns:MyName= <nun zeigt VS eine liste wo du dein namespace nur raussuchen musst> das endet dann normalerweise in ein:
   xmlns:MyName="clr-namespace:MyNamespace;assembly=My Assembly"

Das Tag "HierarchicalItemView" ist im XML-Namespace "clr-namespace:Namespace" nicht vorhanden.

Du hast ein namespace namens "Namespace"?

1. Sei sicher das der Name korrekt ist
2. Schau das dein "HierarchicalItemView" sich in diesen namespace befindet
3. Stell sicher das "HierarchicalItemView" auch public ist
4. Überprüfen zudem das die .dll Datei die selbe .Net Version verwendet wie dein Projekt (es geht nur Abwärtskompatibel)

1. Eine TreeView hat keine "Spalten", was du suchst ist evtl eine TreeListView?

2. Im ItemTemplate kannst du ein HiraricalDataTemplate definieren und das aussehen Festlegen sowie angeben wo sich die Childs befinden (ItemsSource). Besser ist aber HiraricalDataTemplates für die verschiedenen DataTypes in den TreeView resourcen zu definieren, dann hast du je nach Child Typ ein eigenes aussehen und kannst auch weiteres suchen in einer Tiefe unterbinden.

In meiner EnhancedTreeView siehst du eine einfache Demo. Ansonsten ist die MSDN immer dein Freund.

[
3. Definiere nie feste größen "Width", "Height" usw -> Böse
4. Den DataContext kannst du auch mit DataContext="{Binding ElementName=this}" binden
5. HorizontalAlignment, VerticalAlignment und die Margins sind so (ziemlich) schrecklich, schau dir am besten mal die Panels richtig an, und wie man in WPF ein Fenster mit denen aufbaut.
]

ich selber Lese und Speicher immer direkt in der Englischen Culture "new CultureInfo(1033)".

Was du aber auch machen kannst, speicher beim schreiben die CultureInfo mit in die Xml Datei als Zusatzinformation 😄 spätestens beim Schreiben hast du ja eine Current[UI]Culture.

Ich hab mich mit dem Thema noch gar nicht beschäftigt, vielmehr den Reflector als gegeben hingenommen.
Darum frage ich mich gerade, gibt es überhaupt eine alternative?

(Wenn man ehrlich ist hätte man es so kommen sehen können)

@Foufou
Das Problem wird sein das du nur Strings als Objekte rein packst, wenn du dann 2x den selben info String rein schiebst (selber Inhalt, nicht selbe Referenz) dann findet die ListBox es mehrfach und scrollt nur zum ersten.

Lösung: Ein eigenes Objekt in der Liste halten statt nur den String, damit sie auch unterschiedlich sind.

Stalkt ihr herb gerade? ^^

So ist die Trennung schon klarer.

Zum Thema Implementation muss man nun überlegen.

1. Geht es auch bei geschlossenen Themen?
2. Es muss sichergestellt werden das man nicht seine eigene Antwort "bewertet".
3. Nicht alles ist eine Lösung eines Problems, dieses System macht bei normalen Diskussionsbeiträgen keinen sinn, es müsste also individuell ein und ausschaltbar sein.
4. Was ist wenn der Beitrag Editiert wurde, dann müssten alle Befürworter benachrichtigt werden.
5. Was ist mit den Benutzern die E-Mail Benachrichtigung nicht aktiv haben, so wie ich? Sehr aktive Menschen (nicht ich ^^) würden doch eher zu "gespammt" werden und haben es deswegen deaktiviert.
6. Wer hat die Zeit und die Fähigkeit das zu implementieren?

++Support

Ich fände das auf jeden Fall ein Qualitätsanstieg, wenn ich eine Antwort sehe wo schon andere (im dem bereich bekannte namen) ihre Zustimmung gaben, dann geh ich eher davon aus das es eine gute Lösung war.

Wenn es zu einer Frage nur eine Antwort gibt, weiß ich nicht direkt ob die anderen nichts schreiben weil sie es nicht wissen, oder nichts schreiben weil sie "still zustimmen".

1 Person(en) fanden die Antwort hilfreich: tonikln
2 Person(en) befürworten die Antwort: Tomot, herbivore

Wenn ich das sehe wüsste ich gar nicht welches ich klicken sollte, ist das nicht eventuell zuviel?

Das würde doch reichen:
3 Person(en) fanden die Antwort hilfreich: tonikln, Tomot, herbivore

Das kann dann als kleine Zeile unter dem Beitrag, und das "Zustimmen" und "Zustimmen entziehen" (Buttontext wechselt) könnte oben rechts neben den Zitieren Button.

[CI Builds right?]

Die Projekt assemblies müssten eigentlich bei der Applikation liegen, ansonsten kann man bei den settings der build auch ein "Drop Folder" Verzeichnis angeben, dann kopiert er es dort rein.

Grad auch gefunden: TFS 2010 C++ Builds, no output in "Binaries" directory after buil

Nein das meint er nicht, denn schau mal genau hin, er fügt die Items direkt mit Nummer ein:

public FooList()
{
	for( int i = 0; i < 10; i++ )
		this.Add( new Foo( "Foo " + i ) );
}

Hier ging es aber um die Möglichkeit Items zu nummerieren ohne deren Daten zu ändern.

Nicht direkt nein, aber über ein Converter

z.B.:

public class ItemLineNumbersConverter : IValueConverter
{
	public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
	{
		var item = value as ListBoxItem;
		var view = (ListBox)ItemsControl.ItemsControlFromItemContainer(item);
		return view.ItemContainerGenerator.IndexFromContainer(item) + 1;
	}

	public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
	{
		throw new NotImplementedException();
	}
}

<UserControl.Resources>
	<Pages:ItemLineNumbersConverter x:Key="ItemLineNumbersConverter" />
</UserControl.Resources>

<ListBox ItemsSource="{Binding Items}">
	<ListBox.ItemTemplate>
		<DataTemplate>
			<StackPanel Orientation="Horizontal">
				<TextBlock FontStyle="Italic" Foreground="Gray" Text="{Binding Converter={StaticResource ItemLineNumbersConverter}, RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type ListBoxItem}}}" Margin="0,0,10,0" />
				<TextBlock Text="{Binding Name}" />
			</StackPanel>
		</DataTemplate>
	</ListBox.ItemTemplate>
</ListBox>

ich sehe das so, dass die Generic.xaml nicht erkannt wird.

Korrekt

Du hast du Datei nirgends angegeben

Das muss er auch nicht, dafür ist es ja das Themes.

Versuch mal den Code aus der Generic.xaml in die App.xaml zu packen. Dann sollte es eigentlich funktionieren.

Wird funktionieren, aber so macht man das nicht.

@mctimotheus
Der Themes Ordner muss im Projekt root finden, erst dann wird es durch die ThemeInfo (Attribut im AssemblyInfo.cs) auch gefunden.

http://msdn.microsoft.com/de-de/library/ms745025.aspx

Nur als Idee.
Eventuell kannst du im ItemContainerStyle ein Trigger einbauen der auf "IsExpanded" lauscht und dann das Template umdefiniert.

Das Liegt daran das die TreeView in WPF ihre Items nicht virtualisiert.
Ich habe mich selber damit noch nicht beschäftigt, aber eventuell bringt diese Anleitung etwas:
Changing selection in a virtualized TreeView

//Dazu
Evtl reicht es schon wenn du das VirtualizingStackPanel als ItemsPanel definierst.

Interessant das was du beim stackoverflow link liest, jemand sagt dort explizit das keine Businesslogic ins ViewModel gehört (und er ist mit der Meinung nicht allein, wie schon gesagt). Im dem von dir Zitierten Satz ist davon keine rede.
Das "behavior" was dort angesprochen wird ist keine Businesslogic. Businesslogic ist z.B. das errechnen eines Mittelwerts der Daten, nicht das aufrufen der Berechnung.

Das VM dient der Prozesssteuerung, ist klar irgendwie müssen die Aufgaben ja aufgerufen werden, aber die eigentliche Bearbeitung, Errechnen von Werten, Füllen von Models von externen Quellen usw. ist alles Aufgabe der Models und zählt zu der Businesslogic.

Views: is klar,
ViewModels: holt Daten aus den Models wenn gewünscht und delegiert befehle weiter,
Models: hält die Daten und gibt die Businesslogic.

//Dazu:

Models: In short, the Model is the “real application”. It represents all the business logic

The ViewModel is a coordinator. In my opinion, the job of the view model is to coordinate between the view and the model. It should NOT contain business logic, but in fact interface with business services.

Was gibts da nicht zu verstehen?
Auch Josh Smith sieht das in seinem Buch so.

Ich klink mich aus, sind eh schon zu off topic.

MVC = View und Controller reden mit Model MVVM = View redet nur mit VM, und VM gibt befehle an die Businesslogic weiter und bietet Models und Verwaltungsmethoden Bindbar an.

Models: In short, the Model is the “real application”. It represents all the business logic. MVVM Part 1: Overview

tallas meinung ist hier zu finden: Business Logik bei MVVM einsatz

The ViewModel is a coordinator. In my opinion, the job of the view model is to coordinate between the view and the model. It should NOT contain business logic, but in fact interface with business services. The model in MVVM: business object or something else?

Josh Smith verwaltet seine BL in seinem MVVM Buch auch in den Models:
Advanced MVVM

Model --- It is the data / business logic, completely UI independent, that stores the state and does the processing of the problem domain. What is MVVM Pattern?

Könnte ewig fort setzen, finde auch viele Slides wo es so beschrieben wurde.

3. Eigentlich sollte man, wenn man MVVM macht, die Logik, also auch die für die Persistierung in dem VM ( ViewModel oder manchmal auch ViewPresenter genannt ) implementieren.
   Das Model sollte nach Möglichkeit nicht wissen wie es Persistiert wird.

Meeep, das ist eher MVC. Bei MVVM ist es üblich das die Models auch die komplette businesslogic beinhalten.

Aber Vorsicht dabei, er benutzt die zusätzlichen Interactivity dll Dateien aus dem Blend SDK, diese musst du beim deploy der exe bei legen da sie kein fester Bestandteil des .Net sind!
Aus diesem Grund bleibe ich selber auch bei den "guten alten" AttachedBehaviors.

In einer MVVM Umgebung arbeitet man sehr oft mit so genannten DelegateCommand objekten, manchmal auch RelayCommand genannt.
Meine Implementation davon findest du hier: GitHub: DelegateCommand.cs (Ist, glaub ich, die selbe Implementation wie in den MS MVVM Tutorial)
Demo code: My Libraries: DelegateCommand
In dem Beispiel kannst du davon ausgehen das du ein KeyBinding gegen den SetCurrentCustomer gebunden hast.

Diese oder so eine ähnliche Klasse brauchst du in deinem Projekt, dann kannst du im ViewModel ein ICommand erstellen und das KeyBinding dagegen binden.
(Das Binden der InputBindings gegen ein ICommand im ViewModel geht erst ab .Net 4.0)

Dem ViewModel ist es am ende egal ob der Command von einem MenuItem, Button oder InputBinding angetriggert wurde.

Es heißt Schleife und nicht Schlaufe

Ah oh - ich las das es genau 2 sein müssen 😁 hab nix gesagt 😁

private bool CheckString(string str)
{
    return Regex.IsMatch(str, "[A-Z][a-z]");
}

habe eben festgestellt, meine Lösung ist für mich auch nicht befriedigend, vor allem klappt es auch nur bei den "local:DropDownButton", bei den "Button" gehts nicht, ich weiss nicht wo da der Hund begraben liegt. (Hat da jemand eine Idee???)

Im normalen Button wirst du eher ein TextBlock als Content eintragen müssen als mit einer "ViewBox" (?) zu arbeiten. Sind halt unterschiedliche Controls.

Stichwort: INotifyCollectionChanged. Auch INotifyPropertyChanged solltest du beachten. Ein Beispiel findest du hier: Image an eine ListView-Spalte binden

Wenn du die UI nicht ändern kannst, dann ist es eventuell ratsamer die Übersetzung kürzen zu lassen.
Das Problem haben wir auch viel mit alten C++ Applikationen wo das UI Framework einfach nicht dynamisch genug ist.
Ein Automatisches Font skalieren ist sehr gefährlich, bedenke einfach mal wie lang eine Übersetzung werden kann - vor allem die Griechen sind da Experten - da kann der Text nachher zu klein werden.

Möglichkeiten:

• Button dynamisieren (Ist geklärt)
• Übersetzung kürzen lassen (Annehmbare Lösung)
• Font dynamisch kleiner machen (Schlechte Lösung da zu gefährlich)
• Automatisches abschneiden und "..." anfügen (Eventuell annehmbar, muss man prüfen)
• Ein ScrollText Control schreiben (Wo der volle Text bei Mouse over durch Scrollt, evtl auch als ToolTip angezeigt wird, muss man schauen ob es optisch in die UI passt)
• Den Button anders beschriften sodass die Übersetzungen auch Kleiner werden.

Wir haben für solche Zwecke in der Firma "String implementation guidlines" eingeführt mit diversen Regeln, eine Regel ist auch die "Allow for text expansion":
*For whole sentences, allow for at least 30%, better 40% of text expansion. *For single words, allow for at least 15 characters per word, regardless of the original word’s length. For example, the English "add " (3 characters) translates to German “hinzufügen" (10 characters). *When placeholders are used within a string, add at least one extra line to text areas.

War der DataContext korrekt gesetzt?
Die Binding Klasse sucht immer im DataContext des jeweiligen Controls. Wenn ein Binding nicht funktioniert dann siehst du es im Output Fenster.

D.h. Wenn deine Liste in einer Separaten Klasse als Property zur Verfügung steht, dann hängt man diese Klasse in den DataContext und Bindet direkt gegen den Property Namen.

Oder man setzt den DataContext direkt auf die Liste, dann muss man ItemsSource ohne namen Binden, da es ja kein Sub-Property gibt.

Das könnte am Ende so aussehen:

public class Item : INotifyPropertyChanged
{
    public string Name
    {
        get { return _name; }
        set
        {
            _name = value;
            NotifyPropertyChanged(() => Name);
        }
    }
    private string _name;

    public string Image
    {
        get { return _image; }
        set
        {
            _image = value;
            NotifyPropertyChanged(() => Image);
        }
    }
    private string _image;

    public event PropertyChangedEventHandler PropertyChanged;
    void NotifyPropertyChanged<T>(Expression<Func<T>> property)
    {
        var handler = PropertyChanged;
        if (handler != null)
        {
            var memberExpression = property.Body as MemberExpression;
            handler(this, new PropertyChangedEventArgs(memberExpression.Member.Name));
        }
    }
}

MainWindow.xaml

<Window>
    <Grid>
        <!-- Er sucht nun Items im Fenster DataContext -->
        <ListView ItemsSource="{Binding Items}">
            <ListView.View>
                <GridView>
                    <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" />
                    <GridViewColumn Header="Image">
                        <GridViewColumn.CellTemplate>
                            <DataTemplate>
                                <Image Source="{Binding ImageSource}" />
                            </DataTemplate>
                        </GridViewColumn.CellTemplate>
                    </GridViewColumn>
                </GridView>
            </ListView.View>
        </ListView>
    </Grid>
</Window>

MainWindow.xaml.cs

public partial class MainWindow : Window
{
    public ObservableCollection<Item> Items { get; set; }
    public MainWindow()
    {
        InitializeComponent();
        DataContext = this; // Fenster DataContext ist die eigene Code Behind

        Items = new ObservableCollection<Item>();
        ItemRepository.FillWithDummyItems(Items);
    }
}

Oder Variante 2:
MainWindow.xaml

<Window>
    <Grid>
        <!-- Er sucht kein Property sondern bindet sein DataContext direkt -->
        <ListView x:Name="myItemsList" ItemsSource="{Binding }">
            <ListView.View>
                <GridView>
                    <GridViewColumn Header="Name" DisplayMemberBinding="{Binding Name}" />
                    <GridViewColumn Header="Image">
                        <GridViewColumn.CellTemplate>
                            <DataTemplate>
                                <Image Source="{Binding ImageSource}" />
                            </DataTemplate>
                        </GridViewColumn.CellTemplate>
                    </GridViewColumn>
                </GridView>
            </ListView.View>
        </ListView>
    </Grid>
</Window>

MainWindow.xaml.cs

public partial class MainWindow : Window
{
    public ObservableCollection<Item> Items { get; set; }
    public MainWindow()
    {
        InitializeComponent();
        myItemsList.DataContext = Items; // DataContext der Liste ist die Items Collection

        Items = new ObservableCollection<Item>();
        ItemRepository.FillWithDummyItems(Items);
    }
}

//Edit XML versaut ^^

Falscher ansatz, so macht man das in WPF nicht

1. Kein ListViewItem im code erzeugen, erstell dir eine Klasse die ein Item repräsentiert und diese Klasse bekommt die entsprechenden Properties
2. Die Items verwaltest du im Code in einer Liste (ObservableCollection)
3. Du Bindest gegen die Items und die DisplayMemberBindings gegen die Text Properties
4. Das Image bindest du im CellTemplate der GridViewColumn (statt DisplayMemberBinding)

Also ich seh das etwas strenger, beide Beispiele die du aufführt würd ich so monieren.

Bzgl 1.
Du hast eine OpenInBrowser in der News Klasse.
Das gehört dort definitiv nicht hin, das gehört eher in eine NewsReader Klasse (oder ähnlichen namen). Diese Klasse kann dann verschiedene Möglichkeiten anbieten eine News zu lesen, und auch eine gescheite Fehlerbehandlung.

Bzgl 2.
DownloadDescription gehört ebenfalls nicht in die News Klasse.
Herb hat zwar recht damit das du dort nur weiter delegierst, aber du hast dort ein verweis auf eine weitere Klasse. Mach das in 5 Klassen, schon hast du deine DescriptionDownloader munter überall hin verteilt, das ist sehr unschön und bringt sehr schnell alles durcheinander.
Das setzen der ShortDescription sollte die Klasse erledigen die die News Klasse mit Informationen befüllt.

if (string.IsNullOrEmpty(desc))
{
    this.ShortDescription = desc;
}

Was mir einfällt.
Dies Forum wird doch überwiegend von Leuten benutzt die Programmieren und dabei auf Probleme stoßen, oder anderen bei deren Problemen helfen.
Machen das "Phone User"? Ich mein, wird auf den Handys Sourcecode gelesen und geschrieben? Wird auf den Handys nebenbei entwickelt? Der Offtopic bereich ist ja nicht gerade Riesig, entsprechend stellt sich die Frage des Mehrwerts.

In einer Lokalisierten Applikation stellt man die CurrentCulture auch ein.
In Xaml muss man aber die Xaml Sprache separat auch einstellen (Wenn nicht ist es Englisch, egal auf das die CurrentCulture steht):

Thread.CurrentThread.CurrentUICulture = Settings.Get<CultureInfo>(Cfgs.Language);
Thread.CurrentThread.CurrentCulture = Thread.CurrentThread.CurrentUICulture;
FrameworkElement.LanguageProperty.OverrideMetadata(typeof(FrameworkElement), new FrameworkPropertyMetadata(System.Windows.Markup.XmlLanguage.GetLanguage(Thread.CurrentThread.CurrentCulture.IetfLanguageTag)));