Gut finde ich jQuery Scroll Path

"jQuery Scroll Path is a plugin that lets you define your own custom scroll path. What this means exactly is best understood by checking out the demo. The plugin uses canvas flavored syntax for drawing paths, using the methods moveTo, lineTo and arc. To help with getting the path right, a canvas overlay with the path can be enabled when initializing the plugin."

und keymaster.js (analog jwerty).

"Keymaster is a simple (100 LoC or so) micro-library for defining and dispatching keyboard shortcuts. It has no dependencies."

Was ist dir im Monat April aufgefallen, was man unbedingt einmal ausprobieren sollte?

Sollte man jeden Monat aus den Bereichen Web und .NET eine solche Auflistung von Neuerungen machen? Was denkt Ihr?

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• Keine ähnliche Beiträge vorhanden

Nun möchte ich gerne immer den selben EventTrigger an mehreren Stellen einsetzen und verhindern, dass der Code an “tausend” Stellen redundant eingesetzt wird. Aus diesem Grund, soll diese Interaktion als Style zu Verfügung gestellt werden.

Der folgende Code zeigt, wie der redundante Code aussehen würde:

<r:RibbonButton
        Label="{x:Static Helper:ViewModels.AlleKontaktGruppen}"
        LargeImageSource="/OCC.Resources;component/Images/32/kdm/Groups-Meeting-Dark-icon.png">

        <i:Interaction.Triggers>
            <i:EventTrigger EventName="Click">
                <cal:ActionMessage MethodName="Navigate">
                    <cal:Parameter Value="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type r:RibbonButton}, AncestorLevel=1},Path=Label}" />
                </cal:ActionMessage>
            </i:EventTrigger>
        </i:Interaction.Triggers>

    </r:RibbonButton>

Wie gehen wir also vor? Wir leiten uns dazu eine Klasse namens “Triggers” von einer typisierten Liste des Typen System.Windows.Interactivity.TriggerBase ab und registrieren diese als DepedencyProperty:

using System.Collections.Generic;
using System.Windows;
using System.Windows.Interactivity;

namespace OCC.WPF.Helper
{
    public class Triggers : List<System.Windows.Interactivity.TriggerBase> { }

    public static class OCCInteraction
    {
        public static Triggers GetTriggers(DependencyObject obj)
        {
            return (Triggers)obj.GetValue(TriggersProperty);
        }

        public static void SetTriggers(DependencyObject obj, Triggers value)
        {
            obj.SetValue(TriggersProperty, value);
        }

        public static readonly DependencyProperty TriggersProperty =
            DependencyProperty.RegisterAttached("Triggers", typeof(Triggers), typeof(OCCInteraction), new UIPropertyMetadata(null, OnPropertyTriggersChanged));

        private static void OnPropertyTriggersChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var triggers = Interaction.GetTriggers(d);
            foreach (var trigger in e.NewValue as Triggers) triggers.Add(trigger);
        }
    }
}

Und in einem Ressourcenwörterbuch “Style.xaml” bauen wir uns den entsprechenden Trigger dann in zusammen:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:Helper="clr-namespace:OCC.WPF.Helper"
                    xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
                    xmlns:cal="http://www.caliburnproject.org"
                    xmlns:Ribbon="clr-namespace:Microsoft.Windows.Controls.Ribbon;assembly=RibbonControlsLibrary">

    <Helper:Triggers x:Key="ribbonBtnClickTrigger" x:Shared="False">
        <i:EventTrigger EventName="Click">
            <cal:ActionMessage MethodName="Navigate">
                <cal:Parameter Value="{Binding RelativeSource={RelativeSource FindAncestor, 
                    AncestorType={x:Type Ribbon:RibbonButton}, AncestorLevel=1},Path=Label}" />
            </cal:ActionMessage>
        </i:EventTrigger>
    </Helper:Triggers>

    <Style x:Key="ribbonBtnClickBehavior" TargetType="FrameworkElement">
        <Setter Property="Helper:OCCInteraction.Triggers" Value="{StaticResource ribbonBtnClickTrigger}"/>
    </Style>

