Archiv

Posts Tagged ‘Tools’

Praktische Helfer rund um AngularJS

26. August 2014 Kommentare aus

Wenn man sich ein wenig tiefer mit AngularJS beschäftigt stösst man bald einmal an eine steile Lernkurve. Was mit einfachem Data Binding angefangen hat wird plötzlich sehr kompliziert – vor allem wenn es an Direktiven geht. Mit den richtigen Helfern lässt sich allerdings viel vereinfachen. Einige dieser praktischen Werkzeuge und Pakete möchte ich heute vorstellen.

 

Batarang

Eines der häufigsten Probleme auf die ich treffe sind fehlende Daten. Objekte sind nicht dort wo ich sie erwarte oder Listen enthalten nicht die gewünschten Elemente. Aus einer kleinen Änderung wird so schnell eine endlose Suche nach dem Grund eines fehlgeschlagenen Data Bindings.

Batarang ist eine Erweiterung von Chrome und kann nicht nur als Profiler und Debugger verwendet werden, sondern auch zum anzeigen des Scopes. Dies vereinfacht die Suche nach den richtigen Objekten ungemein. Die Handhabung für die einfachen Aufgaben hat man sehr schnell im Griff, für alle anderen Möglichkeiten empfiehlt sich ein Blick in die Anleitung.

Batarang

 

Mehrere Browser zusammen verwenden

Als erstaunlich hilfreich hat sich für mich die Verwendung mehrerer verschiedener Browser erwiesen. Die Fehlermeldungen im Internet Explorer sind gelegentlich besser als die im Firefox, während dieser hin und wieder bessere Meldungen erzeugt als Chrome. Und um es richtig spannend zu machen liefert dann Chrome wiederum die besseren Meldungen als der Internet Explorer.

Kurzum: Um bei einem Problem die bestmögliche Unterstützung durch die Tools für Webentwickler zu bekommen muss man alle 3 Browser installiert haben. So kann man im Fehlerfall zwischen den Browsern hin und her wechseln bis man die Ursache des Problems angezeigt bekommt.

 

Plunker

Hin und wieder genügt der Debugger nicht und es führt nichts an einem 2. Paar Augen vorbei. Um ein Minimalbeispiel ohne grossen Aufwand zugänglich zu machen hat sich für mich der Service von Plunker (Plnkr.co) als äusserst hilfreich erwiesen.

Neben der Community-Funktion gibt es vor allem einen guten Editor der einem die aktuellsten Pakete von AngularJS, Bootstrap und vielen mehr einfach integrieren lässt. So kann man sehr schnell eingrenzen ob das Problem an der eigenen Installation liegt oder ob auch auf einem funktionierenden System die gleichen Probleme bestehen.

Plunker

 

ngMock

AngularJS hat ein eigenes Mocking-Framework. Gerade wenn man Webservices nutzt die nicht unter der eigenen Kontrolle stehen oder man auf eine aufwändige lokale Installation verzichten will ist ngMock eine gute Hilfe. Damit ersetz man zwar keine durchgängigen Tests, aber man kann Probleme eingrenzen die im eigenen Code liegen.

 

ngAnimate

Um den Wechsel zwischen den einzelnen Masken und Seiten ein wenig spannender zu gestalten kann einem ngAnimate viel Arbeit abnehmen. Die entsprechenden Hooks können direkt im Code mit der gewünschten Animation verknüpft werden, was einem sehr viel Tipparbeit erspart.

 

Animate.css

Wer wie ich nicht gerne CSS-Animationen von Hand schreibt sollte unbedingt die vorgefertigten Skripte von Animate.css ausprobieren. In diese Animationen wurde sehr viel Arbeit gesteckt um einen möglichst angenehmen Bewegungseffekt zu erzielen. Um darauf aufzubauen genügt es die entsprechende CSS-Datei einzubinden und an der passenden Stelle aufzurufen.

 

Jasmine

Das JavaScript-Testframework Jasmine hatte ich hier schon kurz beschrieben. Je mehr man mit AngularJS macht desto wichtiger wird es automatisch die bestehende Funktionalität zu überprüfen. Jasmine hat sich diesbezüglich bei mir bewährt und ich kann dieses Framework nur empfehlen.

 

Fazit

Mit den richtigen Werkzeugen kann man auch bei AngularJS viel Zeit und Frust einsparen. Da diese alle kostenlos zur Verfügung stehen gibt es keinen Grund nicht einmal einen Blick auf das eine oder andere Tool zu werfen.

Wie immer freue ich mich über weitere Vorschläge um meine Arbeit noch ein wenig einfacher zu gestalten.

Schlagworte: , ,

Code mittels NDepend analysieren

9. April 2014 1 Kommentar

Um möglichst schnell in ein komplexeres Projekt einzusteigen hilft einem eine gute Übersicht. Visual Studio bietet je nach Ausgabe eine recht gute Code Analyse. Will man mehr wissen oder ist man an bestimmten Konstellationen im Code interessiert, stösst man aber schnell an Grenzen. Hier benötigt man einmal mehr die Werkzeuge und Ergänzungen von Drittherstellern.

