Nuget package für verschiede Frameworks

Eigentlich sollten in der Zwischenzeit alle .NET Entwickler von Nuget gehört haben. Nuget ist wirklich ein sehr schönes Mittel Bibliotheken, Komponenten und Artefakte zu verteilen und für anderen zur Verfügung zu stellen. Für Nuget gibt es eine gute Integration ins Visual Studio 2010, leider nicht in die älteren Versionen, zusätzlich eine Kommandozeilen und Powershell Version. Da ich viel auf Reisen bin, habe ich mir die wichtigsten Pakete, die ich immer wieder brauche in ein lokales Repository gezogen.

nuget install <packagename>

Aus dem heruntergeladenen und installierten Paketen habe ich anschließend alle nupkg-files in einen Ordner kopiert, fertig war mein Repo. Wer mag kann noch eine Nuget-Server (http) daraus machen, dazu muss man nur das Paket “nuget server” 
Im Package Manager im VS kann man mittels Add superleicht seine eigenen Quellen hinzufügen.

Ein Paket kann man superleicht aus jedem Projekt erzeugen.

Nuget spec <packageName>
Nuget pack <projectFile>

Erzeugt ein Spec file. Wenn es zusätzlich im Verzeichnis der SLN ausgeführt wird, dann werden die Parameter als Platzhalter übernommen. mit dem 2Kommando wird das nupkg erzeugt und der Output des Projektes hinzugefügt.

Der Teil war einfach. Nun sollte das Paket allerdings mehrere FX-Versionen unterstützen. Dazu muss man im SPEC-file den Output entsprechend in verschiedenen Ordnern einsortieren. Im file-Element kann man mittels des target-Attributes das Verzeichnis im Package definieren. Im Beispiel unten werden die Assemblies für Framework 2.0 in den Ordner “lib\net20” einsortiert.

lib\net20	.NET Framework 2.0
lib\net40	.NET Framework 4.0
lib\sl40	Silverlight 4.0

Nach dem editieren sah mein Spec File so (oder so ähnlich aus):

 1 <?xml version="1.0"?>
 2 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
 3   <metadata>
 4     <id>MyPackageName</id>
 5     <version>$version$</version>
 6     <authors>Jan Zieschang</authors>
 7     <owners>Jan Zieschang</owners>
 8     <!--<licenseUrl>http://LICENSE_URL_HERE_OR_DELETE_THIS_LINE</licenseUrl>
 9     <projectUrl>http://PROJECT_URL_HERE_OR_DELETE_THIS_LINE</projectUrl>
10     <iconUrl>http://ICON_URL_HERE_OR_DELETE_THIS_LINE</iconUrl>-->
11     <requireLicenseAcceptance>false</requireLicenseAcceptance>
12     <description>Here I should describe my package a bit</description>
13     <tags>Tags For Grouping And Finding</tags>
14     <dependencies>
15       <dependency id="PostSharp" version="2.1"/>
16       <dependency id="log4net" version="1.2" />
17     </dependencies>
18   </metadata>
19   <files>
20     <file src="bin\Release\myPackageLib.dll" target="lib\net40"/>
21     <file src="bin\Release\myPackageLib.xml" target="lib\net40"/>
22     <file src="bin\Release\myPackageLib.pdb" target="lib\net40"/>
23     <file src="bin\Release2\myPackageLib.dll" target="lib\net20"/>
24     <file src="bin\Release2\myPackageLib.xml" target="lib\net20"/>
25     <file src="bin\Release2\myPackageLib.pdb" target="lib\net20"/>
26   </files>
27 </package>

Nun schlug aber der “Nuget pack” Aufruf fehlt. Nach etwas probieren musste ich feststellen, dass der Aufruf nun das Spec file direkt benötigt.

1 "%nugetPath%" pack "MyPackageName.nuspec" -Version %1 -OutputDirectory "%output%" -symbols -Properties Configuration=Release

Wie man ein Package erstellt kann man noch viel detaillierter unter http://docs.nuget.org/docs/creating-packages/creating-and-publishing-a-package nachlesen. Hier noch einige Tipps für die Paketierung - http://lostechies.com/joshuaflanagan/2011/06/23/tips-for-building-nuget-packages/. Publishen von Packages ist mehr als simpel. Paket in den Ordner kopieren und oder mittels nuget push auf den Paket Server schieben. Ich kam nun aber zu meinem eigentlich Problem.

Da ich für mein Projekt mehrere Ausgaben für unterschiedliche Frameworks erzeugen wollte, musste ich irgendwie meine Projekt-Referenzen austauschen. Letztendlich habe ich mein Project files editiert und die Hint-Paths für die Assemblies verändert.