</ResourceDictionary>

Anschließend können wir unser Element an das Style-Attribute binden:

    <r:RibbonButton
        Label="{x:Static Helper:ViewModelNames.AlleKontaktGruppen}"
        LargeImageSource="/OCC.Resources;component/Images/32/kdm/Groups-Meeting-Dark-icon.png"
        Style="{StaticResource ribbonBtnClickBehavior}"/>

Sieht doch gleich viel besser aus.

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 14. Januar 2012 -- Asynchrones Befüllen einer ObservableCollection<T> in einem ViewModel
• 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

Zieldefinition

Ziel ist es, im Outlook ein Dashboard bereit zu stellen, welches einem alle Aufgaben, den Posteingang, den Kalender, Notizen und die Kontakte anzeigt. Das Besondere dabei ist, das die Aufgaben in (agiler) Form eines Scrum/Kanban Boards angezeigt werden.

Features

Dashboard erstellen

Nachdem wir nun die Aufgaben-Ordner erstellt haben, sollen diese im Dashboard angezeigt werden. Dazu müssen wir vorerst das Dashboard erstellen:
Hier legen wir uns eine *.html-Datei an einem beliebigen (sicheren) Ort ab. Ich erstelle dazu in meinem Entwicklungsordner einen Ordner namens "#OutlookToday ". Das Pfad müsste nun so aussehen:  "D:\Dev\#OutlookToday\OutlookToday.html".

In dieser Datei, designen wir nun unser DashBoard.
Die Elemente die wir im Dashboard anzeigen wollen, werden mittels Object-Element eingebunden, hier kann man über den Parameter "Folder" das  jeweilige Outlook-Element anzeigen.

Für den Posteingang sieht das wie folgt aus:

Man kann jeden beliebigen Ordner anhand des Namens angeben. z.B. auch den Ordner "Gesendete Elemente"

Nun baut man sich mit ein paar Html/jQuery Kenntnissen ein Design zusammen und bindet die entsprechenden Object-elemente an den Stellen ein, wo man diese benötigt. Mein Beispiel sieht wie folgt aus:

<html>
<head>

    <title>Dashboard</title> 

    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.js"></script>        

    <style type="text/css">
        a:active, a:focus {
           outline:  none;
           ie-dummy: expression(this.hideFocus=true);
        }

        h1{
            font: bold italic 2em/1em "Times New Roman", "MS Serif", "New York", serif;
            margin: 5;
            padding: 0;
            color: #cc3300;
            border-bottom: dotted #cc3300 thin;

        }
        .thirds{
            width: 33%;
            float:left;
        }

        #tabbed_box_1 {
            margin: 0px auto 0px auto;
            width:100%;
        }

        .tabbed_area {
            border:1px solid #494e52;
            background-color:#636d76;
            padding:8px;
        }

        ul.tabs {
            margin:0px; padding:0px;
            margin-top:5px;
            margin-bottom:6px;
        }
        ul.tabs li {
            list-style:none;
            display:inline;
        }
        ul.tabs li a {
            background-color:#464c54;
            color:#ffebb5;
            padding:8px 14px 8px 14px;
            text-decoration:none;
            font-size:9px;
            font-family:Verdana, Arial, Helvetica, sans-serif;
            font-weight:bold;
            text-transform:uppercase;
            border:1px solid #464c54;
            background-image:url(images/tab_off.jpg);
            background-repeat:repeat-x;
            background-position:bottom;
        }

        ul.tabs li a:hover {
            background-color:#ffffff;
            color:#282e32;
            border:1px solid #464c54;
            border-bottom: 1px solid #ffffff;
            background-image:url(images/tab_on.jpg);
            background-repeat:repeat-x;
            background-position:top;
        }

        ul.tabs li a.active {
            background-color:#ffffff;
            color:#282e32;
            border:1px solid #464c54;
            border-bottom: 1px solid #ffffff;
            background-image:url(images/tab_on.jpg);
            background-repeat:repeat-x;
            background-position:top;
        }

        .content {
            background-color:#ffffff;
            height: 400px;
            border:1px solid #464c54;
            font-family:Arial, Helvetica, sans-serif;
            background-image:url(images/content_bottom.jpg);
            background-repeat:repeat-x;
            background-position:bottom;
            padding: 20px 0px 40px 0px;
        }

        #content_2, #content_3, #content_4, #content_5  { display:none; }

        .content ul {
            margin:0px;
        }
        .content ul li {
            list-style:none;
            border-bottom:1px solid #d6dde0;
            padding-top:15px;
            padding-bottom:15px;
            font-size:13px;
        }
        .content ul li:last-child {
            border-bottom:none;
        }
        .content ul li a {
            text-decoration:none;
            color:#3e4346;
        }
        .content ul li a small {
            color:#8b959c;
            font-size:9px;
            text-transform:uppercase;
            font-family:Verdana, Arial, Helvetica, sans-serif;
            position:relative;
            left:4px;
            top:0px;
        }
        .content ul li a:hover {
            color:#a59c83;
        }
        .content ul li a:hover small {
            color:#baae8e;
        }
    </style>