Als ich vor einigen Wochen gebeten wurde mir NDepend anzuschauen kam mir dies sehr gelegen. NDepend ist ein Tool zur statischen Code Analyse für .Net. Damit lässt sich der Code nicht nur auf vorgefertigte Qualitätskriterien überprüfen, sondern man kann auch eigene Abfragen definieren.

 

Download und Installation

Auf NDepend.com kann man die Demo-Version als Zip herunterladen. Die Installation beschränkt sich aufs entpacken der Datei und einem Doppelklick auf die Installationsdatei.

Wenn einem die Möglichkeiten von NDepend gefallen bekommt man eine entsprechende Lizenz ab 299€. Leider gibt es keine GUI-basierende Möglichkeit um den Lizenzschlüssel einzugeben. Die Lizenzdatei muss man in den entpackten Ordner kopieren bevor man Visual Studio startet. Sonst wird nach Ablauf der Evaluationsperiode NDepend beim nächsten Start von Visual Studio deinstalliert.

Läuft NDepend genügt es das gewünschte Projekt in Visual Studio zu öffnen und über den Menüpunkt “NDepend” die Analyse zu starten. Dieser Vorgang ist zwar recht schnell, kann je nach Projektgrösse aber dennoch einige Minuten dauern.

 

HTML-Report

Das erste was einem als Resultat begegnet ist der HTML-Report. Dieser enthält die wichtigsten Punkte und soll als Zusammenfassung fürs Management dienen. Leider ist die Funktionalität äusserst beschränkt und damit einzig als Druckversion für die Gesamtsicht zu gebrauchen.

NDepend Report

 

Visual NDepend

Mit Visual NDepend hat man ein deutlich besseres Werkzeug zur Verfügung. Hier kann man die Grafiken genauer anschauen und auch einzelne Klassen auf der TreeMap finden. Klickt man auf Klassen- oder Methodennamen öffnet sich Visual Studio und zeigt einem die passende Stelle an.

Da alle Funktionen nur hier schön zusammengefasst werden dürften die meisten Benutzer vor allem mit Visual NDepend arbeiten. Man hat zwar immer noch den Wechsel zwischen Visual Studio und Visual NDepend, dafür kommt man aber sehr schnell zu den gewünschten Informationen.

Visual NDepend

 

Integration in Visual Studio

Die Integration in Visual Studio ist sehr gut und man kann mittels Rechtsklick auf eine Klasse die einzelnen Auswertungen direkt aufrufen. Bei der Gesamtübersicht wurde auf dem Dashbard allerdings nicht alles aus Visual NDepend übernommen. Es ist zwar alles in Untermenüs vorhanden, aber bis man die einzelnen Grafiken findet kann es dauern…

NDepend VS2013

 

Eigene Abfragen

NDepend glänzt vor allem durch die Abfragesprache CQLinq. Damit kann man selber den Code nach eigenen Kriterien durchsuchen (wie mehr als 4 Methoden mit mehr als 3 Parameter und mehr als 10 Attribute pro Klasse). Hat man gewisse Konstellationen entdeckt die häufig zu Problemen führen hilft einem CQLinq beim aufspüren.

Die Dokumentation zu CQLinq ist sehr ausführlich und sollte vor dem Experimentieren konsultiert werden. Die Hilfestellung bei Fehlern im Editor ist nicht gerade optimal und da die Abfragen immer gleich ausgeführt werden wird man sehr schnell mit Fehlermeldungen eingedeckt.

NDepend Query Editor

 

Verbesserungspotential

Die Inkonsistenzen der 3 Ansichten (HTML-Report, Visual NDepend und Visual Studio) sind nicht gerade Benutzerfreundlich. Hat man sich einmal daran gewöhnt kann man damit arbeiten. Allerdings ist es schade wenn man viel Zeit mit der Suche nach einer bestimmten Auswertung verliert nur weil sich diese in einem anderen Tool befindet.

Mit einer verständlicheren Kategorisierung der Fehler könnten die Reports auch dem Fachdienst bei der Beurteilung helfen. Code Climate schafft dies mit der Benotung A bis F für einzelne Klassen. Während ein A sehr gut ist gilt ein F als dringend zu verbessern. Zudem wird schön aufgezeigt wie sich der Code über die Zeit entwickelt, was einen zusätzlichen Motivationsschub gibt. Leider fehlen solche einfachen Werte bei NDepend, auch wenn Ansätze zum Verfolgen der Veränderungen vorhanden sind.

 

Fazit

NDepend ist ein tolles Tool für Entwickler die mehr über ihren Code wissen wollen. Um die Möglichkeiten voll auszuschöpfen wird man aber einiges an Zeit investieren müssen um selber CQLinq Abfragen zu erstellen.

Ausserhalb der Entwicklung sind die Einsatzmöglichkeiten von NDepend allerdings sehr beschränkt. Die Probleme bei der Benutzerführung und die Inkonsistenzen sind wie die Reports wenig hilfreich um mit dem Fachdienst über Qualitätsverbesserungen zu diskutieren.

Schlagworte: , ,

Mittels Technologieradar die Übersicht behalten

12. Februar 2014 1 Kommentar

