1. Zunächst erzeugt man in Visual Studio ein entsprechendes Projekt mit der Vorlage WPF-Benutzersteuerelementbibliothek.
2. In diesem Projekt kann man das automatisch erzeugte UserControl1 guten Gewissens entfernen (wir wollen ja ein WPF-Steuerelement erstellen).
3. Dafür muss man unser WPF-Steuerelement hinzufügen. (Einfügen –> neues Element –> Benutzersteuerelement)
4. Jetzt geht es darum, aus dem Usercontrol ein Steuerelement zu machen, welches von der Standard-TextBox erbt, damit man die ganzen Standard Geschichten schon fertig hat. Dazu einfach im XAML-Code UserControl durch TextBox ersetzen, und alle Attribute außer den namespaces und dem Klassennamen entfernen, so dass es in etwa so ausschaut:

   <TextBox x:Class="Denis.WPF_Controls.MaskedTextBoxWPF"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   />

   Dadurch sagen wir einfach, dass wir ein Steuerelement erzeugen dass von TextBox erbt. Da es ja auch noch eine entsprechende CodeDatei gibt müssen wir dort ebenfalls sagen, dass wir nicht mehr die partielle Klasse UserControl erweitern, sondern Textbox:

   public partial class MaskedTextBoxWPF : UserControl
   //ersetzen durch
   public partial class MaskedTextBoxWPF : TextBox

5. Jetzt brauchen wir noch ein paar Events die wir behandeln um abzufangen wenn Text eingegeben, gelöscht und eingefügt (copy/paste) wird. Dazu einfach den XAML-Code so erweitern:

   <TextBox x:Class="Denis.WPF_Controls.MaskedTextBoxWPF"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       DataObject.Pasting="TextBox_Pasting"
       PreviewTextInput="TextBox_PreviewTextInput"
       KeyDown="TextBox_KeyDown"
   />

6. Als erstes brauchen wir eine Klassen-Variable, welche den MaskedTextBoxProvider enthält (wofür ein Verweis auf SystemComponentModel benötigt wird). Diese wird dann im Konstruktor mit einer Standardmaske gefüllt und dann initialisiert:

   MaskedTextProvider mktProvider;
   
   public MaskedTextBoxWPF()
   {
       InitializeComponent();
       mktProvider = new MaskedTextProvider("???");
   }

7. Außerdem geben wir die Mask-Eigenschaft nach außen weiter, lassen die im Designer bearbeiten und geben auch ne kleine Doku für das Bearbeiten im Designer an:

   [Browsable(true)]
   [DesignOnly(true)]
   [Description("0 Ziffer - erforderlich; 9 Ziffer oder Leerzeichen - opt.;" +
             "L Buchstabe - erforderlich; ? Buchstabe - opt.")]
   public string Mask
   {
     get
     {
         return mktProvider.Mask;
     }
     set
     {
         mktProvider = new MaskedTextProvider(value);
         Text = "";
     }
   }

8. Als letztes müssen wir noch die Events mit Code füllen.Im PreviewTextInput-Ereignis prüfen wir, ob der Buschstabe hinzugefügt werden darf und brechen ggf. ab.Im Pasting-Ereignis machen wir das selbe mit eingefügtem Text und das KeyDown-Ereignis ist dafür da den Text im MaskedTextBoxProvider aktuell zu halten (falls z.B. was gelöscht wird).

   private void TextBox_PreviewTextInput(object sender, TextCompositionEventArgs e)
   {
     if (mktProvider.Add(e.Text) == false)
     {
         e.Handled = true;
     }
   }
   
   private void TextBox_Pasting(object sender, DataObjectPastingEventArgs e)
   {
     if (e.DataObject.GetDataPresent(typeof(String)))
     {
         String text = (String)e.DataObject.GetData(typeof(String));
         if (mktProvider.Add(text) == false)
         {
             e.CancelCommand();
         }
     }
     else e.CancelCommand();
   }
   
   private void TextBox_KeyDown(object sender, KeyEventArgs e)
   {
     mktProvider.Clear();
     mktProvider.Add(Text);
   }