1 <Reference Include="log4net">
2   <HintPath>..\packages\log4net.1.2.10\$(Log4NetHintPath)\log4net.dll</HintPath>
3 </Reference>
4 <Reference Include="PostSharp, Version=2.1.0.0, Culture=neutral, PublicKeyToken=b13fd38b8f9c99d7, processorArchitecture=MSIL">
5   <HintPath>..\packages\PostSharp.2.1.2.8\$(PostSharpHintPath)\PostSharp.dll</HintPath>
6 </Reference>

Die beiden Hint-Paths für die Referenzen PostSharp und Nunit werden mittels einer Variable dynamisiert. In einer PropertyGroup mit einem Condition-Element können die Referenzen ausgetauscht werden.

1 <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release3.5|AnyCPU'">
2   <PostSharpHintPath>lib\net20</PostSharpHintPath>
3   <Log4NetHintPath>lib\2.0</Log4NetHintPath>
4   <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
5 </PropertyGroup>

Achtung: Sollte man die Referenzen aktualisieren, zum Beispiel weil es neue Versionen als Nuget-Package gibt, muss ggf. der Hint-Pfad erneut korrigiert werden.

Außer dem Hint-Path muss die Property “TargetFrameworkVersion” gesetzt werden. Dadurch kann man mit MSBuild 4.0 alle Fx Versionen bauen. (Ich glaube, es gebe auch schon in MSBuild 3.5)

Das war die minimal Version. Aber ich habe schon seit Wochen TeamCity auf meinem Rechner gehabt und CI Builds von meinem Paket zu erzeugen. Außerdem wollte ich auch eine minimal Validierung meines Setups haben.

Aus bauen und Paket erstellen ist sind 4 Schritte geworden. Baue Fx4 Version, Validiere diese Version, Baue Fx3.5 Version Validiere diese und anschließend erstelle mein Nuget-Paket. Natürlich übernimmt der CI Server auch die Versionierung der Assemblies und des Paketes und checkt die Version immer sauber aus.

Technorati Tags: dev CI nuget msbuild

Braucht man für DVCS auch lokale Build-Server?

DVCS steht für Distributed Version Control System. DVCS  ist nicht neu, aber es ist seit einigen Jahren noch stärker in Mode gekommen. Die beiden gängigsten Vertreter sind Mercurial (HG) und GIT. Zurzeit nutze ich für meine “Spiel”-Projekte Mercurial, da es unter Windows etwas angenehmer ist und BitBucket unbegrenzte (private) Repos zur Verfügung stellt.

Das Gute an DVCS ist, dass man sämtliche Informationen lokal hat und auch alle Interaktionen mit dem Repository lokal durchführt. Nur ab und an muss man sich mit dem “source” Repo verbinden und die Informationen updaten. Andere haben die Möglichkeit vom eigenen Repo eine komplett arbeitsfähige Kopie zu ziehen. Ich nutze am meisten lokale Branches und Commits (Reverts). Ich hatte leider einige mal Dateien vergessen einzuchecken (genau wie bei zentralen Repos). Ohne Continuous Integration (CI)  Build merkt man das vermutlich erst, wenn man mal einen anderen Rechner nutzt. Bei zentralen Repos nutze ich eigentlich immer CI, bisher bei DVCS eher weniger. Nach vergessenen Dateien und der Frage, wie ich das abstellen kann, habe ich mich entschieden lokal zu integrieren.

Ich habe mein lokales DVCS Repo in einem Build-Server konfiguriert, so dass dieser einen Clone erzeugt und anschließend gegen die Version kompiliert. Später habe ich auch noch die Ausführung von Tests hinzugefügt. Mir ist dabei erst wieder aufgefallen, wie viel man beachtet, wenn man ein weiteres Feedback der Kompilierung erhält. Denn im Studio geht doch fast immer alles. Man kann das lokale CI noch verbessern, in dem man einen Remote-Build-Agent benutzt, so dass auch ggf. Abhängigkeiten zu VS.NET Installation oder anderer Software erkannt werden können. Seit einiger Zeit habe ich mir auch angewöhnt Unit-Tests zu schreiben, es wird immer leichter einen Test zu schreiben, leider vergesse ich aber öfters die Tests vor dem Checkin laufen zu lassen. Mein Build-Server nimmt mir diese Arbeit ebenfalls ab, so dass ich schnell merke, dass etwas nicht passt. Normalerweise sind die heutigen Rechner leistungsfähig genug und eine Software zügig zu kompilieren ohne, dass die Arbeit maßgeblich leidet. Ich werde in Zukunft, sofern ich mit DVCS arbeite, meinen lokalen Build Server nutzen. Aber noch ein weiterer Vorteil entsteht, Reproduzierbarkeit. Ich kann, sofern ich mal eine Version meines Codes zur Verfügung stelle, diese leicht noch einmal bereitstellen. Es ist nicht notwendig Dateien von Hand zusammen zu sammeln und an die richtigen Stellen für meine Auslieferung zu kopieren.