Bei all den vielen neuen Werkzeugen, Techniken und (JavaScript-) Frameworks die wie Pilze aus dem Boden schiessen ist es äusserst schwer den Überblick zu behalten. Überall sieht man neue Dinge und vieles davon sieht so spannend aus dass man dies gleich ausprobieren will. Nur ist die Menge mittlerweile viel zu gross um dies auch zu tun.

Was man bräuchte ist eine Art Filter mit dem man sich gezielt auf einige ausgewählte Themen und Werkzeugen konzentrieren kann. Man müsste wichtigeres von unwichtigem trennen können ohne dabei zu viel Zeit mit dem Kategorisieren zu verlieren. Was ich bräuchte wäre etwas wie der Technology Radar von ThoughtWorks, nur halt für mich und meine Interessen.

 

Von ThoughtWorks zum eigenen Technologieradar

ThoughtWorks veröffentlicht in etwa alle 6 Monate eine Aktualisierung ihres Technologieradars. Die Grafik ist dabei eine Zusammenfassung der internen Diskussionen und zeigt auf in welche Richtung sich die IT-Branche aus ihrer Sicht bewegt. Statt grosser Dokumente hilft einem eine einzige Grafik abzuschätzen ob man Zeit in die entsprechende Technologie investieren soll oder besser gleich eine Migration plant. Dazu dienen diese 4 Ringen:

  • Hold (abwarten): Keine neuen Projekte mit diesen Technologien starten.
  • Assess (einschätzen): Genauer hinschauen ob sich daraus etwas entwickelt.
  • Trial (ausprobieren): In kleineren und weniger wichtigen Projekten Erfahrungen sammeln.
  • Adopt (umsetzen): Bereit um in kritischen Anwendungen verwendet zu werden.

Neal Ford ist nicht nur beim Radar von ThoughtWorks involviert, sondern spricht auch an Konferenzen über den Nutzen eines persönlichen Technologieradars. In diesem Blogpost erklärt Ford wie man damit auch einen Realitätsabgleich machen kann. Fixiert man sich zu sehr auf einen Hersteller bekommt man nicht mehr mit wie sich die Welt um einen herum verändert – bis es zu spät ist und man keinen neuen Arbeitgeber findet.

Das Festlegen auf die einzelnen Technologien und wo man diese sieht ist der aufwändigste Teil um selber einen Technologieradar zu erstellen. Hier kommt es ganz auf die eigene Einschätzung an, da angesichts der schnellen Veränderungen objektive Kriterien kaum weiterhelfen.
Sobald man alles beisammen hat geht es mit der grafischen Darstellung recht schnell. Dank der grossen Vorarbeit von Brett Dargan uns seinem Projekt Techradar braucht man nur noch eine JSON-Datei anzupassen und schon hat man seine Grafik.

 

Mein Technologieradar

Für meine Grafik bin ich recht schnell von ThoughtWorks abgewichen. Wenn auch etliche Technologien gleich sind so hat mir die Vorlage nicht ganz entsprochen. Der Quadrant “Techniques” ist bei mir weiter gefasst und beinhaltet neben technischen Lösungsansätzen auch Verfahren und Methoden. Gleiches gilt für den Quadranten “Infrastructure” der bei mir auch Plattformen und Services umschliesst.

Techradar_201401

 
 
Techniken, Verfahren & Methoden
Tech201401_Techniques
In diesem Quadranten gibt es bei mir die meisten Einträge in den Ringen “Adopt” und “Trial”. Dies war nicht so geplant, zeigt aber einen interessanten Nebeneffekt des Technologieradars: Durch die grafische Darstellung kann man eine thematische Häufung von Einträgen erkennen die einem so vorher nicht bewusst war.

Bei all den Dingen die ich anschauen oder umsetzen will gibt es eine grosse Ausnahme: Es muss aufhören aus reiner Bequemlichkeit in einer API 1:1 die Limitierungen der darunterliegenden Systemen weiterzureichen. Nur weil SQL Server Null-Werte als 1.1.1753 maskiert braucht ja nicht jeder Konsument der API in seiner Anwendung die Null-Konvertierung selber durchzuführen. Auch wenn ich dies bisher vor allem im Bereich von Datenbanken angetroffen habe gibt es keinen Grund dies nicht auch bei anderen Systemen zu beachten.

 
Infrastruktur, Plattformen & Services
Tech201401_Infrastructure
Das grosse Thema in diesem Quadranten ist die Cloud. Trotz all der NSA Enthüllungen gibt es hier Chancen die zu gut sind um sie zu ignorieren. Angefangen bei GitHub über Code Climate bis hin zu Amazon und Azure gibt es unzählige Einsatzgebiete die auf eine Erkundung warten.

Bei RavenDB habe ich am längsten um die Einteilung gerungen. Da mir noch einige wichtige Informationen für den Produktiveinsatz fehlen blieb es schlussendlich beim Einsatz in kleineren Projekten. Die Wissenslücken für den Einsatz in geschäftskritischen Anwendungen sollte ich aber bald schliessen können.

 
Tools
Tech201401_Tools
Viel Auszuprobieren gibt es für mich bei den Tools. Rund um Ruby gibt es eine Vielzahl von Helfern fürs Testing und den Aufbau von Entwicklungsumgebungen. Bei .Net vermisse ich bisher so ausgereifte Werkzeuge. Daher wird es Zeit genau zu prüfen wie weit SpecFlow und MSpec, respektive Puppet und Chef gekommen sind.