</head>
<body>

    <!-- TabControl http://d2o0t5hpnwv4c1.cloudfront.net/001_Tabbed/site/jQuery.html# -->
    <div id="tabbed_box_1" class="tabbed_box">

        <div class="tabbed_area">        

            <ul class="tabs">
                <li><a href="#" title="content_1" class="tab active">Board</a></li>
                <li><a href="#" title="content_2" class="tab">Inbox</a></li>
                <li><a href="#" title="content_3" class="tab">Appointments</a></li>
                <li><a href="#" title="content_4" class="tab">Notes</a></li>
                <li><a href="#" title="content_5" class="tab">Contacts</a></li>

            </ul>

            <div id="content_1" class="content">                

                <div class="thirds">
                    <h1>BACKLOG</h1>
                    <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100% height=500>
                       <param name="Folder" value="Aufgaben\backlog">
                       <param name="Namespace" value="MAPI">
                       <param name="Restriction" value=""><param name="DeferUpdate" value="0">
                    </OBJECT>
                </div>    

                <div class="thirds">
                     <h1>PROGRESS</h1>
                    <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100% height=500>
                        <param name="Folder" value="Aufgaben\in progress">
                        <param name="Namespace" value="MAPI">
                        <param name="Restriction" value><param name="DeferUpdate" value="0">
                    </OBJECT>
                </div>    

                <div class="thirds">
                    <h1>DONE</h1>
                    <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100%     height=500>
                        <param name="Folder" value="Aufgaben\done">
                        <param name="Namespace" value="MAPI">
                        <param name="Restriction" value><param name="DeferUpdate" value="0">
                    </OBJECT>
                </div>
            </div>                

            <div id="content_2" class="content">

                <h1>Inbox</h1>

                <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100%     height=500>
                    <param name="Folder" value="Posteingang">
                    <param name="Namespace" value="MAPI">
                    <param name="Restriction" value>
                    <param name="DeferUpdate" value="0">
                </OBJECT>

            </div>

            <div id="content_3" class="content">

                <h1>Appointments</h1>
                <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100%     height=500>
                    <param name="Folder" value="Kalender">
                    <param name="Namespace" value="MAPI">
                    <param name="Restriction" value>
                    <param name="DeferUpdate" value="0">
                </OBJECT>
            </div>

              <div id="content_4" class="content">
                <h1>Notes</h1>
                <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100%     height=500>
                    <param name="Folder" value="Notes">
                    <param name="Namespace" value="MAPI">
                    <param name="Restriction" value>
                    <param name="DeferUpdate" value="0">
                </OBJECT>
              </div>

            <div id="content_5" class="content">
                <h1>Contacts</h1>
                <OBJECT classid=CLSID:0006F063-0000-0000-C000-000000000046 id=ViewCtlFolder width=100%     height=500>
                <param name="Folder" value="Contacts">
                <param name="Namespace" value="MAPI">
                <param name="Restriction" value>
                <param name="DeferUpdate" value="0">
                </OBJECT>
            </div>

        </div>
    </div>