Ich bin ein riesiger Fan von CCNet und finde den Server für .NET einfach sehr schön. Allerdings gibt es einige Dinge, die mich (vermutlich eher andere) stören. So ist die Konfiguration nicht sehr intuitiv und erfordert schon etwas wissen. Zum Anpassen der Konfiguration muss man eigentlich immer das XML manipulieren und auf dem Server aktualisieren. Das war der Grund mich mal wieder umzuschauen und eine sehr schnell aufkommende alternative war TeamCity. Es ist für kleinere Build-Umgebungen, die man vermutlich lokal auch nur hat, kostenlos und ermöglicht in der Website relativ leicht die Konfiguration und Statusabfrage. Ich finde die Webseite des lokalen Build-Servers schick und übersichtlich, es wird viel Ajax genutzt um Informationen bereitzustellen.

In TeamCity kann man dem Build-Agent Bedingungen zuweisen die dieser Erfüllt und einer Build-Konfiguration Bedingungen, die erfüllt sein müssen um eine Integration auszuführen. Man kann sich auch einfach mittels verschiedener Kommunikationskanäle über den Status informieren lassen.

Technorati Tags: dev,SCM

Ein paar Unity 2.0 Beispiele

Ich komme kaum noch zum Bloggen, es findet sich immer etwas Wichtigeres. Zu dem fehlt momentan die Kick-Technologie zum bloggen.

Heute stelle ich zumindest mal meine Samples zu Unity 2.0 zum Download. Ich setze in fast all meinen Projekten Unity ein (außer ich muss etwas anderes nutzen), da es sehr simpel und effektiv ist. Unity ist bei Microsoft in eine wichtige Rolle geschlüpft. Heute habe ich gelernt, dass Unity im Exchange Server 2010 verwendet wird. Ich muss mir das zukünftig mal genauer anschauen. Das

Unity kann man Inline konfigurieren, oder per externer Konfiguration initiieren. Bei der Konfiguration per Code werden die Typen und Mappings direkt zum Container hinzugefügt. Die Inline Konfiguration nutze ich als Fallback, falls keine Konfiguration im Container vorhanden ist.

   1:  IUnityContainer container = new UnityContainer();

   2:  container.RegisterType<ITestInterface, TEstRunner>();

   3:  container.RegisterType<ITestInterface, TEstRunner>("specialVersion");

   4:  container.RegisterType<ITestInterface, TEstRunner>("singelton", new ContainerControlledLifetimeManager());

Prüfung, ob eine Definition vorhanden ist.

if(!container.IsRegistered<ITestInterface>())container.RegisterType<ITestInterface, TEstRunner>();

Zur Konfiguration mittels der Konfigurationsdatei muss der Container mit

new UnityContainer().LoadConfiguration();

initialisiert werden. Die Konfiguration könnte zum Beispiel so aussehen:

   1:  <configuration>

   2:    <configSections>

   3:      <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, Microsoft.Practices.Unity.Configuration"/>

   4:    </configSections>

   5:   

   6:    <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">

   7:      <alias alias="runner" type="PoC.Unity.Configuration.TEstRunner, PoC.Unity.Configuration"/>

   8:      <alias alias="Iservice" type="PoC.Unity.Configuration.ITestInterface, PoC.Unity.Configuration"/>

   9:      <container>

  10:        <register type="Iservice"  mapTo="runner"/>

  11:        <register type="Iservice"  mapTo="runner" name="specialVersion">

  12:          <lifetime type="perthread"/>

  13:        </register>

  14:        <register type="Iservice"  mapTo="runner" name="singelton">

  15:          <lifetime type="singleton"/>

  16:        </register>

  17:      </container>

  18:    </unity>

  19:  </configuration>

Beim Erstellen eines Objektes durch den Container, können notwendige Abhängigkeiten ohne weitere Aktionen übergeben werden, sofern diese dem Container bekannt sind. (Injection) Ich nutze meistens Konstruktur Injection, da dies aus meiner Sicht die richtige Anwendung für erforderliche Komponenten ist.

   1:  public class TEstRunner : ITestInterface

   2:  {

   3:      private readonly IUnityContainer _container;

   4:      public TEstRunner(IUnityContainer container)

   5:      {

   6:          _container = container;

   7:          Console.WriteLine("Do I have a container? - " + (ReferenceEquals(_container, null) ? "no" : "yes"));

   8:      }

   9:  ...

  10:  }

  11:  container.Resolve<ITestInterface>().Run();

