Donnerstag, 20. Juni 2013

Mit MEFedMVVM zur WPF Anwendung

Ich nutze nun schon seit geraumer Zeit das Framework Cinch von Sacha Barber um meine Anwendungen zu entwickeln. Cinch selber macht sich MEFedMVVM zu nutze um die Bindung zwischen View und ViewModel zu erstellen.

Mit dem Framework ist es leicht für die Design Zeit die gebundenen Klassen auszutauschen und das Testen wird durch die Schnitstellen sehr vereinfacht.

Hier die Links:

Dienstag, 18. Juni 2013

Command Line Args mit MEFedMVVM

Wie bekommt man eigentlich Command Line Argumente mit MEFedMVVM in sein ViewModel? Die Argumente kommen ja wie üblich in WPF der StartUp Methode der App Klasse mit.

Es gibt zwei Wege:
  1. Entweder man nutzt die Argumente der StartUp Methode und weißt diese einem Service des Containers zu.
     ICommandLineArgs service = ViewModelRepository.Instance.Resolver.Container.GetExport<ICommandLineArgs>().Value;  
    
  2. Oder man greift ganz einfach auf die Methode System.Environment.GetCommandLineArgs() zu. Das hat den Vorteil, das es nicht nötig ist, in der StartUp Methode die Argumente zuzuweisen.
    Nutzt man aber trotzdem einen eigenen Service, der intern die System.Environment.GetCommandLineArgs() nutzt, kann man diesen Service, wie gewohnt, seinem ViewModel übergeben. Für die Tests kann dann ganz einfach ein Test Service geschrieben werden, um die Argumente für die Testfälle vorzugeben.

Sonntag, 16. Juni 2013

Lesen um zu lernen

Jeden Tag schreitet die Entwicklung ein Stückchen vorran. Immer auf dem aktuellen Stand zu sein, ist nicht immer leicht. Clean Code Developer rät deshalb sechs Fachbücher im Jahr zu lesen. Wenn man nun mal überlegt, wie viel Fachbücher kosten, kann das schnell mal ins Geld gehen. Nehmen wir mal an ein Buch kostet 60 Euro und sollen sechs im Jahr lesen. Das wären schon mal 360 Euro im Jahr. Dabei gibt es immer wieder Bücher, bei denen schnell auffällt, dass das Buch für einen selbst nicht geeignet ist. Das heißt man würde sich, um die Anzahl sechs auch wirklich zu lesen, nochmal ein bis zwei Bücher extra kaufen. Und so landet man schnell bei kosten zwischen 400 und 500 Euro im Jahr.

safaribooksonline.com kann die Geldbörse entlasten. Für gut 240 Euro im Jahr, kann man eine viele viele Bücher online und auf mobilen Geräten lesen. Es gibt dort Fachbücher ohne ende und man kann sich zehn Bücher im Monat anschauen. Außerdem ist eine Volltextsuche über alle Bücher möglich, was einem das Suchen bei Problemen extrem vereinfacht.
Für 35 Euro monatlich bekommt man sogar einen komplett Zugang, in dem so viele Bücher gelesen werden können, wie man möchte.
Für die mobilen Geräte gibt es sogar die Möglichkeit die Bücher offline zu lesen!

Reinschauen lohnt sich in jedem Fall. Für 15 Tage kann man kostenfrei alles ausprobieren!

Donnerstag, 13. Juni 2013

Nachtrag zu: Mauszeiger im Sourcecode setzen


Wie ich ja schon beschrieben hatte, ist es möglich den Cursor aus dem Sourcecode heraus zu setzen. Allerdings ist dabei zu beachten, dass dies bedeutet, dass das setzen der Eigenschaft Cursor am WPF Control keine Auswirkung mehr hat. Erst wenn man die Eigenschaft wieder auf null setzt, wird die Cursor Eigenschaft des Controls wieder berücksichtigt.

Dementsprechend sollte mein Beispiel viel eher so aussehen:
 private void OnIsBusyChanged(object sender, bool isBusy)  
 {  
      if (isBusy)
           Mouse.OverrideCursor = Cursors.Wait;
      else
           Mouse.OverrideCursor = null;
 }

So wird die Anwendung, wenn sie in den Busy Modus versetzt wird, den Wait Cursor anzeigen. Ansonsten den Cursor, den das WPF Control vorgibt.

Mittwoch, 12. Juni 2013

TFS for free

