Wie man das machen kann, zeige ich wie folgt:

Ich erstelle mir vorerst einen einfachen Delegate.

1 private delegate void AsyncAwsDelegate();

Im Konstruktor der ViewModels, bzw in einem Command wird dann an diesem Delegate ein BeginInvoke aufgerufen, der die Methode zur asynchronen Verarbeitung zugewiesen bekommt.

1 public MainViewModel()
2 {
3     AsyncAwsDelegate del = (FetchItemsAsync);
4     del.BeginInvoke(null, null);
5 }

In dieser Methode findet dann der Prozess statt, wo die Items verarbeitet und einer ObservableCollection<T> hinzugefügt werden.

1 private void FetchItemsAsync()
2 {
3     var items = _dataLayer.Items.ToList();
4     items.ForEach(i => Items.Add(_aws.ItemLookup(i.ItemId)));
5 }

Das geht leider nicht ohne Dispatcher, sprich wenn ich die “normale” ObservableCollection verwenden würde, müsste ich zuerst in den UI Thread gelangen, ansonsten knallt es.

Dazu konnte ich eine nette spezialisierte Klasse finden, die mir diese Arbeit abnimmt.

 1 public class DispatchingObservableCollection<T> : ObservableCollection<T>
 2 {
 3     private readonly Dispatcher _currentDispatcher;
 4 
 5     /// <summary>
 6     /// The default constructor of the ObservableCollection
 7     /// </summary>
 8     public DispatchingObservableCollection()
 9     {
10         //Assign the current Dispatcher (owner of the collection)
11         _currentDispatcher = Dispatcher.CurrentDispatcher;
12     }
13 
14     /// <summary>
15     /// Executes this action in the right thread
16     /// </summary>
17     ///<param name="action">The action which should be executed</param>
18     private void DoDispatchedAction(Action action)
19     {
20         if (_currentDispatcher.CheckAccess())
21             action();
22         else
23             _currentDispatcher.Invoke(DispatcherPriority.DataBind, action);
24     }
25 
26     /// <summary>
27     /// Clears all items
28     /// </summary>
29     protected override void ClearItems()
30     {
31         DoDispatchedAction(() => base.ClearItems());
32     }
33 
34     /// <summary>
35     /// Inserts a item at the specified index
36     /// </summary>
37     ///<param name="index">The index where the item should be inserted</param>
38     ///<param name="item">The item which should be inserted</param>
39     protected override void InsertItem(int index, T item)
40     {
41         DoDispatchedAction(() => base.InsertItem(index, item));
42     }
43 }

Da die ObservableCollection das INotifyPropertyChanged Interface implementiert, brauch ich auch nicht mehr dafür Sorge tragen, dass sich bei jedem Zufügen eines Items die UI aktualisieren muss.

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 5. Mai 2010 -- ComboBox an ObjectDataProvider binden
• 22. Juli 2009 -- CAL Anwendung in 3 Minuten
• 16. Juli 2009 -- MenuItems aus XML auslesen und binden – WPF / MVVM

Das liegt daran, das im DataBinding keine Exception geworfen werden, wenn hier ein Element, eine Property, oder ein Path nicht gefunden wird.

Ein paar kleine Tricks können Abhilfe und für ein stressfreies Wochenende sorgen.

Tipp 1: Ausgabefenster

Lässt man sich beim Debuggen das Ausgabefenster von Visual Studio anzeigen, kann man diesem schon wertvolle Informationen entlocken.

Eine Fehlermeldung könnte z.B. wie folgt aussehen:

System.Windows.Data Error: 40 : BindingExpression path error: 'Mesage' property not found on 'object' ''MainWindow' (Name='')'. BindingExpression:Path=Mesage; DataItem='MainWindow' (Name=''); target element is 'TextBox' (Name=''); target property is 'Text' (type 'String')

Hier finde ich dann, das ich mich bei der Property “Message” verschrieben habe (“Mesage”).