AOP ist etwas komplizierter, sobald es einmal läuft, auch wieder ganz einfach. ;) Allerdings muss man einige Utility-Klassen erstellen, so ist eine Attribute-Klasse und eine Implementierung des ICallHandler-Interface notwendig. Hier zumindest mal die Unity-Konfiguration:

   1:  IUnityContainer uc = new UnityContainer();

   2:  uc.AddNewExtension<Interception>();

   3:  uc.RegisterType<ITestInterface, TEstRunner>();

   4:  uc.Configure<Interception>()

   5:      .SetDefaultInterceptorFor<ITestInterface>(new InterfaceInterceptor());

Eigentlich ist es egal welchen DI/IoC Container man nutzt, es hilft den Code testbarer zu machen und reduziert Abhängigkeiten deutlich. Das Beste Bespiel für die Reduzierung von Abhängigkeiten erlebt man, wenn man mit Prism arbeitet.

Hier noch der Link zu einem schönen Video zu Unity (etwas veraltet): Unity Features and Futures at the patterns and practices Summit 2009

Samples: poc.unity.zip

X-Mas–The art of unit testing

Dieses Jahr habe ich mich mit “The art of unit testing” beschenkt. Wenn ich es gelesen habe, dann steige ich bestimmt zum Sennmeister für Unit testing auf.

Dieses Jahr wurde in einem Projekt endlich Unit testing als sehr wichtiges Instrument genutzt. Allerdings haben wir das klassische Unit testing mit umfangreichen Intregrationstest verbunden. Allerdings mussten wir vorher in den Projekten lernen, was passiert, wenn die Tools nicht testbar sind und immer komplexer werden. Gerade bei der Architektur und dem Design muss auf eine gute Testbarkeit und Entkopplung wert gelegt werden. Derzeit ist für mich das Mittel der Wahl für IoC – Unity, obwohl mich ein Kollege immer von Spring überzeugen will. Bisher kann ich mich bei Spring nur für den AOP-Teil begeistern.

Wer unit tests für Grenzwerte oder mehrere Parameter schreibt, der sollte auch mal einen Blick auf Nunit Attributes schauen. Es gibt viele Möglichkeiten die Tests zu Parametrisieren und so ein bisschen auch FIT oder ähnliche Tools nachzuahmen.

Es gibt noch einiges zu tun in diesem Jahr, ich muss mich noch ganz schön ranhalten. Andererseits muss ich erst mal wieder richtig fit werden. Mein Körper holt sich in den letzten Wochen den fehlenden Urlaub. Obwohl ich mich nicht schlecht fühle, bin ich erst mal krankgeschrieben und muss mich entspannen.

Query Performance–Open Source, Reflection und “Java”-Tools

Wie  üblich bei den meisten Applikationsentwicklungen ging es bei uns in den letzten Wochen u. a. um das Thema Performance. Die aktuelle Anwendung nutzt verschiedene Open Source Komponenten zum Verarbeiten der Daten. Die Komponenten sind convertierte Java-Entwicklungen, teilweise mit langem Hintergrund.

Zum einen muss ich sagen, dass man wirklich extrem Differenzieren muss zwischen den einzelnen Projekten. Teilweise sollte man vor dem Einsatz noch ein Code-Review und Analyse einschieben. Eine Open Source Komponente nutze Exceptions exzessiv zur Flusssteuerung, was schlechtes Design ist und u. U. Performance kostet. Leider nutzen wir auch eine Datenzugriffskomponente, die eigentlich fast keine Arbeit abnimmt, da damit nur Objektzuweisung durchgeführt werden. Ein OR-Mapper, der Arbeit abnimmt, würde eine wesentlich bessere und einfachere Entkopplung ermöglichen.

Die Datenzugriffskomponente, ich weigere mich OR-Mapper zu sagen, arbeitet intern heftig mit Reflection um die Properties zu setzen. Leider ist gerade bei Massenoperationen Reflection keine gute Wahl. Reflection ist ein zentraler Bestandteil im .NET Framework, dennoch kostet jede Operation dennoch einige Millisekunden, die wenigen Millisekunden potenzieren sich dann bei mehreren Tausend Objekten zu einigen Sekunden, im schlimmsten Fall zu Minuten. Allgemein sollte vor dem Einsatz eines OR-Mapper immer geprüft werden, ob es sich um Massenoperationen handelt, diese sollten ggf. mit klassischen ADO-Mitteln abgehandelt werden. Um unsere Roundtrips zur DB zu reduzieren, haben wir die verschiedenen Statements zu einem "großen" Statement zusammengefügt. Leider wurde dadurch das resultierende Objekt größer und die Property Zuweisungen haben sich auch vervielfacht. Aufgrund der Eltern-Kind-Beziehung in den Statements benötigten die Abfragen anschließend 40s (5s beim Ausführen in der DB). Grundsätzlich kann durch Joins die Abfragegeschwindigkeit gesteigert werden, OR-Mapper wie Lind2SQL oder NHibernate machen diese Optimierungen durchaus auch. Wir haben unsere Zugriffe durch Aufsplitten unserer Joins um das 10-fache beschleunigt. Die Joins wurden eingeführt, um einige DB-Roundtrips zu sparen, leider wurden unserer Datensätze dadurch aber auch ver-100-facht. 100-fache Datenmenge und viel Reflection haben sich so massiv ausgewirkt, dass wir bis zu 40s für einfache Selects benötigt haben. Somit wurden also 2 Statements abgesetzt, 1 die Elterndaten und die 2. Abfrage mit den Kinderdaten, in beiden Statements wurde die gleiche Bedingung benutzt. Wir haben die Zuordnung der Kinder zu Ihren Elternelementen im Code realisiert, da dies sehr einfach war und wir nicht ggf. 100te Roundtrips produzieren. Würde man zu jedem Customer (Beispiel) die entsprechenden Orders über den PK laden, wären dass ggf. sehr viele Operationen. Um das ganze weiter zu optimieren, kann man bei einigen Datenbankprovidern mehrere SQL-Operationen in einem Rutsch absenden, so dass die Weitere Zeit kaum ins Gewicht fällt.