Ein weiteres spannendes Thema sind für mich Micro ORMs. Realistisch betrachtet wechselt man kaum je die Datenbank bei einem Projekt aus. Daher sind OR-Mapper wie Entity Framework oder NHibernate mit ihren Abstraktionsschichten oft ein grosser Overhead der einem den Zugriff auf datenbankspezifischen Funktionen nur über Umwege erlaubt. Micro ORMs könnten da eine Alternative sein die eine vertiefte Abklärung verdienen.

 
Sprachen und Frameworks
Tech201401_Lang
Sowohl für C# wie für Ruby Entwickler dürften die meisten Einträge in diesem Quadranten nachvollziehbar sein. Wo es wohl einige Erklärung braucht ist der “Hold” Ring.

Bei den Desktop-Frameworks wie WPF aber auch WinForms halte ich mich derzeit zurück. Angesichts verteilter Standorte, Home Office und der Verbreitung von Tablets setze ich viel eher auf die Webentwicklung. Diese allerdings abseits von WebForms und Silverlight. Da Silverlight selbst von Microsoft nicht mehr in allen IE-Varianten unterstützt wird ist diese Technologie definitiv gestorben – auch wenn die Supportseite einem eine andere Geschichte erzählen will.

Sehr skeptisch bin ich auch bei TypeScript. Hier handelt es sich aus meiner Sicht um eine Lösung auf der Suche nach einem Problem. Die Probleme vieler Entwickler mit JavaScript lassen sich nicht durch ein aufgepfropftes Typensystem lösen – viel eher muss man JavaScript als eigenständige Sprache akzeptieren und die Eigenheiten lernen. Und sollte TypeScript tatsächlich länger bleiben kann man später immer noch auf diesen Zug aufsteigen.

 

Fazit

Beim Zusammenstellen des Technologieradars muss man sich plötzlich festlegen. Es genügt nicht mehr nur eine vage Liste mit interessanten Technologien zu haben – nun wird auch eine Einteilung in die Kreise und Quadranten benötigt. Es bleibt einem nichts anderes übrig als die einzelnen Technologien zu ordnen und zu klassifizieren.

Der grosse Nutzen dieser Übung liegt für mich im bewussten Auseinandersetzen mit den einzelnen Technologien und der Entscheidung, ob diese nun einen Platz im Radar finden oder nicht. Dabei spielt es keine grosse Rolle wo genau sich diese auf der Grafik befinden. Viel wichtiger ist welche Technologien es überhaupt hinein schaffen.

Wieviel mir die ganze Übung am Ende bringen wird muss sich noch zeigen. Die ersten Erfahrungen waren allerdings so hilfreich dass ich die Erstellung eines eigenen Technologieradars sehr empfehlen kann.

Schlagworte: , , ,

GitHub for Windows – oder Git einmal einfach

23. Oktober 2012 4 Kommentare

Die Versionsverwaltung Git wird unter Windows immer noch zurückhalten eingesetzt. Auch wenn man mit Helfern wie der Console 2 vieles einfacher machen kann, so bleibt Git doch ein komplexes Kommandozeilen-Tool. Die grafischen Oberflächen konnten einem meist auch nicht wirklich überzeugen – fehlende Befehle und Beschriftungen wie von Subversion her störten den Arbeitsfluss zu sehr.

Dieses Problem fiel auch GitHub auf. Eine Firma die ihr Geld mit Dienstleistungen rund um Git verdient möchte natürlich überall präsent sein. Da es an einem guten GUI für Windows fehlte, machte man halt selber eines.

 

Installation

GitHub for Windows lässt sich von http://windows.github.com/ herunterladen. Im *.exe ist ein Installer verpackt der Git in einer Sandbox installiert. Damit kann man problemlos Git installieren und braucht sich um sein System keine Gedanken zu machen – dies bleibt bis auf die Desktop-Icons unangetastet.

Idealerweise erzeugt man nebenher einen Account bei GitHub und verbindet sich gleich mit diesem. Dies ist nicht notwendig um die Applikation zu nutzen, man hat so aber gleich alle Einstellungen im Client und muss nichts mehr von Hand anpassen.

 

Klonen leicht gemacht

Wie man erwarten darf wurde die Anwendung sehr gut in GitHub integriert. Schaut man sich nun ein Projekt auf GitHub.com an, sieht man in seinem Browser (Firefox, IE und Chrome) den Knopf [Clone in Windows]:

Ein Klick darauf genügt und GitHub for Windows öffnet sich und klont das gerade ausgewählte Repository auf den Rechner.

 

Neues Repository anlegen

Ein neues Repository kann man genau so einfach anlegen wie eines zu klonen. Man kann entweder den Knopf [add] auf der Übersichtsseite anklicken oder den Ordner der als neues Repository geführt werden soll auf die Anwendung ziehen. Der einfach gehaltene Dialog ermöglicht einem einen Namen und eine Beschreibung zu vergeben. Wählt man die Option „Push to GitHub“ wird auch gleich alles konfiguriert um das Repository auf GitHub zu veröffentlichen.

