Rash thoughts about .NET, C#, F# and Dynamics NAV. » C#

Observing global hotkeys in C# / F#

Steffen Forkmann — Fri, 06 Nov 2009 10:08:05 +0000

I recently had the problem to register a global hotkey, but my “old” Win32-API calls didn’t work with WPF. I looked around the web and found the “Managed Windows API”, but I didn’t want to add another external dependency to my project, so I extracted the core functions for registering hotkeys and condensed the code to a new version.

As the original “Managed Windows API” is licensed by the GNU Lesser General Public License (LGPL) I want to provide my modifications here.

First we need a Window which can dispatch the window messages to our event handlers:

/// 
/// A Win32 native window that delegates window messages to 
/// handlers. So several
/// components can use the same native window to save 
/// "USER resources". This class
/// is useful when writing your own components.
/// 
public sealed class EventDispatchingNativeWindow : NativeWindow
{
    private static readonly Object MyLock = new Object();
    private static EventDispatchingNativeWindow _instance;
 
    /// 
    /// Create your own event dispatching window.
    /// 
    public EventDispatchingNativeWindow()
    {
        CreateHandle(new CreateParams());
    }
 
    /// 
    /// A global instance which can be used by components 
    /// that do not need their own window.
    /// 
    public static EventDispatchingNativeWindow Instance
    {
        get
        {
            lock (MyLock)
            {
                return 
                  _instance ?? 
                     (_instance = 
                       new EventDispatchingNativeWindow());
            }
        }
    }
 
    /// 
    /// Attach your event handlers here.
    /// 
    public event WndProcEventHandler EventHandler;
 
    /// 
    /// Parse messages passed to this window and send 
    /// them to the event handlers.
    /// 
    /// A System.Windows.Forms.Message 
    /// that is associated with the 
    /// current Windows message.
    protected override void WndProc(ref Message m)
    {
        bool handled = false;
        if (EventHandler != null)
            EventHandler(ref m, ref handled);
        if (!handled)
            base.WndProc(ref m);
    }
}

Now we can write our global hotkey handler class:

/// 
/// Specifies a class that creates a global keyboard hotkey.
/// 
public class GlobalHotkey
{
    private static readonly Object MyStaticLock = new Object();
    private static int _hotkeyCounter = 0xA000;
 
    private readonly int _hotkeyIndex;
    private readonly IntPtr _hWnd;
 
    /// 
    /// Initializes a new instance of this class.
    /// 
    /// The keys.
    /// if true [CTRL].
    /// if true [alt].
    /// if true [shift].
    /// if true [win key].
    public GlobalHotkey(Keys keys, bool ctrl, 
               bool alt, bool shift, bool winKey)
    {
        KeyCode = keys;
        Ctrl = ctrl;
        Alt = alt;
        Shift = shift;
        WindowsKey = winKey;
        EventDispatchingNativeWindow.Instance.EventHandler 
                += NwEventHandler;
        lock (MyStaticLock)
        {
            _hotkeyIndex = ++_hotkeyCounter;
        }
        _hWnd = EventDispatchingNativeWindow.Instance.Handle;
        Enable();
    }
 
    /// 
    /// The key code of the hotkey.
    /// 
    public Keys KeyCode { get; private set; }
 
    /// 
    /// Whether the shortcut includes the Control modifier.
    /// 
    public bool Ctrl { get; private set; }
 
    /// 
    /// Whether this shortcut includes the Alt modifier.
    /// 
    public bool Alt { get; private set; }
 
    /// 
    /// Whether this shortcut includes the shift modifier.
    /// 
    public bool Shift { get; private set; }
 
    /// 
    /// Whether this shortcut includes the Windows key modifier.

      /// 
    public bool WindowsKey { get; private set; }
 
    ~GlobalHotkey()
    {
        Disable();
        EventDispatchingNativeWindow.Instance.EventHandler 
            -= NwEventHandler;
    }
 