Mit dem Team Foundation Server von Microsoft können Projekte geplant und verwaltet werden. Sowohl eine Sourcecode Verwaltung, als auch einen Buildagent bringt er mit sich.

Auf der Seite tfs.visualstudio.com kann man diesen kostenfrei nutzen!

Folgend ein paar Argumente, warum man es einfach mal versuchen sollte:

  • Es können beliebig viele Projekte angelegt werden.
  • Bei der Sourcecode Verwaltung kann sogar zwischen der Microsoft eigenen und Git gewählt werden.
  • Agile Projektplanung wird vom TFS auch unterstützt.
  • Tests können ausgeführt werden.
  • Arbeiten in Teams bei der kostenfreien Variante mit bis zu fünf Personen.
Und alles was man braucht, ist eine Windows Live ID. Also ausprobieren lohnt sich!

Dienstag, 11. Juni 2013

Mobile Farbwahl mit dem iPhone

Nachdem ich vor kurzem über den Adobe Service Kuler berichtete, habe ich nun auch eine mobile Version des Services entdeckt. Sobald man die App auf dem iPhone startet, wird die Kamera aktiviert und die Farbwahl beginnt.

Die fünf Farbpunkte sucht sich die App automatisch zusammen. Es ist möglich das aktuelle Bild mit einem Klick zu fixieren und die Farbpunkte beliebig zu verschieben.
Ein Farbschema kann dann gespeichert und wenn gewünscht auch direkt der Community zur Bewertung freigegeben werden.

Folgend der Link zur App:

Montag, 10. Juni 2013

Mauszeiger im Sourcecode setzen

Der Cursor kann, nicht nur wie schon beschrieben im XAML gesetzt werden. Er kann auch im Sourcecode, wie zum Beispiel im ViewModel, überschrieben werden.

Als klassisches Beispiel habe ich einen Event-Handler in dem ich schaue, ob die Anwendung Busy ist oder nicht und dementsprechend einen Wait Cursor oder einen Pfeil anzeigt.

 private void OnIsBusyChanged(object sender, bool isBusy)  
 {  
      if (isBusy)  
           Mouse.OverrideCursor = Cursors.Wait;  
      else  
           Mouse.OverrideCursor = Cursors.Arrow;  
 }

Sonntag, 9. Juni 2013

LED Control in WPF

Wie ich ja schon mal berichtete, ist es in WPF recht einfach ein eigenes Control zu entwickeln. Nun möchte ich das mal anhand eines Beispiels belegen.
Ziel: Ein LED Control, bei dem es möglich ist eine beliebige Farbe vorzugeben und außerdem soll das Control in der Größe auch skalierbar sein, ohne das es an schärfe verliert.

Als erstes legen wir eine neue Klasse mit dem Namen "Led" an. Diese bekommt eine DependencyProperty mit dem Namen Color vom Typ System.Windows.Media.Color. Das ist dann später die Eigenschaft, die im XAML gesetzt werden muss, um der Led eine Farbe zu geben.

Hier die Led.cs Datei
 using System.Windows;  
 using System.Windows.Controls;  
 using System.Windows.Media;  

 namespace LedSpike  
 {  
   public class Led : Control  
   {  
     public static readonly DependencyProperty ColorProperty =  
       DependencyProperty.Register("Color", typeof(Color), typeof(Led), new PropertyMetadata(default(Color)));  
     public Color Color  
     {  
       get { return (Color)GetValue(ColorProperty); }  
       set { SetValue(ColorProperty, value); }  
     }  
     static Led()  
     {  
       DefaultStyleKeyProperty.OverrideMetadata(typeof(Led), new FrameworkPropertyMetadata(typeof(Led)));  
     }  
   }  
 }  

Jedes Control benötigt ein ContentControl, ohne dieses kann es nicht angezeigt werden. Wie man unterschiedliche Themes anlegt, habe ich hier beschrieben.

Wir legen nun erstmal den Themes Ordner in unserem Projekt an und erstellen die Generic.xaml Datei, um das Standard Template für unser Control zu erstellen.
Da das Control in verschiedenen Größen genutzt werden soll, nutzen wir eine Viewbox. Danach erstellen wir eine Ellipse und legen einen Farbverlauf fest, damit das Control auch modern aussieht. Unser Verlauf hat zwei Farben, wobei ich die eine Farbe generell mit Weiß vorbelege, um einen schimmernden Effekt zu erzeugen. Die andere Farbe habe ich an die DependencyProperty gebunden.