Neben dem .git Ordner wird in diesem Schritt ebenfalls eine .gitignore und .gitattributes Datei angelegt. So werden automatisch all die temporären und benutzerspezifischen Dateien ausgeschlossen, die man meist nicht veröffentlichen will. (Will man diese Dateien doch drin haben kann man .gitignore selber anpassen.)

 

Änderungen speichern und anschauen

Nachdem man seine Änderungen gemacht hat geht es an den commit. Dazu öffnet man das Repository in GitHub for Windows und sieht auf einen Blick was sich verändert hat:

Nach dem man eine passende Beschreibung eingetragen hat genügt es auf [commit] zu klicken und die Änderungen sind als neue Version gespeichert.

Der gleiche Dialog dient einem auch um die Änderungen zu verfolgen. Dazu wählt man in der rechten Spalte die gewünschte Version und sieht alle veränderten Dateien mit den Anpassungen.

 

Änderungen publizieren

Wer seine Arbeit veröffentlichen will wird auch hier von GitHub for Windows unterstützt. Dazu genügt auf dem Repository ein Klick auf [push to github]. Im Dialog genügt es den Namen zu überprüfen (und bei Bedarf zu ändern) und mit einem weiteren Klick auf [push] wird das Repository zu GitHub hochgeladen:

Hat man dies einmalig gemacht genügt ein Klick auf [sync] um die lokale Arbeitsversion mit dem Repository auf GitHub abzugleichen.

 

Wenn mal etwas schiefläuft

Nicht immer gelingen einem allen Änderungen im ersten Anlauf. GitHub for Windows hat dafür auf der Repository-Seite 2 hilfreichen Funktionen:

  • [Revert commit] erzeugt einem die Gegenaktion zum gemachten Commit. Was man dort gelöscht hatte ist nun wieder drin und was hinzugekommen ist wird entfernt.
  • [Rollback to this commit] verwirft alle Änderungen zurück bis zur ausgewählten Version. Ist dies die letzte Version kann man den letzten Commit nochmals verändern. Andernfalls löscht es alle Änderungen die seit der ausgewählten Version gemacht wurden.

Genügt einem dies nicht kann man über [Tools] / [open a shell here] auf der Kommandozeile auf alle Git-Befehle zurückgreifen.

 

Nicht nur GitHub

Mit GitHub for Windows kann man jedes beliebige Git-Repository verwalten. Da GitHub private Repositories nur gegen Bezahlung anbietet greife ich gerne auf den Service von Bitbucket zurück.
Um das Repository mit Bitbucket zu verknüpfen muss man den Settings-Dialog auf dem Repository öffnen und die URL gemäss den Angaben von Bitbucket einfügen. Von da an gehen alle Aktionen genauso wie sie auch mit GitHub laufen.

 

Fazit

GitHub for Windows ist aus meiner Sicht der derzeit beste Client für Git auf Windows. Die Funktionalität der GUI-Anwendung deckt das ab was man als „normaler“ Anwender mit Git machen will. Soll es doch einmal nicht genügen stehen einem mehrere konfigurierte Konsolen zur Verfügung.

Das problemlose Zusammenspiel mit anderen Hostern wie Bitbucket macht dieses Tool auch für all diejenigen interessant, die nicht mit GitHub arbeiten wollen.

Schlagworte: ,

Schnellere Webanwendungen dank MiniProfiler

17. Oktober 2012 Kommentare aus

Performance-Probleme bemerkt man meist erst dann wenn es zu spät ist – in der Produktion. Die kleine Menge an Testdaten auf dem Entwicklungssystem verzeihen einem so manche Unachtsamkeit und Ressourcenverschwendung. Unnötige SQL-Abfragen und die Select N+1 Problematik könnte man schon früh erkennen. Nur wer nimmt sich die Zeit immer den Profiler zu starten und alles zu überprüfen?

Wäre es nicht toll wenn im Hintergrund immer ein Profiler laufen und einem mit den Auswertungen versorgen würde? So könnte man immer mal wieder einen Blick aufs Ergebnis werfen und bei lange dauernden Aktionen gleich sehen wo die Ursache liegt. Tönt dies zu schön um wahr zu sein?

MiniProfiler bietet einem genau diese Funktionalität für ASP.Net und ASP.Net MVC Anwendungen. Dieser Profiler stammt von Stack Exchange und hilft dort beim optimieren aller Seiten der Stack Overflow-Familie.

 

Installieren

Die Installation von MiniProfiler erfolgt über NuGet. Wie immer kann man über die grafische Oberfläche das Paket suchen und installieren oder man nutzt die Konsole:

Install-Package MiniProfiler

 

Aktivieren

Um dem Profiler den Anfang und das Ende eines Requests mitzuteilen muss man die Datei Global.asax um diese beiden Methoden Erweitern:

protected void Application_BeginRequest()
{
    if (Request.IsLocal)
    {
        MiniProfiler.Start();
    }
}

protected void Application_EndRequest()
{
    MiniProfiler.Stop();
}

Damit auch etwas angezeigt wird muss die Datei \Views\Shared\_Layout.cshtml direkt vor dem schliessenden Body-Tag mit einem Aufruf zum Rendern der Resultate ergänzt werden:

    @StackExchange.Profiling.MiniProfiler.RenderIncludes() 
  </body>