    /// 
    /// Enables the hotkey. When the hotkey is enabled, 
    /// pressing it causes a
    /// HotkeyPressed event instead of being 
    /// handled by the active application.
    /// 
    private void Enable()
    {
        // register hotkey
        int fsModifiers = 0;
        if (Shift) fsModifiers += ModShift;
        if (Ctrl) fsModifiers += ModControl;
        if (Alt) fsModifiers += ModAlt;
        if (WindowsKey) fsModifiers += ModWin;
        bool success = 
           RegisterHotKey(_hWnd, _hotkeyIndex, 
                fsModifiers, (int) KeyCode);
 
        if (!success)
            throw new 
              Exception(
                "Could not register hotkey (already in use).");
    }
 
    /// 
    /// Disables this instance.
    /// 
    private void Disable()
    {
        // unregister hotkey
        UnregisterHotKey(_hWnd, _hotkeyIndex);
    }
 
    /// 
    /// Occurs when the hotkey is pressed.
    /// 
    public event EventHandler HotkeyPressed;
 
    private void NwEventHandler(ref Message m, ref bool handled)
    {
        if (handled) return;
        if (m.Msg != WmHotkey || 
                m.WParam.ToInt32() != _hotkeyIndex)
            return;
        if (HotkeyPressed != null)
            HotkeyPressed(this, EventArgs.Empty);
        handled = true;
    }
 
    #region PInvoke Declarations
 
    private const int ModAlt = 0×0001;
    private const int ModControl = 0×0002;
    private const int ModShift = 0×0004;
    private const int ModWin = 0×0008;
    private const int WmHotkey = 0×0312;
 
    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool RegisterHotKey(IntPtr hWnd, 
          int id, int fsModifiers, int vlc);
 
    [DllImport("user32.dll", SetLastError = true)]
    private static extern bool UnregisterHotKey(IntPtr hWnd, 
          int id);
 
    #endregion
}

Now we can easily register a global hotkey or use it as an observable in F#:

/// system-wide keyboard hook
let hotkey = new GlobalHotkey(Keys.Q,true,false,false,false)
let hookObserver =
  hotkey.HotkeyPressed  
    |> Observable.subscribe (fun _ -> printfn "Hotkey pressed")