Hier ein sehr abstraktes und einfaches Beispiel:

 1 select * from Customers c
 2 INNER JOIN Orders o ON c.ID=o.customerID
 3 WHERE o.orderdate>@DATE;
 4 /* Splittet into 2 Statements */
 5 select c.* from Customers c
 6 INNER JOIN Orders o ON c.ID=o.customerID
 7 WHERE o.orderdate>@DATE;
 8 select o.* from Customers c
 9 INNER JOIN Orders o ON c.ID=o.customerID
10 WHERE o.orderdate>@DATE;

Dies soll kein Post gegen Open Source oder konvertierte Java-Componente sein. Jedoch finde ich es falsch, einfach anzunehmen, dass gut funktionierende Java-Componenten, auch gut in .NET funktionieren. Es sollte immer der Anwendungsfall im Vordergrund stehen. Componenten/Frameworks sind nur Unterstützer zu diesem Weg. Nebenbei bin ich sehr  gespannt, wie es mit JAVA weiter geht http://goo.gl/rUAHG.

Vielleicht bekomme ich es doch noch mal hin, dass ich diese Jahr noch einen weiteren Post erstelle. Ich wollte seit Wochen mal was zu NDepend schreiben, aber …

GIT, Putty and SSH auth (Windows)

Ich hatte heute morgen Problem beim Zugriff auf mein GIT-Repository. Eigentlich hatte es immer super geklappt, allerdings habe ich auf dem Rechner nur die Portable Version von msysgit benutzt. Also mal wieder das typische Googlen bis man was findet, etwas passendes zu finden, war aber eher ein Glücksspiel. Zumindest wußte ich zu 90% was ich zu tun habe.

Zu erst benötigt man natürlich GIT, unter Windows würde ich derzeit immer auf msysgit zurückgreifen. Außerdem werden für Zugriff auf Repositories mit SSH/Public Key Access noch die Putty-Tools benötigt, eigentlich braucht man nur pageant.exe, plink.exe und puttygen.exe.

Zuerst erzeugt man sich ein einen Private-Key mittels puttygen erzeugen. Nach dem das Zertifikat erstellt wurde, muss dieses nur noch gespeichert werden. A

Außerdem sollte man den Text für Public Key kopieren. Dieser wird für den Import bei dem GIT-Anbieter oder Server benötigt, genauso wie bei vielen anderen Applikationen. Bei Unfuddle zum Beispiel wird der Key beim Benutzer registriert und ermöglicht erst dadurch die Authentifizierung und den Zugriff auf das Repository.

Den gespeicherten Private-Key (ppk-Erweiterung) öffnen man nun mit pageant. Um den Key zu lesen muss die Passphrase angegeben werden.