</html>

Will man MiniProfiler in einem Webforms-Projekt einsetzten ist der Header in der Datei Site.Master so zu ergänzen:

<%= StackExchange.Profiling.MiniProfiler.RenderIncludes() %>
</head>

Bei mir war zudem noch eine Anpassung im web.config nötig:

<system.webServer>
  ...
  <handlers>
    <add name="MiniProfiler" path="mini-profiler-resources/*" verb="*" type="System.Web.Routing.UrlRoutingModule" resourceType="Unspecified" preCondition="integratedMode" />
  </handlers>
</system.webServer>

 

Auswerten

Sobald man die Webanwendung neu kompiliert und gestartet hat erscheint eine kleine Box in der linken oberen Ecke der Seite:

MiniProfiler beschränkt sich nicht nur aufs anzeigen der Ladezeit. Klickt man auf die Box wird ein detaillierter Report angezeigt:

Neben den allgemeinen Informationen über die Dauer des Request und die Dom Events kann man auch eigene Schritte definieren. Dazu setzt man den zu überwachenden Code in einen Using-Block und benennt den Step mit einem prägnanten Titel:

using (MiniProfiler.Current.Step("Step Set Message"))
{
  ViewBag.Message = "Your contact page.";
  Thread.Sleep(100);
}

Normalerweise werden die Ereignisse die keine relevante Zeit verbrauchen ausgeblendet. Fehlt einem der gesuchte Schritt kann man über den Link „show trivial“ das anzeigen aller Einträge erzwingen.

 

EF-Abfragen überprüfen

Richtig praktisch wird MiniProfiler wenn man auch gleich noch die Datenbankabfragen anzeigen kann. Dazu muss man zusätzlich das Paket MiniProfiler.EF installieren und Application_Start() in der Global.asax um einen Aufruf zur Initialisierung ergänzen:

MiniProfilerEF.Initialize();

Von nun an wird neben der Dauer der Aktionen die Anzahl darin ausgeführten SQL-Abfragen angezeigt:

Von dieser Zusammenfassung aus genügt 1 Klick und man sieht was genau für SQL-Befehle auf die DB losgelassen wurden:

Der Hinweis auf doppelte Abfragen oder Select N+1 ist äusserst hilfreich und hilft einem die gröbsten Schnitzer einfach zu finden.

 

Fazit

MiniProfiler ist schnell installiert und sehr einfach zu konfigurieren. Die Ladezeit als eine der wichtigsten Kennzahlen steht einem von nun an jederzeit und gut sichtbar zur Verfügung. Zusätzliche Informationen lassen sich mit geringem Aufwand hinzufügen und ermöglichen einen Einblick ins Innere der Anwendung.

Meiner Meinung nach ist dieses kleine Tool ein tolles Hilfsmittel um schon zur Entwicklungszeit die Ursachen der häufigsten Produktionsprobleme anzugehen.

Schlagworte:

Meine Werkzeugliste

25. September 2012 2 Kommentare

Es sind ja meist die ganz kleinen Werkzeuge die einem die Arbeit erleichtern und die sind so simpel dass man sie kaum je erwähnt. Startet man in einer neuen Umgebung sind diese Werkzeuge aber meist das erste was man installiert um sich wieder „zu Hause“ zu fühlen.

Dies hier ist meine Liste mit diesen kleinen Tools und Anwendungen die ich für meine tägliche Arbeit einsetze. Die Idee dazu habe ich von Scott Hanselman und Piotr Kwapin. Wer seine Tools beisteuern möchte kann diese gerne via Kommentar tun.

 

Windows

IrfanView ist ein leichtgewichtiger und schneller Bildbetrachter. Mit den eingebauten Funktionen kann man aber auch direkt einen Scanner ansprechen oder eine Batchverarbeitung starten.

7-Zip ist eine Open Source Alternative zu WinZip. Neben *.zip können auch *.tar und *.rar Dateien entpackt werden. Das Tool ist sehr praktisch wenn man betriebssystemübergreifend arbeiten muss.

Notepad++ ist der Texteditor den ich jeweils als erstes Programm auf einem neuen Gerät installiere. Neben Syntaxhervorhebung für fast alle Sprachen unterstützt Notepad++ auch allerlei Zeilenumbrüche und Kodierungen.

ZoomIt ist ein Miniprogramm für Präsentationen. Will man etwas auf dem Monitor zeigen erlaubt ZoomIt das heranzoomen und markieren.

Microsoft Security Essentials ist ein für den Privatgebrauch kostenloser Virenschutz. Läuft bei mir ohne Probleme und ohne Geschwindigkeitseinbussen.

Foxit Reader ist eine schlanke Alternative zum Adobe Reader fürs Anzeigen von PDF-Dateien.

Greenshot liefert alles was man für Screenshots und deren Bearbeitung (wie Hervorhebungen und Pfeile) benötigt.

 

Visual Studio und .Net

ReSharper ist eine äusserst hilfreiche Erweiterung für Visual Studio die viele kleine Unschönheiten behebt und eine sehr praktische Codeanalyse liefert.

NuGet ist ein Paketmanager für Visual Studio der es erlaubt sehr einfach Bibliotheken in sein Programm aufzunehmen. Mit NuGet entfällt zudem das eigenhändige Auflösen der Abhängigkeiten. (Kurzanleitung)