Extensibility of functions with lambdas (in F# and C#)

Steffen Forkmann — Wed, 01 Jul 2009 14:02:25 +0000

One of the nice properties of functional programming languages is the easy extensibility of custom functions. Let’s consider a simple F# function (from “FAKE – F# Make”) for a recursive directory copy:

open System
open System.IO

/// Copies a directory recursive
/// Thanks to Robert Pickering http://strangelights.com/blog/
///  param target: target directory : string
///  param source: source directory : string
let CopyDir target source =
  Directory.GetFiles(source, "*.*", SearchOption.AllDirectories)
    |> Seq.iter (fun file ->
      let newFile = target + file.Remove(0, source.Length)
      printf "%s => %s" file newFile
      Directory.CreateDirectory(Path.GetDirectoryName(newFile)) |> ignore
      File.Copy(file, newFile, true))

If we want to allow users to set custom file filters, we can add a third parameter:

/// Copies a directory recursive
/// and allows to filter the files
/// Thanks to Robert Pickering http://strangelights.com/blog/
///  param target: target directory : string
///  param source: source directory : string
///  param filterFile: FilterFunction: string -> bool
let CopyDirFiltered target source filterFile =
  Directory.GetFiles(source, "*.*", SearchOption.AllDirectories)
    |> Seq.filter filterFile
    |> Seq.iter (fun file ->
      let newFile = target + file.Remove(0, source.Length)
      printfn "%s => %s" file newFile
      Directory.CreateDirectory(Path.GetDirectoryName(newFile)) |> ignore
      File.Copy(file, newFile, true))

Now we can define some filter functions:

/// Exclude SVN files (path with .svn)
/// excludeSVNFiles: string -> bool
let excludeSVNFiles (path:string) = not <| path.Contains ".svn"

/// Includes all files
/// allFiles: string -> bool 
let allFiles (path:string) = true

Now it is possible to use CopyDirFiltered in the following ways:

/// Copies all files <=> same as CopyDir
CopyDirFiltered "C:\\target" "C:\\source" allFiles

/// Copies all files except SVN files
CopyDirFiltered "C:\\target" "C:\\source" excludeSVNFiles

/// Copies all files only if random number <> 2
let r = new Random()
CopyDirFiltered "C:\\target" "C:\\source" (fun path -> r.Next(5) <> 2)

Extensibility of functions in C#

Of course we can do the same thing in C# 3.0:

/// 
/// Copies a directory recursive
/// and allows to filter the files
/// 
/// The target.
/// The source.
/// The file filter.
public static void CopyDirFiltered(string target, string source,
                                   Func<string, bool> fileFilter)
{
    string[] allFiles = Directory.GetFiles(
        source, "*.*", SearchOption.AllDirectories);
    foreach (string file in from f in allFiles
                            where fileFilter(f)
                            select f)
    {
        string newFile = target + file.Remove(0, source.Length);
        Console.WriteLine("{0} => {1}", file, newFile);
        Directory.CreateDirectory(Path.GetDirectoryName(newFile));
        File.Copy(file, newFile, true);
    }
}

Now it is easy to use the C# function with lambdas:

“A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types.”

[MSDN]

Func<string, bool> filterSVN = x => !x.Contains(".svn");
Func<string, bool> allFiles = x => true;

/// Copies all files <=> same as CopyDir
CopyDirFiltered("C:\\target", "C:\\source", allFiles);

/// Copies all files except SVN files
CopyDirFiltered("C:\\target", "C:\\source", filterSVN);

/// Copies all files only if random number <> 2
var r = new Random();
CopyDirFiltered("C:\\target", "C:\\source", path => r.Next(5) != 2);

Keeping this simple technique in mind allows to create very flexible functions.

Debugging in Dynamics NAV 2009

Steffen Forkmann — Thu, 16 Oct 2008 11:41:09 +0000

Claus Lundstrøm zeigt in einem schönen Blogpost wie man in NAV2009 den Code auf Seite der ServiceTier (also auch remote) debuggen kann – und zwar über Visual Studio 2008 direkt im generierten C#-Code. Mit dieser Variante ist man nicht mehr gezwungen das Debugging über den Classic-Client zu tun, sondern kann direkt aus dem Dynamics NAV RoleTailored-Client debuggen.

Dummerweise ist der generierte C#-Code, wie das bei generiertem Code eigentlich immer der Fall ist, nicht gerade “optisch schöner” C#-Style und hat auch nur noch wenig mit dem Original-C/AL-Code zu tun – ist aber immerhin lesbar.

Das ist ein wirklich interessanter Ansatz und erlaubt mit etwas Geschick auch UnitTesting für NAV 2009. Dafür werde ich demnächst mal versuchen ein kleines Beispiel zu bloggen.

Technologie Highlights von Heute und Morgen! – Umfrage auf der BASTA! 2008

Steffen Forkmann — Tue, 14 Oct 2008 07:02:56 +0000

Florian Mätschke hat soeben seine auf der BASTA! 2008 in Mainz angekündigte Umfrage auf seinem Blog veröffentlicht. Dabei wurden die BASTA!-Speaker zu der Technologie befragt, die sie im Moment am meisten fasziniert. “Gewinner” ist übrigens Silverlight 2 geworden, dicht gefolgt von funktionaler Programmierung (in F# bzw. LINQ) – wofür ich mich übrigens auch entschieden habe.

Insgesamt ist das Umfrageergebnis, wie für die BASTA! zu erwarten war, sehr .NET-lastig. Obwohl auf der Abendveranstaltung noch Technologien wie Waschmaschine und Auto als faszinierend erachtet wurden, haben sich die meisten Speaker schlussendlich für ihr Vortragsthema im weitesten Sinne entschieden.

Ich muss sagen, dass ich das Konzept der Umfrage sehr interessant finde. Das Problem ist nur, dass man z.B. auf einer Java-Konferenz natürlich vollkommen konträre Ergebnisse erzielt. Um die wirklichen “Technologie Highlights“ zu ermitteln müsste man die Umfrage selbstverständlich viel größer und anonymisiert anlegen.

F# option types und generische Listen in C# verwenden

Steffen Forkmann — Sun, 12 Oct 2008 12:08:00 +0000

Luis Fallas beschreibt in seinem Blog (“Exploring Beautiful Languages”) an einem sehr schönen Beispiel, wie man die F# option types mit Hilfe von Extension Methods in C# verwenden kann.

Hier ist eine generische Variante zu seiner Exists()-Methode:

open System.Runtime.CompilerServices

[]

module Extensions =

[]

  let Exists(opt : 'a option) =

    match opt with

      | Some _ -> true

      | None –> false

Auf ähnlichem Wege kann man übrigens auch die generischen F#-Listen in System.Collections.Generic.List umwandeln:

[]

let ToCSharpList(list : 'a list) =

  let csharpList =

    new System.Collections.Generic.List<'a>()

  list |> List.iter (fun item -> csharpList.Add item)

  csharpList

Der umgekehrte Weg (von C# nach F#) ist fast analog, allerdings muss man die Liste drehen:

static class Extensions

///

  /// Converts a System.Collections.Generic.List

  /// in the corresponding F# list.

///

  public static Microsoft.FSharp.Collections.List

     ToFSharpList(this List list)

      var fSharpList =

        Microsoft.FSharp.Collections.List.Empty;

      for (int i = list.Count - 1; i >= 0; i--)

       fSharpList =

          Microsoft.FSharp.Collections.List.Cons(

            list[i],

            fSharpList);

      return fSharpList;

Microsoft Dynamics Mobile 1.1 released

Steffen Forkmann — Sat, 05 Apr 2008 09:53:34 +0000

Microsoft hat am 31.3.2008 auf PartnerSource die erste Version von Dynamics Mobile veröffentlicht. Dabei handelt es sich primär um ein auf .NET basierendes Architekturkonzept mit dem man Mobile Endgeräte (mit Windows Mobile 5.0 oder 6.0) an ERP-Systeme (Dynamics NAV oder AX) anbinden kann. Weiterhin wird mit “Mobile Sales” jedoch eine umfangreiche Beispielanwendung mitgeliefert.

Das Release umfasst:

Microsoft Dynamics Mobile – Mobile Development Tools.zip
- Server und Framework Komponenten, sowie Beispielquellcode in C#
Microsoft Dynamics Mobile – Mobile Sales.zip
- Installer für “Mobile Sales”, die Beispielanwendung für Dynamics Mobile
Microsoft Dynamics Mobile – Documentation.zip
- Installer für die Dokumentation der Mobile Development Tools und Mobile Sales

Dynamics Mobile wird momentan unterstützt für:

Microsoft Dynamics NAV 5.0 SP1
Microsoft Dynamics NAV 4.0 SP3
Microsoft Dynamics AX 4.0 SP1
Microsoft Dynamics AX 4.0 SP2

ReSharper 3.0 für Visual Studio 2005 im Test – Refactoring für Profis

Steffen Forkmann — Sat, 06 Oct 2007 10:03:11 +0000

ReSharper ist ein Plugin der Firma JetBrains für Visual Studio, das sich speziell die Produktivitätssteigerung beim Entwickeln als Ziel gesetzt hat. Besonderes Augenmerk wird dabei auf die Refactoring-Unterstüzung gelegt, also auf das nachträgliche Umgestalten von Quellcode. JetBrains wirbt damit das “intelligenteste AddIn für Visual Studio” entwickelt zu haben – doch was kann ReSharper wirklich?

Download & Installation

ReSharper 3.0.2 gibt es bei JetBrains als 30-Tage Testversion zum Download. Die Installation gestaltet sich wirklich einfach – empfehlenswert ist jedoch Visual Studio vorher zu schließen. Nach vollendeter Installation und erneutem Starten von Visual Studio wird die Shortcutbelegung für ReSharper abgefragt. Es besteht die Wahl zwischen “Visual Studio” und “IntelliJ IDEA”. Beim “Visual Studio”-Schema werden die bekannten Standard-Refactoring-Features von Visual Studio einfach mit den analogen ReSharper-Features überschrieben, während die zweite Einstellung für Entwickler gedacht ist, die bereits mit IntelliJ IDEA oder ReSharper 2.5 gearbeitet haben.

Seit der Version 3.0 kann man die Keyboard-Belegung nun auch jederzeit über ReSharper/Options/Environment/General editieren. Im weiteren werde ich jedoch nur auf die “Visual Studio”-Belegung eingehen.

IntelliSense-Erweiterungen

Visual Studio 2005 bringt standardmäßig eine Reihe von “IntelliSense”-Features mit, die das Entwicklerleben einfacher gemacht haben. ReSharper erweitert diese Features noch um einige weitere Möglichkeiten. So ist es zum Beispiel möglich alle im Projekt verwendeten Typen im IntelliSense auszuwählen und nicht nur die Importierten. Das möglicherweise erforderliche Using-Statement wird von ReSharper automatisch ergänzt.

Code-Assistent

Immer wenn die Glühbirne am linken Bildschirmrand erscheint, hat der Code-Assistent eine Möglichkeit zum Refactoring gefunden. Durch Druck auf ALT+ENTER werden die gefundenen Möglichkeiten aufgelistet. Hier einige Beispiele:

Member-Variablen, die nicht beschrieben werden, können “readonly” gesetzt werden:

Stringverkettungen können in String.Fomat() umgewandelt werden:

Falls festgestellt wird, dass eine benutzte Variable NULL sein könnte, wird ein “If(variable != null)” angeboten:

Wenn erkannt wird, dass der benutzte Namespace in einer Datei nicht der Struktur innerhalb der Projektmappe entspricht, kann der Namespace verlagert werden:

Code-Navigation

ReSharper bildet intern den gesamten abstrakten Syntaxbau des Projektes ab und kann so genau erkennen, wann Refactoring eingesetzt werden kann. Das AddIn ist so u.a. in der Lage alle Aufrufe einer Funktion (ALT+F7) innerhalb der gesamten Projektmappe zu finden. Neben der Anzeige dieser Stellen ist auch eine einfache Navigation innerhalb der Aufrufhierarchie möglich.

Besonders nett ist dieses Feature, wenn man innerhalb von Klassenhierarchien an abgeleitete Stellen navigieren möchte.

Toter Code

Da alle Funktions-Aufrufe der Projektmappe analysiert werden, ist ReSharper auch in der Lage “toten Code” zu erkennen, also Code der nirgends aufgerufen wird. Dieser Code wird grau markiert und kann getreu dem YAGNI-Prinzip (You Ain’t Gonna Need It) per ALT+ENTER gelöscht werden.

Das Feature funktioniert so gut, dass ich mittlerweile bei grauem Code automatisch ALT+ENTER drücke und den Code lösche. Falls der sehr seltene Fall eintritt, dass man die Funktion irgendwann doch nochmal braucht, dann schreibt man sie eben neu – oder schaut in seine Versionsverwaltung.

Codeformatierung

Nachdem man ReSharper installiert hat, zeigt sich Visual Studio in einem etwas anderen Gesicht. Das Erste das auffällt, ist das verfeinerte Syntax-Highlighting. Aber auch beim Tippen von Code darf man sich an einige neue Features gewöhnen – u.a. werden geöffnete Klammern immer gleich wieder geschlossen und der Cursor zwischen die Klammern geschoben. Das größte Feature in diesem Bereich ist jedoch die automatische Codeformatierung mit STRG+ALT+F. Je nach eingestellter Stufe werden hier toter Code entfernt, die Klassen-Member alphabetisch geordnet, Usings optimiert und die Blockeinrückung nach voreingestellter Konvention korrigiert.

Leider hat das Feature in der getesteten Version 3.0.2 noch ein paar kleine Macken, so dass ReSharper beim Neuformatieren einiger längerer Dateien einen “Out of Memory Error” meldet. Laut JetBrains Bugdatenbank wurde das Problem bereits gelöst – der Patch ist aber noch nicht downloadbar.

Die Farbanzeige

Neben dem Quellcodefenster zeigt ReSharper eine Farbanzeige mit einem Überblick über den Status des aktuellen Dokuments an. Die Balken stellen dabei Links zu den entsprechenden Stellen im Dokument dar und die Position innerhalb des Dokuments wird auf die Größe der Scrollleiste skaliert.


Roter Rand:Compile-Error	Gelber Rand:Warnungen / Toter Code / Refactoringanweisungen	Grüner Rand:Alles Ok / Empfehlungen zum Refactoring

Leider gibt es keine solche Anzeige für alle Dateien innerhalb eines Projektes, so dass man alle Dateien manuell öffnen und ansehen muss.

UnitTesting

ReSharper bietet wie viele andere Tools eine erweiterte Unterstützung für UnitTests. Dabei werden aktuell NUnit, csUnit und über ein zusätzliches Plugin auch mbUnit angeboten. Leider gibt es scheinbar keine Möglichkeit das UnitTest-Framework von Visual Studio Team System zu benutzen, so dass ich hier nicht weiter getestet habe.

Refactoring

Das Herz von ReSharper ist natürlich das Refactoring. Es werden hier so viele Funktionen angeboten, so dass ich hier nur auf die Wichtigsten eingehen möchte. Eine komplette Übersicht aller Refactoring-Features gibt es auf der ReSharper-Homepage.

Als wichtigsten ReSharper-Shortcut sollte man sich STRG+SHIFT+R für “Refactor This” merken. Diese Funktionalität bietet abhängig vom Kontext eine Auswahl der gerade möglichen Refactoring-Möglichkeiten.

Neben den bereits aus Visual Studio bekannten Features wie “Feld einkapseln” und “Umbenennen” gibt es zum Beispiel Möglichkeiten um Eigenschaften in Methoden zu konvertieren und umgekehrt, Methoden entlang von Vererbungshierarchien zu verschieben und Interfaces in Abstrakte Klassen zu konvertieren. Ein besonders nettes Feature ist, dass man ganze Quelltextblöcke als eigenständige Methoden auslagern kann. ReSharper erkennt dabei sogar automatisch welche Parameter der Methode übergeben werden müssen:

Fazit

ReSharper ist ein ausgezeichnetes Tool um die Produktivität in Visual Studio zu steigern. Es werden viele Refactoring-Features angeboten und durch die Farbanzeige am Bildschirmrand hat man immer einen Überblick über den aktuellen Stats der Datei (leider nicht über das gesamte Projekt). Ein kleiner Wermutstropfen ist die fehlende UnitTest-Unterstützung für Visual Studio Team System und der mit 249 $ (C#-Edition für Firmen) doch meiner Meinung nach recht saftige Preis.

Vortrag von Roland Weigelt zur Visual Studio 2005 Erweiterbarkeit

Steffen Forkmann — Sat, 05 May 2007 06:57:36 +0000

Am 06.07.2007 findet ab 19:30 ein sehr interessantes Event in Leipzig statt. Roland Weigelt wird über die Entwicklung seines mehrfach ausgezeichneten Plugins GhostDoc berichten und einen Einblick in die Visual Studio Erweiterbarkeit geben. GhostDoc ist für mich neben ReSharper das wichtigste Plugin für Visual Studio überhaupt.

Der Vortragende wird folgende Features vorstellen:

Code Snippets
Item und Project Templates
Wizards
Makros
Add-Ins

Mehr zu dieser Veranstaltung bzw. die Anmeldung findet man auf den Seiten der .NET User Group Leipzig.

View this on the map.

Java vs. C# vs. VB.NET

Steffen Forkmann — Wed, 03 Jan 2007 13:35:49 +0000

Für Java-Programmierer bzw. VB-Programmierer die gern in C# einsteigen wollen, gibt es eine Schnellreferenz mit den wichtigsten Syntaxunterschieden. Das funktioniert natürlich auch umgekehrt – aber wer würde schon freiwillig von C# weg wollen?

Codierung einer Textdatei ändern in C#

Steffen Forkmann — Wed, 03 Jan 2007 13:24:58 +0000

Wenn man die Encodierung einer Textdatei ändern möchte, kann man das mit diesem Code-Fragment tun:

public void ConvertEncoding(
  string fileName, string newFileName,
  Encoding oldEncoding, Encoding newEncoding)
{
    using (StreamWriter w =
        new StreamWriter(newFileName, false, newEncoding))
    {
        using (StreamReader r =
            new StreamReader(fileName, oldEncoding, false))
        {
            int charsRead;
            char[] buffer = new char[128 * 1024];
            while ((charsRead =
                        r.ReadBlock(buffer, 0, buffer.Length)) > 0)
                w.Write(buffer, 0, charsRead);
        }
    }
}