So, das war’s schon. Man könnte das ganze noch etwas schöner machen, indem man wie bei WinForms die Eingabemaske anzeigt, aber die Funktionalität ist vorhanden und kann so benutzt werden.

Es reicht in XAML den Graphen zu deklarieren und ihn dann über die DataSource zu füllen. Falls man so wie ich mehrere Datenreihen dynamisch hinzufügen will kann man einfach eine entsprechende Series per Code hinzufügen und dann über die Itemsource die Datenquelle binden.

Hier mal ein Beispiel-Graph für ein Balkendiagram, welches Daten Monatsweise anzeigt (dafür ist auch die Formatierung gedacht). Dieser enthält immer eine “lineare” Achse, welche einen normalen Liniengraphen darstellt – ich habe Sie explizit definiert, damit der mindest-Wert immer auf 0 steht und nicht automatisch angepasst wird..

<chartingToolkit:Chart Name="chart1">
   <chartingToolkit:Chart.Axes>
      <chartingToolkit:DateTimeAxis
         Orientation="X" Location="Bottom"
         IntervalType="Months" Interval="1">
         <chartingToolkit:DateTimeAxis.AxisLabelStyle>
            <Style TargetType="chartingToolkit:DateTimeAxisLabel">
               <Setter Property="StringFormat" Value="{}{0:MM-yy}"/>
            </Style>
         </chartingToolkit:DateTimeAxis.AxisLabelStyle>
      </chartingToolkit:DateTimeAxis>
      <chartingToolkit:LinearAxis Orientation="Y"
         Location="Left" Minimum="0"
         ShowGridLines="True" />
   </chartingToolkit:Chart.Axes>
</chartingToolkit:Chart>

der dann ohne Daten so ausschaut:

Um diesem dann dynamisch mehr “Series”, also weitere z.B. Balken/Linien hinzuzufügen kann reicht dann dieser Code. Durch das setzen von Title wird der entsprechende Titel in der legende angezeigt.

ColumnSeries serie = new ColumnSeries();
// Alternativ z.B.
// LineSeries serie = new LineSeries();
serie.Title = "Titel für Legende";
serie.DependentValuePath = "Y-Wert-komponente";
serie.IndependentValuePath = "X-Wert-komponente";
serie.ItemsSource = daten;
// chart1, weil ich dem Chart im XAML
// diesen kreativen Namen spendiert habe,
chart1.Series.Add(serie);

Eine Sache, welche schon als bug reported wurde ist allerdings, dass momentan ein Graph mit einer DateTimeAxis und einer ColumnSeries keine Daten anzeigt, wenn nur ein Datum in der Liste für die Itemsource vorhanden ist. Dies liegt daran, dass mit Hilfe zumindest eines anderen Balkens versucht wird, die Breite für den Balken zu berechnen. Das wird aber im nächsten Release gefixt werden.

The project File "...Projekt.csproj" is not valid.
Das importierte Projekt C:\Microsoft.CSharp.targets wurde nicht gefunden.
...

Mit ein wenig Glück konnte ich die Lösung finden: das Service Pack 1 für Expression Blend installieren! Nachdem ich das installiert hatte, funktioniert alles wunderbar. Jetzt wird animiert!

Vor kurzem ist AnkhSVN 2.0 erschienen was eine wesentlich bessere Integration bietet, da es als natives SCC für Visual Studio implementiert wurde. Soweit ich es nach ein paar Tagen testen beurteilen kann hat es sich nicht nur insofern verbessert als dass Outlook-Plugin Projekte nun ohne Probleme damit verwaltet werden können. Die weiteren Pluspunkte sind:

• subjektive Beschleunigung des Eincheck-Vorgangs
• Bessere Integration (eigenes Ausgabe-Fenster)
• schönere Symbole

Falls mir noch mehr Punkte einfallen werde ich Sie hinzufügen. Ich werde noch eins der größeren Nachteile testen müssen: Die Zusammenarbeit von mehreren Personen an einem einzigen Projekt. Bisher wurde dabei irgendwann die Projektdatei beschädigt wenn z.B. unterschiedliche Leute gleichzeitig Formulare in ein Projekt eingefügt haben.

1. Zunächst muss man wissen was man sucht. Was WMI alles zur Verfügung stellt kann man hier in der msdn nachlesen.
2. Dann baut man einen string zusammen der die Form einer SQL-Query hat.
3. Als nächstes benutzt man einen ManagementObjectSearcher um die Daten zu suchen. Dieser gibt eine Collection mit den gefundenen ManagementObject-Objekten zurück. Über diese kann man mit dem Namen gewünschten Eigenschaft zugreifen.

Hier ein Beispiel um den Namen, die ID und die MAC-Adresse aller Netzwerkkarten (virtuell oder nicht) in einer MessageBox anzeigen zu lassen:

string query = "SELECT * FROM Win32_NetworkAdapter WHERE NetConnectionID IS NOT null";
ManagementObjectSearcher sucher = new ManagementObjectSearcher(query);

string s = "";
foreach (ManagementObject m in sucher.Get())
{
    // NetConnectionID Name der Karte wie in der Systemsteuerung
    // DeviceID ID HardwareID wie in der Registry
    s += m["NetConnectionID"] +
        " ID " + m["DeviceID"] +
        " MAC " + m["MACAddress"] + "\n";
}

MessageBox.Show(s);

Der erste Eindruck: Alles ist wie vorher, nur etwas aufgeräumter.

Als erstes habe ich mal ein WPF-Projekt erstellt und mal geprüft was man da so machen kann. Im ersten Moment war ich fasziniert von den Möglichkeiten die der Designer mir jetzt bietet : Man kann das Fenster zoomen, was für die Entwicklung von größeren Fenster extrem cool ist. Dann kam das große Erwachen: Die einzige Möglichkeit hier ein Formular zu erstellen ist indem man es per Hand macht. Aus welchen Gründen auch immer hat Microsoft das schöne und einfache Designen per Maus entfernt und meint, dass wir jetzt alles schreiben müssen. Somit sind wir Programmierer nun zu Webdesignern degradiert worden (obwohl die teilweise komfortablere WYSWIG-Werkzeuge haben…).

Hier die Sachen die mir negativ aufgefallen sind:

• Das TabControl-Steuerelement:
  • Wenn man dieses in das Formular zieht kann man zwar per rechts-klick Reiter hinzufügen, allerdings ist es nicht möglich hier dann Steuerelemente einzufügen. Weder Container-Elemente noch andere.
  • Man kann (nachdem man per Hand in der XML-Ansicht Steuerelemente in die Registerkarten eingefügt hat) nicht per klick auf die Reiter auf einen anderen als den ersten Reiter wechseln. Der einzige Workaround besteht darin, die SelectedIndex auf den Index des Reiters zu setzen den man sehen möchte
• Die Toolbox ist nicht mehr gruppiert, so dass man nicht per z.B. alle Container-Steuerelemente zusammen hat.
• Es gibt keinen Ereignis-Reiter mehr in den Eigenschaften eines Steuerelements, so dass man Intellisense in der XML-Ansicht durchsuchen muss um das richtige Ereignis zu finden. Dieses ist natürlich schwieriger, da hier auch Eigenschaften der Steuerelemente in der Liste stehen.

Nach diesen Eindrücken ist WPF für mich erst einmal gestorben und ich werde weiterhin Windows-Forms benutzen. Mal schauen was das SP1 bzw. die nächste .Net Framework Version bringt.