Hier die Themes/Generic.xaml Datei:

 <ResourceDictionary  
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
   xmlns:local="clr-namespace:LedSpike">  
   <Style TargetType="{x:Type local:Led}">  
     <Setter Property="Template">  
       <Setter.Value>  
         <ControlTemplate TargetType="{x:Type local:Led}">  
           <Viewbox>  
             <Ellipse Margin="10,10,10,10" Width="300" Height="300">  
               <Ellipse.Fill>  
                 <RadialGradientBrush Center="0.6,0.35" GradientOrigin="0.6,0.35" RadiusY="0.67" RadiusX="0.67">  
                   <RadialGradientBrush.RelativeTransform>  
                     <TransformGroup>  
                       <ScaleTransform CenterY="0.35" CenterX="0.6" ScaleY="1" ScaleX="1" />  
                       <SkewTransform AngleY="0" AngleX="0" CenterY="0.35" CenterX="0.6" />  
                       <RotateTransform Angle="-4.447" CenterY="0.35" CenterX="0.6" />  
                       <TranslateTransform X="0" Y="0" />  
                     </TransformGroup>  
                   </RadialGradientBrush.RelativeTransform>  
                   <GradientStop Color="{Binding RelativeSource={RelativeSource TemplatedParent}, Path=Color}" Offset="0.8" />  
                   <GradientStop Color="White" />  
                 </RadialGradientBrush>  
               </Ellipse.Fill>  
             </Ellipse>  
           </Viewbox>  
         </ControlTemplate>  
       </Setter.Value>  
     </Setter>  
   </Style>  
 </ResourceDictionary>  

Die Benutzung ist sehr einfach. Es bedarf lediglich einen Namespace Eintrag und das Led Element im XAML.

 <Window  
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
     xmlns:local="clr-namespace:LedSpike" x:Class="LedSpike.MainWindow"  
     Title="LED spike" Height="200" Width="200">  
   <Grid>  
     <local:Led Color="Red" />  
   </Grid>  
 </Window>  

Das Ergebnis:


Samstag, 8. Juni 2013

WPF Resourcen in mehrere Dateien auslagern

In WPF hat man die Möglichkeit Styles und Templates für seine Controls in Dateien auszulagern. Die Klasse ResourceDictionary hilf einem dabei.
 <ResourceDictionary  
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">  
 </ResourceDictionary>  
Um dann mehrere Resourcen zu laden kommt die MergedDictionaries Property ins Spiel. Wenn man zum Beispiel einem Window verschiedene Resourcen zuweisen möchte, könnte das so aussehen:
 <Window x:Class="WpfSpike.MainWindow"  
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">  
   <Window.Resources>  
     <ResourceDictionary>  
       <ResourceDictionary.MergedDictionaries>  
         <ResourceDictionary Source="Sample1.xaml" />  
         <ResourceDictionary Source="Sample2.xaml" />  
       </ResourceDictionary.MergedDictionaries>  
     </ResourceDictionary>  
   </Window.Resources>  
 </Window>h
Wie man sehen kann, wird dem ResourceDictionary über die Source Property der Pfad zur Resource übergeben.

Freitag, 7. Juni 2013

Mauszeiger im XAML setzen

Jedes WPF Control bzw jedes FrameworkElement hat eine Cursor Eigenschaft. Mit der kann man jedem Control den gewünschten Cursor zuordnen.

 <StackPanel>  
      <Label Cursor="Hand">label with hand cursor</Label>  
      <Label Cursor="Help">label with help cursor</Label>  
 </StackPanel>  

Das Ergebnis ist dementsprechend:



Die Cursor Eigenschaft vererbt sich auch weiter, so dass jedes Child Control auch davon betroffen ist.

Donnerstag, 6. Juni 2013

WPF Themes

Warum sieht eigentlich eine WPF Anwendung unter Windows XP anders aus als unter Windows 7 oder einer anderen Windows Version?

WPF macht sich dem System Theme zu nutze, um seine Standard Controls der Windows Umgebung anzupassen. Stellt man unter Windows 7 den System Theme auf "Windows klassisch", so besitzt das Window der eigenen Anwendung wieder den Rahmen, den man noch aus Windows XP Zeiten kennt.

Schreibt man ein eigenes Control, so sollte man sich überlegen, ob es sinnvoll ist, den verschiedenen Themes auch ein unterschiedliches Layout zu geben. Möchte man lediglich ein Design für alle Themes haben, so muss nur in der Generic.xaml Datei im Themes Verzeichnis ein ControlTemplate angelegt werden. Sollen auch andere Themes unterstützt werden, so können zum Beispiel die Datei Themes/Aero.NormalColor.xaml für den Standard Windows 7 Theme oder Themes/Classic.xaml für den klassischen Theme angelegt werden.