Ist der Key geöffnet, so kann man versuchen das Repository zu öffnen. Dazu "plink.exe –v git@<project>.unfuddle.com:user/<projectrepo>.git" ausführen. Die Antwort sollte dann etwa so aussehen:

   1: Looking up host "<project>.unfuddle.com"

   2: Connecting to 174.129.5.196 port 22

   3: Server version: SSH-2.0-OpenSSH_5.1p1 Debian-5

   4: We claim version: SSH-2.0-PuTTY_Release_0.60

   5: Using SSH protocol version 2

   6: Doing Diffie-Hellman group exchange

   7: Doing Diffie-Hellman key exchange with hash SHA-256

   8: Host key fingerprint is:

   9: ssh-rsa 2048 a6:74:33:36:95:31:6e:a6:d7:71:87:b8:3c:38:e2:60

  10: Initialised AES-256 SDCTR client->server encryption

  11: Initialised HMAC-SHA1 client->server MAC algorithm

  12: Initialised AES-256 SDCTR server->client encryption

  13: Initialised HMAC-SHA1 server->client MAC algorithm

  14: Pageant is running. Requesting keys.

  15: Pageant has 1 SSH-2 keys

  16: Using username "git".

  17: Trying Pageant key #0

  18: Remote debug message: Forced command: gitosis-serve <user>_<user>

  19: Remote debug message: Port forwarding disabled.

  20: Remote debug message: X11 forwarding disabled.

  21: Remote debug message: Agent forwarding disabled.

  22: Remote debug message: Pty allocation disabled.

  23: Authenticating with public key "<key comment>" from agent

  24:  

  25: Sending Pageant's response

  26: Remote debug message: Forced command: gitosis-serve <user>_<user>

  27: Remote debug message: Port forwarding disabled.

  28: Remote debug message: X11 forwarding disabled.

  29: Remote debug message: Agent forwarding disabled.

  30: Remote debug message: Pty allocation disabled.

  31: Access granted

  32: Opened channel for session

  33: Server refused to allocate pty

  34: Started a shell/command

  35: ERROR:gitosis.serve.main:Need SSH_ORIGINAL_COMMAND in environment.

  36: Server sent command exit status 1

  37: Disconnected: All channels closed

Evtl. kann eine Bestätigung des Server Keys notwendig sein, dass sollte allerdings nur beim 1. mal der Fall sein.

Hat der Teil geklappt, dann fehlt nur noch git korrekt zu konfigurieren. Hat mit den msysgit installer benutzt und die Option plink.exe während der Installation ausgewählt, so sollte bereits alles funktionieren, anderenfalls muss noch etwas nachgearbeitet werden. Um git beizubringen, dass er mittels pageant/plink sich authentifizieren soll, muss noch eine Umgebungsvariable gesetzt werden.

   1: GIT_SSH=<path to plink>\plink.exe

Anschließend kann mit git auf das Repo zugegriffen werden

Der Zugriff kann durch registrieren des Remote-Repo ordentlich verkürzt und vereinfacht werden. Beim erzeugen des Repo mit git clone … sollte das bereits passiert sein.