VisualSVN ist meine Wahl um mit SVN-Projekten in Visual Studio zu arbeiten. Die Integration ist sehr gut und man behält die Kontrolle über die einzelnen Aktionen. Dieser Luxus ist mit $49 nicht gratis aber sein Geld wert.

Indent Guides ist eine Erweiterung für Visual Studio zum Visualisieren der Einrückungen. Bei Code mit sehr vielen Verschachtelungen ist diese Erweiterung äusserst Hilfreich.

LINQPad ist ein Editor mit dem man LINQ-Abfragen testen kann. Dadurch dass man nicht mehr für jede Änderung den Code neu kompilieren muss kann man sehr schnell arbeiten und Probleme finden. Ein meiner Meinung nach unverzichtbares Werkzeug auch fürs testen von OData-Abfragen oder zur Zertifizierungsvorbereitung. (Kurzanleitung)

SQL Complete ist ein kostenloses Plug-In um das SQL Server Management Studio mit IntelliSense zu erweitern. Schreibt man SQL-Abfragen von Hand ist dies eine enorme Erleichterung.

 

Web

Firefox ist ein schneller Webbrowser der sich mit Add-ons beliebig erweitern lässt. Wer mit dem Internet Explorer unzufrieden ist sollte sich Firefox anschauen.

FireBug ist eine Erweiterung zu Firefox für Webentwickler. Der ausgereifte JavaScript Debugger, ein verständlicher Profiler und die sehr einfache Anzeige der verschachtelten CSS-Formatierungen machen FireBug zu einem unverzichtbaren Werkzeug.

YSlow analysiert Webseiten hinsichtlich der Performance. Als Grundlage dienen 23 Empfehlungen des Performance-Teams von Yahoo die man unbedingt beachten sollte.

Internet Explorer Developer Toolbar ist eine Erweiterung die vergleichbar mit FireBug für Firefox ist. Obwohl noch nicht ganz so ausgereift wie FireBug ist es doch ein nützliches Tool zum abklären IE-spezifischer Probleme.

Chrome ist ein sehr schneller Webbrowser von Google. Das direkte absetzen von Suchabfragen in der Adressleiste und die mächtige JavaScript-Konsole sind sehr praktisch und nur zwei von vielen Funktionen.

WireShark kommt bei mir immer dann zum Einsatz wenn ich schauen muss was genau über das Kabel übertragen wird. Als letzter Zufluchtsort fürs Debuggen ist WireShark sehr hilfreich, es braucht aber einiges an Hintergrundwissen.

 

Webseiten und Services

Stack Overflow ist meine Anlaufstelle bei Programmierproblemen. Die Frage-und-Antwort Seite bietet eine zeitgemässe Variation der bekannten Web Foren und Newsgroups.

Gist ist eine sehr einfache Möglichkeit zum Veröffentlichen von Code-Schnipsel. Neben der sprachabhängigen Syntaxhervorhebung ist jedes Gist auch ein vollwertiges Git-Repository. (Kurzinfo)

DropBox bietet einen benutzerfreundlichen Weg zum Synchronisieren von Dateien zwischen verschiedenen Computern. Sensitive Daten sollte man vor dem hochladen aber mit geeigneten Mitteln selber verschlüsseln.

PortableApps.com liefert eine ganze Reihe von Programmen zum Ausführen direkt ab einem USB-Stick. Da eine Installation entfällt laufen diese Programme häufig auch dort wo man keine Schreibrechte fürs Programmverzeichnis hat.

Instapaper ermöglicht einem das markieren von Webseiten zum späteren Lesen. Durch das Entfernen der Werbung sind die Seiten auch problemlos auf kleineren Displays (wie einem Smartphone oder Kindle) darstellbar.

Schlagworte:

Moq für komplexere Anwendungsfälle

29. August 2012 Kommentare aus

Moq ist eine kleine Mock-Bibliothek, die ich hier bereits einmal vorgestellt habe. Für die meisten Anwendungsfälle genügt es die Rückgabewerte von Methoden zu beeinflussen. Ab und zu wäre es aber praktisch ein wenig mehr mit den Mocks machen zu können. Heute zeige ich wie Moq einem bei spezielleren Anwendungsfällen unterstützen kann.

 

Flexible Rückgabewerte

Mit Moq ist es kein Problem verschiedene Rückgabewerte zu liefern – so lange sich die Parameter beim Methodenaufruf unterscheiden. Der notwendige Code um den Wert „A“ für die Id 1 und „B“ für die Id 2 zu erhalten sieht so aus:

public interface ISimpleDemo
{
    string GetValue(int id);
}

[TestMethod]
public void MultipleReturnsForDifferentInputs()
{
    var mock = new Mock<ISimpleDemo>();
    mock.Setup(service => service.GetValue(1)).Returns("A");
    mock.Setup(service => service.GetValue(2)).Returns("B");

    Assert.AreEqual("A", mock.Object.GetValue(1));
    Assert.AreEqual("B", mock.Object.GetValue(2));
}