Hinweis: Das ThemeInfoAttribute Attribut darf natürlich nicht fehlen, wenn man ein eigenes Control in WPF schreibt!

Mittwoch, 5. Juni 2013

Hilfe bei der Farbwahl

Immer wieder steht man als Entwickler vor der Qual der Wahl. Es gibt tausende verschiedene Farben, aber welche von denen passen wirklich zusammen und lassen sich für die eigene Anwendung verwenden? Das bei gelber Schrift auf blauen Hintergrund einem die Nackenhaare zu Berge stehen, ist mittlerweile vielen bekannt. Aber welche Farbe nun wirklich mit anderen Farben harmoniert, ist trotzdem nicht immer so leicht zu entscheiden, weil solche Entscheidungen oft nur nach "Gefühl" getroffen werden.

Auf der Internetseite kuler.adobe.com bekommt man aber Unterstützung! Zum einen gibt es einige Farbkombinationen als Vorlage und zum anderen kann man auch selber Farbkominationen erstellen und bewerten lassen!

Probiert es einfach mal aus! Ich finde, man merkt auf anhieb, dass die Farben dort sofort miteinander harmonieren und so einem die Farbwahl extrem erleichtert wird!

Dienstag, 4. Juni 2013

SplashScreen in WPF

Einen SplashScreen in WPF Anwendungen anzuzeigen ist leicht und schnell mit dem Visual Studio gemacht. Es muss lediglich ein Bild dem WPF Projekt hinzugefügt und die Build Action auf "SplashScreen" gesetzt werden.


Beim Kompilieren wird dann automatisch eine Instanz der Klasse SplashScreen erstellt und dem Konstruktor den Pfad des Bildes übergeben. Die Instanz besitzt eine Methode Show, die mit dem Parameter true aufgerufen wird, bevor eine Instanz der eigentlichen App erstellt wird. Der Parameter true sorgt dafür, dass sich der SplashScreen nach dem Ladevorgang wieder automatisch schließt.

Es ist natürlich auch möglich einen SplashScreen ohne die Build Action zu nutzen. Dafür muss lediglich die SplashScreen Klasse direkt in der Methode OnStartup der App aufgerufen werden.

Montag, 3. Juni 2013

Übersetzungen? Nein danke!

Eine Anwendung zu übersetzen kann unter umständen sehr lästig sein! Grade wenn man die gewünschte Fremdsprache nur selten oder gar nicht spricht. Deshalb macht es auf jeden fall Sinn die Anwendung erstmal in der Muttersprache zu verfassen. Denn in keiner anderen Sprache weiß man besser, wie man einen Satz am besten formuliert.

Trotzdem sollten schon zu beginn der Anwendung Resource Dateien angelegt werden. Wie man das macht beschreibe ich hier. Das erspart am Ende der Entwicklung das nervige und zeitaufwändige Suche nach den Stellen, die lokalisiert werden müssen.

Hat man die Anwendung fertig, kann man sich ganz in ruhe um die Übersetzung kümmern oder diese von einer Fremdfirma oder Kollegen machen lassen.

Sonntag, 2. Juni 2013

Gruppieren von Resourcen in .NET Anwendungen

Eine Anwendung mehrsprachig zu machen, ist in der .NET Welt schnell und einfach gemacht. Auch im XAML Code von WPF Anwendungen sind diese einfach, wie auch hier beschrieben, zu nutzen. Wichtig für die Nutzung in WPF ist, dass der Zugriff auf die Resource public ist, ansonsten kann diese nicht direkt  gebunden werden.

Aber nun endlich zum eigentlichen Thema. Anwendungen können sehr schnell, sehr groß werden und so kann eine Resourcen Datei schnell mehrere hundert oder tausende Einträge beinhalten. Man sollte sich schon zu beginn der Entwicklung überlegen, ob und wie es nicht Sinn machen könnte, die Resourcen zu gruppieren.

Eine gute Stategie ist mehrere Resource Dateien anzulegen. Zum Beispiel für jeden großen Bereich eine Datei. So könnte eine Anwendung zum Beispiel in die Bereiche Main und Settings getrennt werden. Außerdem lege ich auch immer eine Messages Resource an, diese beinhaltet alle Nachrichten, die in MessageBoxen angezeigt werden.