Hier noch mal ein kleiner Git-Ablauf (nach meinem Verständnis)

   1: cd myproject

   2: git init

   3: git remote add unfuddle git@<project>.unfuddle.com:<user>/<repo>.git

   4: git config remote.unfuddle.push refs/heads/master:refs/heads/master

   5: git pull unfuddle master

   6: git checkout -b dev

   7: ... changes ...

   8: git add **/*

   9: git commit -a -s -m ""

  10: git checkout master

  11: git merge dev

  12: git push unfuddle master

In der ersten Zeile wird in ein leeres Verzeichnis gewechselt und anschließend das Repository angelegt. Zeile 3 und 4 registrieren das Remote-Repository, so dass in Zeile 5 mit unfuddle auf dem Repo zugegriffen werden kann. Zum arbeiten wird dann in einen neuen Branch dev gewechselt. Anschließend können die Arbeiten durchgeführt werden. mittels git add werden neue Dateien für das Change-Tracking und den anschließenden Commit registriert. Mittels commit werden die Änderungen lokal übernommen. Der Parameter "-s" sorgt dabei für das hinzufügen des "Sign-off"/Abzeichnen und der Parameter –a übernimmt alle Änderungen in den Commit. Danach wird zum "Hochschieben" der Änderungen in den master gewechselt und die Änderungen aus dem "dev" Zweig übernommen. Git push shiebt in Zeile 12 die Änderungen ins Repository.

Weiterhin sind die Befehle git init/git gui zu empfehlen, ich nutze diese immer wieder mal. Manche Sachen sind einfach nicht geläufig.

Hier sind noch einige interessante Links:

• http://www.sourcemage.org/Git_Guide
• http://live.gnome.org/Git/FAQ
• http://asimilatorul.com/index.php/2009/09/20/git-on-windows-with-msysgit/

Projektgeschäft …

Hmmm, mein letzter Post ist 3 Monate her. :( Sorry, habe ich in den letzten Wochen einfach viel mit meinem Projektbeschäftigt und hatte dann nicht mehr so viel Lust am Abend noch zu bloggen oder etwas anders zu machen. Zudem war das Wetter auch sehr schön, Fußball, ….

Ich werde versuchen in nächster Zeit wieder etwas mehr zu bloggen und auch einige Themen finden. Bisschen was habe ich noch an Ideen, aber Aufgrund von Lustlosigkeit nicht geblogged.

Aktuell habe ich eigentlich ein Projekt ohne "wow"-Effekt, dafür aber sehr anstrengend aufgrund der Konzeption. Ich finde es sehr schade, dass ich das Projekt nicht von Anfang an gestalten konnte, sondern ein "*****" weiterführen sollte. Schön ist es aber trotzdem jeden Tag wieder Lösungen zu finden.

Was sich auch bei diesem Projekt wieder zeigt, mit Continous Integration lässt sich die Qualität eines Projektes steigern, allein dadurch, dass das Vertrauen in die kompilierfähigkeit steigt. Wer wenige Erfahrungen mit Continous Integration hat, sollte sich mittels CI-Factory dem Thema zu nähern. CI-Factory setzt eine komplette Projektbuildumgbung mit allen wichtigen Tools und Konfiguration nach Best Practices auf. Ich bin nicht mit allen Sachen einverstanden, aber dabei handelt es sich um Details. Zusätzliche Aktionen, wie Code-Analysen oder Unit-Tests, sorgen für deutlich mehr vertrauen. Unit-Tests sind ein wichtiges Mittel, wie man auch immer wieder liest. Wir hatten innerhalb unseres Teams in den letzten Wochen mehrfach die Diskussion, was ein Unit-Test ist. Ich bin derzeit absolut der Meinung, dass ein Unit-Test komplett ohne äußere Einflüsse auskommen muss, zum einen beschleunigt dies die Ausführung, zum anderen sichert es einen wiederherstellbaren Ausführungszustand. Leider arbeiten wir mit VB.NET, ich finde es eine furchtbare Entscheidung und könnte während des Schreibens von Unit-Tests nur fluchen, obwohl es auch während der normalen Entwicklung schon ein "Krampf" ist. Leider hört man oft das Argument, dass sich die VB6-Entwickler nicht an etwas Neues gewöhnen müssen, aber mal ehrlich, VB6 und .NET sind schon sehr unterschiedliche Technologien.

Jeder der dennoch VB.NET-Projekte realisiert sollte darauf achten, dass Option Strict und Option Explicit auf jeden Fall aktiviert sind. Leider war das in meinem Projekt nicht der Fall, es gibt einige Ausführungspfade, wo ich nicht sagen kann, was wirklich bei den Typ-Umwandlungen passiert.

Eine andere Sache, die sich (wieder) sehr positiv gezeigt hat, sind DI/IoC. Dadurch wird die Wartung und Austauschbarkeit von Komponenten deutlich erhöht.

Nebenbei beschäftige ich mich wieder mit Prism/CompositeWPF. Ich finde das Konzept richtig schick und es macht viel Spaß damit zu arbeiten. Ich muss dabei noch so viel lernen, auch bei MVVM lerne ich bei jeder Benutzung wieder etwas dazu. Bei Prism gibt es demnächst ein neues Release (Version 4).

Ants Performance Profiler

Cool, es gibt die neue Version des Ants Performance Profilers. Neu in der Version ist eine Kommandozeilen Version, die im Build mitlaufen kann. Wenn man in einer Anwendung Performance Probleme hat, dann ist das sicherlich eines der besten Tools. Es ist leicht verständlich, schnell und einfahch zu benutzen. Ich finde jedes Team sollte Zugang zu mind. einer Ants Profiler Version haben. Die Investition in die Pro-Version rechnet sich und lohnt auf jeden Fall.

Oracle Client und die Versionen …

Leider muss ich schon wieder eine ganze Weile mit Oracle Datenbanken arbeiten. Es gibt sovieles, was mich an Oracle stört, aber ein Austauschen ist nicht möglich. Das Schlimmste bei der Arbeit mit Oracle-Datenbanken ist diese nervige Client-Problematik und diese TNSNames-Konfiguration Sch…. In dem Unternehmen in dem ich zur Zeit aktiv bin, gibt es ein relativ umfangreiches Software Management, man hat für Oracle eine Standardversion definiert, die Version 10. Leider gibt es zu der Version nicht den passenden ODP.NET Provider für .NET-Framework 2.0, so dass bisher den FX 1.0 Treiber benutzt wird. Wie man sich denken kann, wird dabei auch nicht alles unterstützt, unteranderem fehlt die Unterstützung für Framework 2.0 Transaktionen. Ein noch viel größeres Problem ist aber, dass es auch durchaus noch Arbeitsplätze mit Ora Client 9 gibt und auf diesen funktioniert es gar nicht. Bei manchen klappt es, wenn die OraOps10.dll vorhanden war, aber  dann ging es auch auf einigen Oracle Client 10 Installationen nicht.

Seit der Version 11, vielleicht auch 10 gibt es eine halbwegs akkzeptable Lösung, der Oracle Instant Client. Mit etwas Aufwand kann man sogar den Client komplett mit nur 5 Dateien mit der eigenen Applikation verteilen und ist nicht damit nicht mehr auf die vorhandene Installation, welche Version auch immer es ist, angewiesen. Nach dem ersten Schritt, finden des Instanat Clients als mögliche Lösungsoptionen, hatte ich mein Problem mit dem Oracle Client nocht nicht final gelöst. Laut Oracle müssen Umgebungsvars gesetzt werden, was dann aber evtl. höhere Rechte beim Einrichten erforderlich machen würde. Nach einigem googlen bin auch den Post "Deploying ODP.NET with Oracle Instant Client" gestoßen und das sieht genau nach der Lösung aus, die ich brauchte. Ich habe mich für den Basic Client entschieden, es gibt auch noch eine Lite-Version, ich wollte nicht das Risiko eingehen, dass Funktionalitäten nicht mehr gehen. (Lite würde ungefähr 30MB ergeben, Basic etwas über 100 MB) Die Dateien

• oci.dll
• Oracle.DataAccess.dll
• oramts.dll
• oramts11.dll
• oramtsus.dll
• orannzsbb11.dll
• oraocci11.dll
• oraociei11.dll und
• OraOps11w.dll

müssen sich bei der Ausführung im Applikationsverzeichnis liegen. OraMTS wird für Transaktionen benötigt. Am besten im Visual Studio Projekt einbinden und "Copy to output directory" auf "Copy if newer" setzen, so dass die Dateie im richtigen Verzeichnis landen.

Einige Probleme gab es noch bei der Konfiguration auf den Rechnern, Oracle ermöglich es viele Einstellungen über Umgebungsvariablen oder Registry vorzunehmen, offensichtlich war durch die vielen Client Versionen auf meinem Rechner einiges "merkwürdig". Ich habe die Einstellungen für "NLS_LANG" und "TNS_ADMIN" in meiner Applikation gesetzt.

   1:  Environment.SetEnvironmentVariable("NLS_LANG", "GERMAN_GERMANY.WE8MSWIN1252")

   2:  Environment.SetEnvironmentVariable("TNS_ADMIN", AppDomain.CurrentDomain.BaseDirectory)

NLS_LANG bei Oracle nachschlagen. TNS_ADMIN ermöglich das Auffinder der TNSNAMES.ORA, ich konnte Transaktionen nicht ohne TNSNAMES aufbauen, es gab immer einen seltsamen Fehler, wenn die "Data Source" im Connection String den TNS-Eintrag enthielt. Nach dem beide Werte gesetzt waren, klappt es wunderbar, hoffentlich auch weiterhin. Vielleicht sollte sich Oracle mal überlegen, ob es nicht schick wäre einen komplett Managed Treiber zu erstellen.

Auto freier Sonntag – Fahrrad fahren in Berlin

Heute war, wie die letzten Tage, bestes Wetter. Zum Glück hat der ADFC heute zur Sternfahrt zum Umweltfest organisiert. Für mich war es die 1. Teilnahme und es war einfach nur schön, aber langsam.

Die Sternfahrt führt von vielen Punkten in Berlin zur Siegessäule, ich habe mich am Bahnhof Lichtenberg angschlossen, obwohl auch vor der Haustür möglich gewesen werden. Es war super beeindruckend, wie viele schon an in der Schlange waren. Unterwegs Richtung Ostbahnhof haben sich viele weitere Radler angeschlossen und bei gemütlichem Tempo, vermutlich knapp über 10km/h fuhr es sich auch bei der Hitze super. Die Tour führte anschließend über Treptow nach Neuköln, dort war eines der Highlights der Tour, fahren durch den Autobahntunnel. Allerdings vor dem Tunnel war das große warten. Die Massen waren so große, dass es eine Gefühlte Ewigkeit gedauert hat, um auf die Autobahn zu kommen. Im hinteren Teil konnte man anschließend kräftig gas geben um wieder nach Vorne zu kommen. Im Tunnel auf der Autobahn war es so klasse, zu mal bei den Temperaturen der Schatten nach dem Stehen in der Hitze super angenehm war. Toll war im 2. Teil der Strecke, dass diese komplett durch die Polizei gesperrt war, der 1. Teil war Fahren hinter dem Führungsfahrzeug. Irgendwo kam auch der ganze Rest der Radler aus den westlichen Bezirken dazu, das war aber nicht mehr so sehr zu merken, da sich alles über viele viele Kilometer auseinander gezogen hatte.

Slideshow

Auf dem 17. Juni wurden die Radler Umweltfest begrüßt, wo Essen und Getränke nach gefüllt werden konnten. Bei Getränkenn fällt mir ein, dass meine 1,5-2l knapp waren. Auf dem Umweltfest gab es auch noch gute Musik, unter anderem von 48 Stunden. Ich habe mir dort nicht so viel Zeit gegönnt, bin nach kurzem Aufenthalt Richtung zu Hause gefahren.

Für mich war es ein Fahrradreiches Wochenende mit viel Sonne und viel Spass, leider aber auch wieder ein Blog-Post ohne Technik. Wenn es gut läuft kann ich vielleicht nächstes Jahr die Kids und einige Freunde begeistern. Es waren sehr viele Kinder dabei.