Um das Ausgabefenster anzuzeigen, geht man unter Ansicht > Ausgabe oder zeigt dieses über die Tastenkombination CTRL+W+O an. Man muss hier aber darauf achten, dass man sich bereits im Debugging befindet.

Vorher sollte man überprüfen ob die Einstellungen in Visual Studio richtig sind.

Dazu geht man nach Extras > Optionen > Debugging > Ausgabefenster und wählt hier unter WPF-Ablaufverfolgung im DropDown “DataBinding” die Option “Alle”

Tipp 2: PresentationTraceSources

Wem die Informationen in der Ausgabe nicht ausreichen, kann sein Control um weitere, ausführlichere Informationen erweitern.

Hierzu referenziert man auf den Namespace System.Diagnostics aus der Assembly WindowsBase

Anschließend erweitert man sein Binding um das AttachedProperty TraceLevel aus der Klasse PresentationTraceSources und dieses um den Wert High:

<TextBox Text="{Binding Mesage, debugging:PresentationTraceSources.TraceLevel=High}"  />

Hier bekommt man dann richtig viele Informationen zu einem Binding, die ich hier auszugsweise nur als Grafik zeigen möchte:

Mögliche Werte in TraceLevel können sein: High, Low, Medium und None.

Tipp 3: IValueConverter

Nun, es kommt vor, dass obwohl die Properties richtig definiert sind, immer noch nicht das angezeigt wird, was man eigentlich erwartet. Hier kommt die dritte Möglichkeit ins Spiel.

Es wäre doch toll, wenn man irgendwie einen BreakPoint irgendwo setzen könnte um nach gewohnter Manier zu debuggen. Ja, auch das ist möglich.

Hierzu definiert man sich einen Converter, der lediglich den Value durchreicht:

public class DebuggingConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return value;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        return value;
    }
}

Nun referenziert man den Namespace zum Converter und in den Resources des Elements wird der Converter bekannt gemacht:

xmlns:converter="clr-namespace:Debugging"

<Grid.Resources>
    <converter:DebuggingConverter x:Key="debugger" />
</Grid.Resources>

Im Binding wird der Converter dann noch definiert

<TextBox Text="{Binding Message, Converter={StaticResource debugger}}"  />

Jetzt setze ich meine BreakPoints im Convert oder beim TwoWay-Binding auch im ConvertBack und kann mir den Wert genauer anschauen.

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 23. Juli 2011 -- Gemeinsamen Validation Style für Controls – WPF
• 25. Juni 2011 -- Enumeration in einer ComboBox darstellen – WPF Quicky
• 15. März 2011 -- Cookies in einer WPF Applikation
• 6. März 2011 -- MultiBinding die Zweite
• 14. Februar 2011 -- Doppelklick im DataGrid abfangen – WPF Quicky

<Style x:Key="validationTriggerBase" TargetType="Control">
    <Style.Triggers>
        <Trigger Property="Validation.HasError" Value="true">
            <Setter Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self}, Path=(Validation.Errors)[0].ErrorContent   }" />
        </Trigger>
    </Style.Triggers>
</Style>

Im Anschluss, kann man einzelne Controls diesen Style zuweisen:

<Style TargetType="{x:Type DatePicker}" BasedOn="{StaticResource validationTriggerBase}" />

<Style TargetType="{x:Type TextBox}" BasedOn="{StaticResource validationTriggerBase}" />

Nicht vergessen, das bindende Control muss ValidatesOnDataErrors=True aufrufen.

<StackPanel Width="250" HorizontalAlignment="Center" DataContext="{StaticResource Person}">
    <TextBox Text="{Binding Name, ValidatesOnDataErrors=True, 
        UpdateSourceTrigger=PropertyChanged}" />

    <DatePicker SelectedDate="{Binding Birthday, StringFormat=dd.mm.yyyy, 
        ValidatesOnDataErrors=True,
        UpdateSourceTrigger=PropertyChanged, Converter={StaticResource conv}}" />