<script type="text/javascript">

 $(document).ready(function(){

        // When a link is clicked
        $("a.tab").click(function () {

            $(".active").removeClass("active");
            $(this).addClass("active");
            $(".content").hide();

            // slide this content up
            var content_show = $(this).attr("title");
            $("#"+content_show).show();

        });

});

</script>

</body>
</html>    

In Outlook einbinden.

Um die OutlookToday.html in Outlook einzubinden, geht man mittels Rechtsklick auf den Posteingang und wählt hier unter Eigenschaften den Reiter "Homepage" 

und trägt hier den Pfad ein: D:\Dev\#OutlookToday\OutlookToday.html

Neue Mails als Aufgabe in Backlog kopieren

Nun kommen wir zum zweiten Feature. Wenn eine neue Mail eintrifft, wollen wir einer Regel erstellen, die die Mail als Kopie in den Aufgaben-Ordner "Backlog" kopiert.

Dazu benötigen wir ein VBAScript, welches man im Visual Basic Editor erstellen kann. Diesen ruft man mit der Tastenkombination ALT F11 auf. Hier fügt man ein neues Modul ein

In diesem Modul schreibt man folgenden Code

(Das Copy() im Code ist ein Workaround, da sonst die Mail nicht mehr im Posteingang gelistet wird)

Sub RulesScript(olItem As MailItem)
   Set copyitem = olItem.Copy
   Set myTasks = Application.GetNamespace("MAPI").GetDefaultFolder(olFolderTasks)

   Set backlog = myTasks.Folders("backlog")
   olItem.Move backlog
End Sub

Nach dem Speichern und Schließen des VBA Editors, müssen wir eine Regel erstellen, die diesen Code ausführt.

Dazu gehen wir im Outlook unter Extras auf Regeln und Benachrichtigungen.

Hier erstellen wir folgende neue Regel.

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 11. April 2012 -- Unable to write * ‘obj\Release\
• 31. Juli 2011 -- Gottmodus in Windows 7 aktivieren
• 4. Juli 2011 -- Neuer Ordner im Projekt per Hotkey
• 25. Juni 2011 -- Enumeration in einer ComboBox darstellen – WPF Quicky
• 9. Juni 2011 -- Entscheidungen einfach gemacht

Also dann einfach auf dem TFS löschen, einchecken und Projekt bauen.

Viel Spaß beim entwickeln : )

Dieser Beitrag stammt von Mario Priebe.

Ähnliche Beiträge

• 18. April 2012 -- Outlook als GTD Applikation
• 12. Januar 2012 -- Automatisiertes Ein- und Auschecken im Buildprozess
• 31. Juli 2011 -- Gottmodus in Windows 7 aktivieren
• 4. Juli 2011 -- Neuer Ordner im Projekt per Hotkey
• 25. Juni 2011 -- Enumeration in einer ComboBox darstellen – WPF Quicky

Jede dieser Technologien haben ihre Vor- und Nachteile. In diesem Artikel möchte ich auf die Hauptunterschiede beider Technologien eingehen und bei der Entscheidung helfen, welche der beiden für den Einsatzzweck vom Vorteil ist.

Windows Forms

Windows Forms ist die ältere der beiden Technologien und ist die Basis für die meisten (älteren) Windows Applikationen. Die meisten Entwickler haben bereits umfängliche Erfahrungen mit dieser Technologie machen können.

Mit Windows Forms können Formulare in unterschiedlichen Größen und Formen von Fenstern erstellt werden und haben im Prinzip immer die selbe Anordnung für Container, Menüs und Struktur. Einen großen Spielraum für die Umsetzung von grafisch, anspruchsvollen Anforderungen hat man leider nicht, bzw. ist dies sehr schwierig mit Windows Forms umzusetzen, machbar ist es aber dennoch.