Hin und wieder steht man aber vor der Aufgabe bei einer Methode ohne Parameter verschiedene Rückgabewerte definieren zu müssen. Der direkte Versuch die gewünschten Werte nach einander zu definieren schlägt leider fehl:

public interface IBlogDemo
{
    string GetNextName();
}

[TestMethod]
public void MultipleReturnsTheWrongWay()
{
    var mock = new Mock<IBlogDemo>();
    mock.Setup(service => service.GetNextName()).Returns("A");
    mock.Setup(service => service.GetNextName()).Returns("B");
    mock.Setup(service => service.GetNextName()).Returns("C");

    Assert.AreEqual("A", mock.Object.GetNextName()); // Gibt "C"
    Assert.AreEqual("B", mock.Object.GetNextName());
    Assert.AreEqual("C", mock.Object.GetNextName());
}

So überschreibt man nur den Rückgabewert und der Tests endet mit dieser Fehlermeldung:

Assert.AreEqual failed. Expected:<A>. Actual: <C>.

Damit man diesen Test erfüllen kann benötigt es einen anderen Ansatz. Mit Hilfe einer Queue kann man die Werte in der gewünschten Reihenfolge ablegen (auch null-Werte sind so möglich). Die Returns-Funktion von Moq ruft nun die Dequeue-Methode auf und bekommt die für den Test benötigten Werte zurück:

[TestMethod]
public void MultipleReturnsRight()
{
    var mock = new Mock<IBlogDemo>();
    var results = new List<string> {"A", "B", "C", null};
    var pq = new Queue<string>(results);

    mock.Setup(c => c.GetNextName()).Returns(pq.Dequeue);

    Assert.AreEqual("A", mock.Object.GetNextName());
    Assert.AreEqual("B", mock.Object.GetNextName());
    Assert.AreEqual("C", mock.Object.GetNextName());
    Assert.IsNull(mock.Object.GetNextName());
    // ==> Funktioniert
}

 

Wurde eine Methode aufgerufen?

Moq bietet einem die Möglichkeit einzelne Aspekte des verwendeten Mocks zu überprüfen. Muss man wissen wie oft eine Methode des Mocks aufgerufen wurde ist die Funktion Verify sehr hilfreich. Der notwendige Code um zu prüfen ob GetValue mit Parameter 1 genau einmal aufgerufen wurde wird so sehr einfach:

[TestMethod]
public void ExactlyOnceCalled()
{
    var mock = new Mock<ISimpleDemo>();

    mock.Object.GetValue(1);

    mock.Verify(db => db.GetValue(1), Times.Once());
}

Wird die Methode nicht mit dem erwarteten Parameter aufgerufen (zum Beispiel in dem man im oberen Code-Ausschnitt GetValue mit dem Wert 2 aufruft), wirft Moq eine entsprechende Fehlermeldung:

Test method TestProject1.UnitTest1.ExactlyOnceCalled threw exception:
Moq.MockException:
Expected invocation on the mock once, but was 0 times: db => db.GetValue(1)
No setups configured.
Performed invocations:
ISimpleDemo.GetValue(2)

Es kann vorkommen das man nicht genau weiss mit welchem Parameter die Methode aufgerufen wurde (wenn beispielsweise in der zu testenden Klasse neue Instanzen erzeugt werden). In diesem Fall kann man die It-Klasse verwenden:

[TestMethod]
public void ExactlyOnceCalledUnknownParameter()
{
    var mock = new Mock<ISimpleDemo>();

    mock.Object.GetValue(1);

    mock.Verify(db => db.GetValue(It.IsAny<int>()), Times.Once());
}

Auch bei der Anzahl der Aufrufe ist Moq sehr flexibel. Ob eine Methode einmal, nie, genau x mal oder innerhalb eines Bereiches aufgerufen wurde kann man alles mit der Times-Klasse überprüfen lassen:

[TestMethod]
public void TimesHasManyUsages()
{
    var mock = new Mock<ISimpleDemo>();

    mock.Object.GetValue(1);
    mock.Object.GetValue(2);
    mock.Object.GetValue(2);

    mock.Verify(db => db.GetValue(1), Times.Once());
    mock.Verify(db => db.GetValue(2), Times.AtLeastOnce());
    mock.Verify(db => db.GetValue(2), Times.Between(1, 2, Range.Inclusive));
    mock.Verify(db => db.GetValue(2), Times.Between(1, 3, Range.Exclusive));
    mock.Verify(db => db.GetValue(2), Times.Exactly(2));
    mock.Verify(db => db.GetValue(3), Times.Never());
}

 

Fazit

Moq unterstützt einem auch bei komplexeren Einsatzszenarien. Die Möglichkeiten von Verify sind vielfältig und können einem dabei helfen so manches Testszenario abzudecken. Dabei sind It.IsAny und Times eine grosse Hilfe.

Allerdings darf man bei so viel Flexibilität das Ziel des Tests nicht aus den Augen verlieren. Sobald man sich auf zu viele Implementationsdetails einlässt werden die Tests sehr schnell unwartbar. Im Zweifel sollte man daher lieber erst versuchen mit einer besseren Code-Struktur den Test einfacher zu gestalten.

Schlagworte: ,
Folgen

Erhalte jeden neuen Beitrag in deinen Posteingang.

Schließe dich 297 Followern an