</StackPanel>

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 24. Juli 2011 -- DataBindings debuggen – WPF
• 25. Juni 2011 -- Enumeration in einer ComboBox darstellen – WPF Quicky
• 15. März 2011 -- Cookies in einer WPF Applikation
• 6. März 2011 -- MultiBinding die Zweite
• 14. Februar 2011 -- Doppelklick im DataGrid abfangen – WPF Quicky

Mit der Methode GetValues() aus der Klasse Enum, bekommt man einen Array mit den Konstanten aus der Aufzählung zurück.

<ComboBox ItemsSource="{Binding AutoCompleteFilters}" SelectedItem="{Binding SelectedFilterMode}" />

public List<AutoCompleteFilterMode> AutoCompleteFilters { get; set; }

private void SetAutoCompleteFilters()
{
    Array values = Enum.GetValues((typeof(AutoCompleteFilterMode)));

    AutoCompleteFilters = new List<AutoCompleteFilterMode>();
    foreach (AutoCompleteFilterMode value in values)
    {
        AutoCompleteFilters.Add(value);
    }
}

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 31. Juli 2011 -- Gottmodus in Windows 7 aktivieren
• 24. Juli 2011 -- DataBindings debuggen – WPF
• 23. Juli 2011 -- Gemeinsamen Validation Style für Controls – WPF
• 4. Juli 2011 -- Neuer Ordner im Projekt per Hotkey
• 15. März 2011 -- Cookies in einer WPF Applikation

Folgendes einfaches Beispiel zeigt wie die Cookieinformationen abgelegt und gelesen werden können:

XAML

1
2
3
4
5
6
7
8
9

<StackPanel>
    <TextBox Name="tbUserName" />
    <TextBox Name="tbPassword" />        
    <Button Content="SetCookie" Click="Button_Click" />   
 
    <Button Content="GetCookie" Click="Button_Click_1" /> 
    <TextBlock Name="tbGetUserName" />        
    <TextBlock Name="tbGetPassword" />
</StackPanel>

C#

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

public partial class MainWindow : Window
{
    Uri cookiePath = new Uri(System.Environment.GetEnvironmentVariable("tmp"));
 
    public MainWindow()
    {
        InitializeComponent();
    }
 
    private void Button_Click(object sender, RoutedEventArgs e)
    {
        SetCookie(cookiePath, tbUserName.Text, tbPassword.Text);
    }
 
 
    private void Button_Click_1(object sender, RoutedEventArgs e)
    {
        string c = GetCookie(cookiePath);
 
        if (!String.IsNullOrEmpty(c))
        {
            var auth = GetAuthentification(c);
            tbGetUserName.Text = auth["Username"];
            tbGetPassword.Text = auth["Password"];
        }
    }
 
 
    public static void SetCookie(Uri uri, String name, String value)
    {
        String cookie = String.Format("Username={0}Password={1}", name, value);
        Application.SetCookie(uri, cookie);
    }
 
    public static String GetCookie(Uri uri)
    {
        string c = String.Empty;
        try
        {
            c = Application.GetCookie(uri);
        }
        catch (Exception)
        {
            //set new cookie here
        }
 
        return c;
    }
 
    private Dictionary<string, string> GetAuthentification(string cookie)
    {
        var username = cookie.Substring(0, cookie.IndexOf("Password=")).Replace("Username=", string.Empty);
        var password = cookie.Substring(cookie.IndexOf("Password=")).Replace("Password=", string.Empty);
 
        Dictionary<string, string> auth = new Dictionary<string, string>();
        auth.Add("Username", username);
        auth.Add("Password", password);
 
        return auth;
    }
}

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 24. Juli 2011 -- DataBindings debuggen – WPF
• 23. Juli 2011 -- Gemeinsamen Validation Style für Controls – WPF
• 25. Juni 2011 -- Enumeration in einer ComboBox darstellen – WPF Quicky
• 6. März 2011 -- MultiBinding die Zweite
• 14. Februar 2011 -- Doppelklick im DataGrid abfangen – WPF Quicky