Windows Forms hat aber eine sehr gute Unterstützung für multilinguale Anwendungen. Wenn man also eine mehrsprachige Business-Applikation, bei der Usability und Optik nicht so wichtig sind, erstellen möchte, könnte man Windows Forms einsetzen. Man sollte sich aber dennoch den folgenden WPF-Teil anschauen.

Die Navigation innerhalb einer Windows Forms-Anwendung ermöglicht ein Wechseln innerhalb verschiedener Formulare im Single Document Interface Modus (SDI, der Benutzer sieht immer nur ein Fenster mit Informationen) und im Multi Document Interface Modus (MDI, der Benutzer kann mehrere Formulare zeitgleich geöffnet haben).

Für ein entsprechendes UI Pattern um eine Trennung zwischen Code und Design zu erzielen, bekommt man in Windows Forms von Hause aus leider nichts mitgeliefert. Hier kann man sich aber das MVP (Model View Presenter) Pattern anschauen. Es gibt auch ein Framework namens MVC#, welches einem dabei unterstützt. Aber auch der MVVM Ansatz kann beispielsweise über das Windows Application Framework (WAF) mittels Windows Forms Adapter nach implementiert werden.

WPF

WPF steht für Windows Presentation Foundation und ist der direkte Nachfolger von Windows Forms. Der wichtigste Unterschied zwischen WPF und Windows Forms ist, dass in WPF eine klare Trennung zwischen Code und Design herrscht, sprich UI und Logik können getrennt voneinander entwickelt werden.

Der Code kann dabei mit allen .NET basierenden Sprachen entwickelt werden. Die Beschreibungssprache für die UI nennt sich XAML und steht für Extensible Application Markup Language. Wichtig dabei ist, dass bei der Entwicklung der UI, dem Designer keinerlei Grenzen gesetzt sind. Alles ist möglich!

WPF-Applikationen werden in drei verschiedenen Typen unterteilt, welche für verschiedene Aufgaben zuständig sind. Windows-Applikation, Navigations-Applikation und XAML-Browser-Applikation (XBAP).

Windows-Applikation

Die Windows-Applikation ist Fensterbasierend und Windows Forms am ähnlichsten. Man erstellt SDI und MDI Applikationen und verschiedene Formulare können über einen Menü-Link direkt angewählt und geöffnet werden. Für Navigation oder Historien ist von Hause aus nichts implementiert. Man muss hier selbst Hand anlegen.

Navigations-Applikation

Unterstützt die Entwicklung von seitenbasierten Anwendungen und ist dem der Webentwicklung sehr ähnlich. Man verfügt über Vor- und Zurück Funktionalitäten und der automatisierten Speicherung der aufgerufenen Seiten in einem Journal. Im Gegensatz zur Webentwicklung, muss die Applikation kompiliert werden und läuft unter Windows, man hat aber vollen Zugriff auf die Ressourcen des Betriebssystems, wie das File-System und/oder der Registry.

XAML-Browser-Applikation

XBAPs verfügen, ähnlich einer Navigations-Applikation, über die Navigations- und Journalfunktionalitäten. Eine XBAP-Applikation kann auf einem Server oder einer Website veröffentlicht werden und werden bei der Instanziierung heruntergeladen. Mit einer XBAP hat man beschränken Zugriff auf die Ressourcen des Computers und man kann weder auf das Filesystem, noch auf die Registry zugreifen.

Die Wahl des entsprechenden Applikations-Typen hängt von verschiedenen Faktoren ab. Die beiden wichtigsten wären, User Experience und spezielle Anforderungen an die Applikation.

User Experience

Möchte man beispielsweise eine seitenbasierte Anwendung oder einen Wizard erstellen, sollte die Wahl auf den Navigations-Typen, oder je nach Anforderung (Zugriff) auf den XBAP-Typen fallen.

Für das Deployment macht sich eine XBAP Applikation recht komfortabel. Man veröffentlicht die Applikation auf einen Webserver und via Hyperlink kann die Applikation gestartet werden. Applikations-Update Mechanismen sind innerhalb einer XBAP-Applikation ebenfalls recht gut umgesetzt.

Anforderungen

Wenn die Anwendung es erfordert, dass man auf das Filesystem zugreifen, oder Einträge in der Registry verwalten muss, sollte man auf alle Fälle eine der beiden ersten Typen wählen.

Egal für welchen Typen man sich entscheidet. WPF unterstützt für alle dieser Typen Möglichkeiten für das Theming und Styling. Auch für Lokalisierung hat man entsprechenden Support, jedoch lange nicht diesen, wie man das von Windows Forms her gewohnt ist. Hier bedarf es eine etwas längere Entwicklungszeit.

Interoperabilität

In WPF fehlen leider auch einige Controls, wie beispielsweise die FileDialog-Klassen für OpenFileDialog und SaveFileDialog. Man ist aber in der Lage, die Windows Forms Assembly (System.Windows.Forms) in einer WPF Applikation einzubinden und die o.g. Klassen stehen einem danach zur Verfügung.

Es ist aber nicht ratsam diesen Weg zu gehen, da es hier zu Namenskonflikten mit Klassen in WPF kommen kann. Empfehlenswert ist der Zugriff über den Microsoft.Win32 Namespace in der PresentationFramework Assembly.

Aber auch den ColorDialog, den FontDialog und anderes findet man vergebens in WPF. In der folgenden Übersicht Windows Forms Controls und  äquivalente WPF Controls bekommt man eine Vergleichstabelle, welche Forms-Controls in WPF nicht vorhanden sind. Auch einige Properties unterscheiden sich, hier sollte man sich Windows Forms and WPF Property Mapping zum Vergleich anschauen.

Nun, wenn man sich für eine Technologie entschieden hat, kann man dennoch beide miteinander kombinieren. Das heißt, man hat entsprechende Controls, um die jeweils andere Technologie einzubinden. In Windows Forms ist das das ElementHost-Control und in WPF das WindowsFormsHost-Control. Einige HowTos zum Verwenden der Controls findet man direkt im MSDN (ElementHost, WindowsFormsHost).

Also, welche Faktoren spielen bei der Wahl zwischen Windows Forms und WPF eine Rolle? Hier ein paar Fragen, um die richtige Technologie, oder den Technologietypen zu ermitteln.

1. Wie stark sind die Fähigkeiten der Entwickler in der jeweiligen Technologie?
2. Können durch den Entwickler fehlenden Forms-Controls ersetzt werden?
3. Verfügt man über Grafik-, oder UI-Designer?
4. Welche Unterstützung von Styling und Theming wird in der Applikation erwartet?
5. Soll die Applikation individuell gestaltet sein?
6. Benötigt die Applikation volle Rechte auf das Betriebssystem?
7. Wird großer Wert auf eine Seitennavigation ähnlich einer Website gelegt?
8. Muss die Applikation mehrsprachig sein?

Fazit

Mit WPF ist man in der Lage, grafisch hochwertige Applikationen zu entwickeln. Es fehlen zwar einige Controls, jedoch ist man in der Lage einen passenden Ersatz zu finden, bzw. in der Lage diesen zu entwickeln. Weiterhin kann durch die Trennung von UI und Logik, die Applikation in einem Team aus Developer und Designer entwickelt werden. Durch die Einteilung in verschiedenen Typen, kann man den richtigen Typen für die jeweilige Aufgabe finden und erhält Unterstützung für nahezu jede Anforderung vom Framework.

Ich hoffe dieser kleine Überblick von Vor- und Nachteilen der beiden GUI Technologien hilft dabei, sich für die richtige Technologie zu entscheiden.

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
• 15. März 2011 -- Cookies in einer WPF Applikation
• 6. März 2011 -- MultiBinding die Zweite