.NET User Group Bern Community Feed

SQL Server Performance Tuning and Troubleshooting Workshop in Bern (19. - 21. Juni 2012)

info@dnug-bern.ch — Mon, 18 Jun 2012 08:00:00 Z

Freitags - 16:30. Sie erhalten eine Email, dass Ihr SQL Server Installation in enorme Performance- Probleme geraten ist! Was nun? Wie können Sie das Problem identifizieren und effektiv lösen? Welche Tools stehen Ihnen dazu mit dem SQL Server 2008 (R2) zur Verfügung?

In diesem Workshop werden Sie eine Reihe von unterschiedlichen Tools kennenlernen, mit denen Sie ein effektives Troubleshooting einer SQL Server 2008 (R2) Installation durchführen können. Sie werden einerseits lernen, die entsprechenden Problembereiche anhand bestimmter Scripte/Tools zu identifizieren, um diese anschließend aufgrund der gewonnenen Erkenntnisse zu beseitigen.

Mitglieder der .NET User Group Bern profitieren von einem zusätzlichen Rabatt. Der Rabattcode steht für Mitglieder in unserem internen Xing-Forum zur Verfügung. Bei einer Anmeldung diesen im Bemerkungsfeld des Anmeldeformulars eintragen.

CQRS mit Roger Rudin

Tue, 12 Jun 2012 18:00:00 +0200

.NET User Group Bern Event

Dienstag, 12. Juni 2012 (18:00 bis 21:00 Uhr)

CQRS mit Roger Rudin

Kurz bevor es in die Sommerpause geht, treffen wir uns zum Thema CQRS mit Roger Rudin

Abstract

Immer mehr Entwickler verwenden Messaging Patterns und Domain Modelle in ihren N-Tier Architekturen. Manche sind über die zusätzliche Komplexität überrascht und fangen an sich zu fragen, ob sich das überhaupt lohnt. In dieser Präsentation stelle ich euch die fehlenden Patterns vor, welche benötigt werden um die Komplexität aus verteilten Systemarchitekturen herauszunehmen und diese zu vereinfachen.

Über Roger Rudin

Roger Rudin arbeitet als Software Architekt und agile Coach bei bbv Software Services AG.

Er beschäftigt sich seit vielen Jahren mit .NET-Technologien mit Schwerpunkt verteilte Systeme und Persistenz.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbecqrs.

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

JavaScript für C#-Entwickler mit Golo Roden

Tue, 29 May 2012 18:00:00 +0200

.NET User Group Bern Event

Dienstag, 29. Mai 2012 (18:00 bis 21:00 Uhr)

JavaScript für C#-Entwickler mit Golo Roden

Was im November 2011 mit einem Gesamtüberblick zum Thema "Rich-Internet Apps & Mobile Anwendungen mit HTML5, Javascript und Azure" begann, betrachten wir nun weiter in detaillierter Form. Nachdem wir mit Kay Herzam und Roland Krummenacher das Thema Azure vertieften, ist beim nächsten Treffen JavaScript an der Reihe. Für dieses Thema können wir erneut Golo Roden begrüssen, er wird JavaScript aus der Sicht eines C# Entwicklers beleuchten.

Abstract

Seit Monaten bereitest Du dich auf Windows 8 und WinRT vor. Nun hat gerade Dein wichtigster Kunde angerufen, um Dir den Auftrag zur Entwicklung einer entsprechenden Anwendung zu erteilen. Dein anfänglicher Stolz ist jedoch schnell Ernüchterung gewichen, als die Anforderung genannt wurde, dass die Anwendung in JavaScript geschrieben werden müsse ... Diese Sprache hast Du bislang nämlich vollständig außer Acht gelassen. Was Du jetzt brauchst, ist ein JavaScript-Crashkurs für C#-Entwickler, der Dir auf die Sprünge hilft. Golo Roden stellt in zwei Stunden (fast) alles vor, was Du über JavaScript wissen musst, und zeigt - ganz nebenbei - dass JavaScript-Entwicklung nicht bedeutet, steinzeitlich mit vi auf der Konsole arbeiten zu müssen.

Über Golo Roden

Golo Roden ist freiberuflicher Wissensvermittler und Technologieberater für Webtechnologien, Codequalität und agile Methoden. Zu diesen Themen berät er Firmen bei der Evaluierung, Erforschung und Verwendung geeigneter Technologien und Methoden. Darüber hinaus ist er journalistisch für Fachzeitschriften und als Referent und Content Manager für Konferenzen tätig. Für sein qualitativ hochwertiges Engagement in der Community wurde Golo von Microsoft als Most Valuable Professional (MVP) für C# ausgezeichnet.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbejs2.

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

Entity Framework 4.3 - Building Blocks oder wie steuer ich die Datenbankversion

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sun, 22 Apr 2012 07:04:00 +0200

Gelegentlich kommt es vor, dass die Datenbankversionen pro Umgebung unterschiedlich sein können. Bei meinen ersten versuchen ist mir das mit den SQL-Server Versionen 2005 und 2008 so ergangen.

Eine bessere Konsole für Git

Johnny Graber — Sat, 21 Apr 2012 10:12:50 Z

In letzter Zeit nutze ich auch unter Windows immer öfters Git. Dank dem Projekt Git for Windows braucht man nach dem Download nur den Installationsassistenten durchzuklicken und man kann los legen.

Die mitgelieferte Git-Konsole bietet leider nur wenige Verbesserungen gegenüber dem mit Windows ausgelieferten cmd.exe. Um einen Text zu kopieren und wieder einzufügen sind nach wie vor die gleichen Verrenkungen nötig.

Console2 als Alternative

Mit Console2 gibt es eine Alternative zu cmd.exe die sich mit einigen Anpassungen auch sehr gut als Umgebung für Git anbietet. Am einfachsten richtet man sich einen eigenen Tab für Git ein. Dazu kann man unter Edit / Settings den Einstellungsdialog starten und den Punkt Tabs öffnen:

Für meine Konsole habe ich diese Werte gesetzt:

Feld	Wert
Title:	GIT
Icon:	`C:\Program Files (x86)\Git\etc\git.ico`
Shell:	`C:\Program Files (x86)\Git\bin\sh.exe --login -i`

Mit diesen Einstellungen kann man mit den gleichen Eingabemöglichkeiten wie von der Git-Konsole her gewöhnt arbeiten. Zusätzlich hat man aber all den Komfort der einem Console2 bietet, wie das einfache kopieren von Text durch markieren oder ein Einfügen über einen Klick aufs Mausrad.

Einsortiert unter:Tools Tagged: .Net, Beschleuniger

.Net Framework übergreifend entwickeln mit Portable Class Libraries

Johnny Graber — Mon, 16 Apr 2012 16:56:23 Z

Mittlerweile gibt es neben dem .Net Framework 4 auch Silverlight, Windows Phone 7 und Xbox 360. Obwohl man überall in C# entwickeln kann stösst man doch schnell einmal an eine Grenze: Eine Klassenbibliothek vom vollen .Net Framework kann nicht in einem Silverlight-Projekt verwendet werden. Gleiches gilt für Windows Phone 7. Und um es noch ein wenig mühsamer zu machen sind Silverlight und Windows Phone 7 auch nicht kompatibel.

Dies zeigt sich mit dieser Fehlermeldung wenn man versucht eine *.dll einzubinden:

Portable Library Tools als Lösung

Eine Entdeckung der Tech Conference war für mich die Portable Class Libraries. Dieser Projekt-Typ ist vergleichbar mit einer gewöhnlichen Class Library. Allerdings kann man mehrere Framework-Plattformen als Ziel wählen.

Die einzelnen Frameworks haben eine grosse Menge an Funktionen die überall zur Verfügung stehen. So lange man in diesem Bereich bleibt ist dieser Projekttyp eine sehr gute Lösung um den Code nur einmal zu schreiben. Was genau geht und wo die Grenzen liegen ist in der MSDN gut beschrieben.

Benötigt man die Framework-Spezifischen Teile kann man immer noch mehrere Projekte machen und die *.cs Dateien verlinken.

Installation

Wie immer mehr Bibliotheken und Erweiterungen kann man die Erweiterung Portable Library Tools über NuGet installieren. Sobald dies gemacht ist gibt es eine neue Projektvorlage:

Über die Projekteigenschaften kann man die Zielframeworks sehr einfach auswählen:

Der wiederverwendbare Code kann nun in diesem Projekt entwickelt werden und steht Anwendungen der aktivierten Frameworks zur Verfügung.

Ausblick

Windows 8 wird mit Metro noch ein weiteres Framework in die .Net Welt bringen. Gemäss den Informationen aus der Tech Conference von Mitte März in Baden gibt es aber eine gute Nachricht: Visual Studio 11 (oder wie man die Version am Ende nennt) wird diesen Projekttyp bereits integriert haben. Eine Nachinstallation wird so nicht nötig sein und damit auch den Anwendern der Express-Edition zur Verfügung stehen.

Einsortiert unter:.Net, Visual Studio, webDotNet, Windows Phone 7 Tagged: .Net, C#, Silverlight, VisualStudio, Windows Phone 7

Rethinking Automated Testing

noreply@blogger.com — Sun, 15 Apr 2012 23:32:00 +0200

While you’ve been worrying about your BDD adverbs the iFart dev just made $40,000.

- Iain Hunter

Can you give 140 char synopsis of "opportunity cost of TDD?"

Is #TDD always a "Best Practice"? Is there even any such thing? When shouldn't you use it? What could you do instead?

- Conversation on Twitter

Testing implementation is terrible terrible terrible.

- Matt Rogish

The pendulum is swinging back and forth in the TDD and developer-testing world...
I blogged over two years ago about Testing Backlash and then again one year ago Are you too agile for TDD/BDD?

It seems the time has come for the pendulum to swing by once again. In an almost mystical conjunction a lot of alpha geeks are voicing current "new" insights about automated testing and TDD.

Maybe this is the developer community climbing the ladder to another stage of competence or to another stage of grief (the viewpoint is probably depending of the pains in your current project)… but maybe it is just that alpha-geeks like any other intelligent beings are getting bored after a while and turn to new topics.

Anyways, here is a list of the recent tide of "let's rethink automated testing":

Michael Feathers: Taking Automated Tests Off The Pedestal
DHH: Testing like the TSA
Scott Bellware: The Inflection Point - How Long can you Safely Avoid Automated Testing
Alberto Gutierrez: The evil unit test.
Hopefully soon Dan North: The opportunity cost of TDD

Just for completion I am reenumerating older reflections on the topic:

The Dark Side Beckons? by Obie Fernandez
Test-Driven Development and Embracing Failure by Steve Freeman
Problems with TDD an Essay by Andrew Dalke. Heavily discussed on his blog and on Hacker News.
Ayende's posts: Even tests has got to justify themselves and re: Are you smart enough to do without TDD
And finally Luce Francis brilliant presentation: Testing is Overrated (matching blog post, slides)

Update:
Tudor Girba: When testing does not cut it

If you like this, follow me on twitter ...

Entity Framework 4.3 Mapping Szenarien

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sun, 15 Apr 2012 22:58:00 +0200

Vor ein paar Wochen wurde über Twitter gefachsimpelt, welche Vererbungsstrategie Standard bei Code First ist. Es kam sehr schnell die Antwort TPT. Da ich diesen Bereich mit der Version 4.1 durchgetestet habe und eigentlich TPH der Standard ist, wollte ich nun überprüfen, ob sich etwas zur Version 4.3 geändert hat.

Einführung in MongoDB mit Roger Rudin

Tue, 10 Apr 2012 18:00:00 +0200

.NET User Group Bern Event

Dienstag, 10. April 2012 (18:00 bis 21:00 Uhr)

Einführung in MongoDB mit Roger Rudin

Im April treffen wir uns spontan ausserhalb des 2-Monats-Rhythmus zu einer Einführung in MongoDB mit Roger Rudin

Abstract

In den letzten Jahren sind etliche "NoSQL" Datenbanken entwickelt worden, welche unter Verwendung von Standardhardware enorme Skalierung und eine hohe Verfügbarkeit bieten. Grosse Internetplattformen wie Google, Facebook und Twitter setzen diese Technologie bereits sehr erfolgreich ein.

In dieser Session wird uns Roger Rudin einen Einblick in MongoDB, einer dokumentenbasierten NoSQL Datenbank, geben. Wir werden uns anschauen, wann sich der Einsatz einer NoSQL Datenbank lohnt, und warum gerade MongoDB eine sehr attraktive Datenbank für .Net Entwickler ist.

Tauche mit uns ab in die schemalose Welt von NoSQL.

Über Roger Rudin

Roger Rudin arbeitet als Software Architekt und agile Coach bei bbv Software Services AG.

Er beschäftigt sich seit vielen Jahren mit .NET-Technologien mit Schwerpunkt verteilte Systeme und Persistenz.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbem. Wir verzichten auf mdb als Suffix, damit keiner auf die Idee kommt, es handelt sich hierbei um MS Access ;-)

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

Entity Framework - Ein neuer Workaround für 2nd Level Cache mit dem DbContext

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Tue, 10 Apr 2012 13:07:00 +0200

Bisher habe ich den 2nd Level Cache nur über einen Umweg über den ObjectContext zum laufen gebracht. Pawel Kadluczka vom EF-Team hat Ende März einen weiteren Ansatz in seinen Blog veröffentlicht, der ohne den ObjectContext auskommt.

Buch-Rezension zu „MCPD 70-519 Exam Ref“

Johnny Graber — Sat, 31 Mar 2012 10:37:12 Z

“MCPD 70-519 Exam Ref: Designing and Developing Web Applications Using Microsoft .NET Framework 4” von Tony Northrup erschien im November 2011 bei Microsoft Press.

Dieses Buch ist zur Vorbereitung der MCPD Zertifizierung 70-519 geschrieben worden. Entsprechend deckt es die Themen für die Zertifizierung sehr gut ab, geht aber nicht darüber hinaus.

Aufbau

Das Buch folgt genau dem Prüfungsumfang. So genau dass sowohl die Hauptkapitel wie auch die Unterkapitel gleich benannt wurden wie auf der Prüfungsseite. Dies hilft einerseits beim finden des entsprechenden Kapitels, andererseits ist das Buch so recht zerstückelt. Um zu verstehen wie die einzelnen Teile zusammenarbeiten muss man zwingend das ganze Buch lesen.

Am Ende jedes Unterkapitels gibt es eine Zusammenfassung und Fragen zum gerade behandelten Thema. Bei den Fragen sollte man nicht nur auf die Fragen an sich achten, sondern auch auf das Szenario in das die Fragen eingebettet sind. Ein genaues Lesen der Beschreibung macht das Beantworten der Fragen deutlich einfacher.

Inhalt

Die Themen werden entsprechend der Stufe MCPD auf einer höheren Abstraktionsebene behandelt als bei den Training-Kits für die Technology Specialist Zertifizierungen. Hier geht es mehr darum zu wissen was es für verschiedene Caching-Möglichkeiten gibt als wie man diese aktiviert. Das man auch die Details kennt hat man ja bereits mit den TS-* Zertifizierungen bewiesen.

Behandelt wird alles vom Strukturieren einer Anwendung bis zur passenden Deployment Strategie in diesen 6 Kapiteln:

Design application architectures
Design the user experience
Design data strategies and structures
Design a security architecture and implementation
Prepare for and investigate application issues
Design a deployment strategy

Was fehlt

Für die Zertifizierung hat das Buch alles wesentliche abgedeckt. Dort wo es mir an praktischer Erfahrung fehlte oder wo ich bedarf nach einer detaillierteren Erklärung hatte half mir das MSDN weiter.

Um das Buch für etwas anderes als die Prüfungsvorbereitung zu nutzen fehlt allerdings recht viel. Neben den geprüften Technologien werden keinerlei Informationen über Alternativen genannt. Wer nur dieses Buch hat und damit Lösungen aufbauen will wird so einiges verpassen.

Fazit

Für die Prüfungsvorbereitung ist dieses Buch eine sehr gute Wahl. Man bekommt alles notwendige um sich solide vorzubereiten. Man muss sich aber im klaren sein das Alternativen wie NHibernate oder Log4net mit keinem Wort erwähnt werden. Der Nutzen über die Zertifizierung hinaus ist dadurch doch recht limitiert.

Zum Buch

“MCPD 70-519 Exam Ref: Designing and Developing Web Applications Using Microsoft .NET Framework 4” von Tony Northrup, 2011 Microsoft Press, ISBN 978-0-7356-5726-7, 304 Seiten, Englisch

Einsortiert unter:.Net, Bücher, webDotNet, webRead Tagged: .Net, Bücher, C#, Zertifizierung

Schritt für Schritt zum eigenen generischen Repository

schaedlerdaniel — Wed, 28 Mar 2012 09:41:43 Z

Das Speichern und Abfragen von Daten wäre mit dem klassischen Repository-Pattern viel zu aufwändig für kleinere Projekte. In Anlehnung an das hier, in Verbindung mit dem Unit Of Work Pattern, verwendete generische Repository, habe ich mir überlegt, dass es doch für kleinere Projekte auch eine Lösung geben sollte, die nicht so viel Aufwand nach sich zieht.

Als Grundlage, oder besser gesagt als Ausgangspunkt habe ich mir diesen Artikel zur Brust genommen.

Wie wollen wir vorgehen?

Wir erstellen uns ein ganz triviales Model (Adressverwaltung)
Dann erstellen wir uns Schritt für Schritt das Repository
Am Schluss ziehen wir noch ein Fazit aus dem Artikel

Erstellung des Models

In Anbetracht, dass nicht zwingend die Korrektheit der Datenmodellierung und der verwendeten Typen im Mittelpunkt steht, erstellen wir uns das Modell wie folgt.

Wichtig an diesem Punkt ist, dass die Pluralisierung nicht geändert wird (hierzu später mehr bei der Erstellung des Repositories). Die Eigenschaften für die Personen-Entität sind hier represäntativ für alle anderen auch.

Eine Spezialität ist die komplexe Eigenschaft Persistance, welch die Attribute für

CreateDate
ModifyDate
Creator
Modifier

beherbergt. Schön wäre es ja, wenn alle Attribute bei der entsprechenden Operation des Repositories, Add, Update automatisch aktualisiert wird (dazu später mehr).

Soweit so gut, wir haben unsere Modell für die 1001 Adressverwaltung erstellt. Wollen wir doch zum nächsten Schritt übergehen, die Erstellung des Repositories.

Die Repository Erstellung

Damit wir mit unserem Repository die CRUD Operation unterstützen können brauchen wir folgende Methoden:

Rumpf des Repositories
Add
Remove
Update
GetObjectById
GetObjectByQuery
Persistance Attribute automatisch erstellen /aktualisieren

Rumpf des Repositories

Damit wir die restlichen Methoden implementieren können müssen wir das Repository wie folgt erstellen:

namespace GenericRepositoryPattern
{
    public class Repository<T> : IDisposable where T: EntityObject
    {
        /// <summary>
        /// The context of the database.
        /// </summary>
        private readonly AddressModelContainer context;
        /// <summary>
        /// The related objectSet to the context. Is dependent
        /// of the context.
        /// </summary>
        private readonly ObjectSet<T> objectSet;
        /// <summary>
        /// Constructor to initialize the context and the
        /// objectSet.
        /// </summary>
        /// <param name="context">The context of the model.</param>
        public Repository(AddressModelContainer context)
        {
            this.context = context;

            if (context != null) 
            { 
                this.objectSet = context.CreateObjectSet<T>();
                this.context.SavingChanges +=new EventHandler(context_SavingChanges);
            }
        }

(Anmerkung: Die Wiedergabe des Code’s ist gekürzt).
Wichtig hierbei ist, dass der Context von aussen her dem Konstruktor übergeben werden muss und das ObjectSet vom instantiierten Context das ObjectSet erhält.

Add Methode

Damit wir ein neues Objekt zu unserem ObjectContex hinzufügen können müssen wir die Methode wie folgt implementieren.

        /// <summary>
        /// Add's a newly created entity to the
        /// objectSet
        /// </summary>
        /// <param name="entity">The newly created entity.</param>
        public void Add(T entity)
        {
            this.objectSet.AddObject(entity);            
            this.context.SaveChanges();                    
        }

Also eine ganz einfache Sache. Als nächstes wenden wir uns der Remove Methode zu.

Remove Methode

Das Entfernen eines Objektes ist relativ rasch implementiert:

        public void Remove(T entity)
        {
            if (entity != null)
            {
                this.objectSet.Attach(entity);
                this.context.DeleteObject(entity);
                this.context.SaveChanges();
            }
        }

Also keine Hexerei. Als nächstes wenden wir uns der Update Methode zu und schauen diese genauer an.

Update Methode

Die Update Methode zeigt sich in ihrer Ausprägung so:

        public void Update(T entity)
        {
            this.objectSet.Attach(entity);
            this.context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);        
            this.context.SaveChanges();
        }

Damit der Context weiss, dass sich was geändert hat muss die Entität an den Context wieder „Attached“ und im ObjectStateManager der EntityState auf Modified gestellt werden. Dann speichert der Context die Daten aktualisiert.

GetObjectById

Damit wir ein Object vom Typ Person erhalten, anhand der übergebenen Id, erstellen wir uns in der Methode einen EntityKey und einem KeyValuePair. Das Attribut dass die Id verkörpert heiss auch „Id“.

        public T GetById(Int32 id)
        {
            string entitySet = string.Format(@"{0}Set", typeof(T).Name);
            KeyValuePair<string, object> member = new KeyValuePair<string, object>("Id", id);
            IEnumerable<KeyValuePair<string, object>> values = new KeyValuePair<string, object>[] { member };

            EntityKey key = new EntityKey(entitySet, values);

            return (T)this.context.GetObjectByKey(key);
        }

Und hier sehen wir auch wieso wir die Pluralisierung PersonSet belassen haben. Damit der Context weiss in welchem Set er suchen soll müssen wir dieses übergeben. Das erreichen wird mit dem kleinen Codeschnipsel

string entitySet = string.Format(@"{0}Set", typeof(T).Name);

Danach wird der EntityKey erstellt und dem Context zur Abfrage übergeben. Das gefundene Object casten wird dann in den generischen Typ den wir übergeben haben.

GetObjectByQuery

Damit wir spezifisch ein Objekt, oder auch mehrere zurück erhalten können wir diese mit dem entsprechenden Methode und einer Func zurück holen. Als Beispiel: Wenn ich eine Person haben möchte bei welchem ich nur den Vornahmen und den Nachnamen haben möchte, dann lege ich beim Aufrufer der Methode folgende Funktion fest:

Func<Person, bool> functionPerson = person => person.FirstName.ToLower().Equals("hans");

Die kann dann der Methode übergeben werden und diese erstellt dann auch das Resultat anhand der übergebenen Methode.

        public IEnumerable<T> GetObjectByQuery(Func<T, bool> customQuery)
        {
            if (customQuery == null)
            {
                throw new ArgumentNullException("parameter: customquery must be given by caller!");
            }

            List<T> result = this.objectSet.Where(customQuery).ToList();
            result.ForEach(this.objectSet.Detach);
            return result;
        }
[/csharp]
<p>Wichtig ist nur, dass die gefundenen Objekte vom Context getrennt werden, damit diese auch ausserhalb der Verwendung des Contextes verwendet werden können.</p>
<h6>Persistance Attribute aktualisieren</h6>
<p>Dem Leser wird nicht entgangen sein, dass im Konstruktor der Context mit seinem Ereignis SavingChanges verknüpft worden ist. Hier werden alle relevanten Attribute vom komplexen Property IPersistance aktualisiert oder erstellt. Die Ereignisbehandlung sieht dann so aus:</p>
[code language="csharp"]
        void context_SavingChanges(object sender, EventArgs e)
        {
            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Added).ToList().ForEach(entity => {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    IPersistance persistance = CreatePersistance();
                    entity.Entity.GetType().GetProperty("Persistance").SetValue(entity.Entity, persistance, null);
                }
            });

            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Modified).ToList().ForEach(entity =>
            {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    UpdatePersistance(entity.Entity);
                }
            });
        }

Hier wird eigentlich nicht’s anderes gemacht, als das alle Entitäten die den Status Added oder Modified haben das Persistance komplexe Property angepasst. Für das sind dann die zwei Methoden zuständig.

        private IPersistance CreatePersistance()
        {
            IPersistance persistance = new IPersistance();
            persistance.CreateDate = DateTime.Now;
            persistance.ModifyDate = DateTime.Now;
            persistance.Creator = WindowsIdentity.GetCurrent().Name;
            persistance.Modifier = persistance.Creator;
            return persistance;
        }

Wird verwendet wenn eine neue Entität persistiert wird und die nachfolgende wenn eine Entität geändert worden ist.

        private void UpdatePersistance(object entity)
        {
            if (typeof(T).GetProperty("Persistance") != null)
            {
                IPersistance persistance = (IPersistance)typeof(T).GetProperty("Persistance").GetValue(entity, null);
                if (persistance != null)
                {
                    persistance.Modifier = WindowsIdentity.GetCurrent().Name;
                    persistance.ModifyDate = DateTime.Now;
                }
            }
        }

Zur Übersicht noch der vollständige Code des gesamten Repositories.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.Objects.DataClasses;
using GenericRepositoryPattern.Model;
using System.Data.Objects;
using System.Data;
using System.Security.Principal;
using System.Reflection;

namespace GenericRepositoryPattern
{
    /// <summary>
    /// Generic repository.
    /// </summary>
    /// <typeparam name="T">For example it could be a model entity Person</typeparam>
    public class Repository<T> : IDisposable where T: EntityObject
    {
        /// <summary>
        /// The context of the database.
        /// </summary>
        private readonly AddressModelContainer context;
        /// <summary>
        /// The related objectSet to the context. Is dependent
        /// of the context.
        /// </summary>
        private readonly ObjectSet<T> objectSet;
        /// <summary>
        /// Constructor to initialize the context and the
        /// objectSet.
        /// </summary>
        /// <param name="context">The context of the model.</param>
        public Repository(AddressModelContainer context)
        {
            this.context = context;

            if (context != null) 
            { 
                this.objectSet = context.CreateObjectSet<T>();
                this.context.SavingChanges +=new EventHandler(context_SavingChanges);
            }
        }
        /// <summary>
        /// Get's a specific entity by it's key.
        /// </summary>
        /// <param name="id">The id from the object to retrieve.</param>
        /// <returns>The object if it's present in the db, or NULL if not existent.</returns>
        public T GetById(Int32 id)
        {
            string entitySet = string.Format(@"{0}Set", typeof(T).Name);
            KeyValuePair<string, object> member = new KeyValuePair<string, object>("Id", id);
            IEnumerable<KeyValuePair<string, object>> values = new KeyValuePair<string, object>[] { member };

            EntityKey key = new EntityKey(entitySet, values);

            return (T)this.context.GetObjectByKey(key);
        }
        /// <summary>
        /// Allows the user to query the db with a custom
        /// function to retrieve data from the specific type
        /// of entity.
        /// </summary>
        /// <param name="customQuery">Created outisde by caller</param>
        /// <returns>A queryable of T with the possibility to treat it further.</returns>
        /// <example>
        /// Func<Person, bool> functionPerson = person => person.FirstName.ToLower().Contains("da")
        /// </example>
        public IEnumerable<T> GetObjectByQuery(Func<T, bool> customQuery)
        {
            if (customQuery == null)
            {
                throw new ArgumentNullException("parameter: customquery must be given by caller!");
            }

            List<T> result = this.objectSet.Where(customQuery).ToList();
            result.ForEach(this.objectSet.Detach);
            return result;
        }

        /// <summary>
        /// Updates the values of the entity.
        /// </summary>
        /// <param name="entity">Updates a given entity with new values.</param>
        public void Update(T entity)
        {
            this.objectSet.Attach(entity);
            this.context.ObjectStateManager.ChangeObjectState(entity, EntityState.Modified);        
            this.context.SaveChanges();
        }
        /// <summary>
        /// Add's a newly created entity to the
        /// objectSet
        /// </summary>
        /// <param name="entity">The newly created entity.</param>
        public void Add(T entity)
        {
            this.objectSet.AddObject(entity);            
            this.context.SaveChanges();                    
        }
        /// <summary>
        /// Occurs every time an entity is saved or updated.
        /// It goes through the entity properties to update or craete
        /// the persistance attributes that are necessary for saving.
        /// </summary>
        /// <param name="sender">The context</param>
        /// <param name="e">The eventargs from the context.</param>
        void context_SavingChanges(object sender, EventArgs e)
        {
            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Added).ToList().ForEach(entity => {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    IPersistance persistance = CreatePersistance();
                    entity.Entity.GetType().GetProperty("Persistance").SetValue(entity.Entity, persistance, null);
                }
            });

            this.context.ObjectStateManager.GetObjectStateEntries(EntityState.Modified).ToList().ForEach(entity =>
            {
                if (entity != null && entity.Entity != null && entity.Entity.GetType().GetProperty("Persistance") != null)
                {
                    UpdatePersistance(entity.Entity);
                }
            });
        }
        /// <summary>
        /// Set's the createdate to the datetime
        /// where the creation of the entity
        /// object has been executed.
        /// </summary>
        /// <param name="entity">The entity to create the IPersistance creator and update attributes.</param>
        private IPersistance CreatePersistance()
        {
            IPersistance persistance = new IPersistance();
            persistance.CreateDate = DateTime.Now;
            persistance.ModifyDate = DateTime.Now;
            persistance.Creator = WindowsIdentity.GetCurrent().Name;
            persistance.Modifier = persistance.Creator;
            return persistance;
        }
        /// <summary>
        /// Set's the modifydate to the datetime
        /// where the modification of the entity
        /// object has been executed.
        /// </summary>
        /// <param name="entity">The entity to update the IPersistance modify attributes.</param>
        private void UpdatePersistance(object entity)
        {
            if (typeof(T).GetProperty("Persistance") != null)
            {
                IPersistance persistance = (IPersistance)typeof(T).GetProperty("Persistance").GetValue(entity, null);
                if (persistance != null)
                {
                    persistance.Modifier = WindowsIdentity.GetCurrent().Name;
                    persistance.ModifyDate = DateTime.Now;
                }
            }
        }
        /// <summary>
        /// Removes an entity from the database.
        /// </summary>
        /// <param name="entity">The entity to remove. Must be loaded prior to remove.</param>
        public void Remove(T entity)
        {
            if (entity != null)
            {
                this.objectSet.Attach(entity);
                this.context.DeleteObject(entity);
                this.context.SaveChanges();
            }
        }

        #region IDisposable Members
        /// <summary>
        /// Dispose the context.
        /// </summary>
        public void Dispose()
        {
            if (this.context != null)
            {
                this.context.Dispose();
            }
        }

        #endregion
    }
}

Fazit

Mit dem hier vorgestellten Ansatz ist es uns , auch für kleinere Projekte möglich, rasch und einfach CRUD Methoden zur Verfügung zu stellen ohne, dass wir das Unit of Work und das Repositoriy Pattern in ihren grössten Ausprägungen implementieren müssen.

Wenn Ihnen der Artikel gefallen hat, würde ich mich über einen KICK freuen. Auf Verbesserungsvorschläge und Kritik bin ich natürlich auch offen.

What the hell is PowerShell mit Thomas Krause

Tue, 27 Mar 2012 18:00:00 +0200

.NET User Group Bern Event

Dienstag, 27. März 2012 (18:00 bis 21:00 Uhr)

What the hell is PowerShell?

Im März wird uns Thomas Krause das Thema Powershell näher bringen. Pirmär werden wir uns auch damit beschäftigen wie der Administrative Teil einer Anwendung effizienter gestaltet werden kann.

Abstract

Das Windows Management Framework - aka PowerShell - wird immer wichtiger, daran besteht kein Zweifel. Egal, ob Desktop, Server oder Cloud: Kaum ein Produkt, das nicht mit PowerShell-Administrations-Features daherkommt. Windows 8 wird das Thema Administration/Konfiguration mit PowerShell noch mehr in den Mittelpunkt rücken. Es wird also Zeit, sich auch als Entwickler damit auseinanderzusetzen.

PowerShell ist nicht nur das schmucklose Terminal-Fenster, mit dem man wahrscheinlich den Erstkontakt hat. Es ist vor allem eine universelle Automatisierungsengine fuer alle denkbaren taeglichen Aufgaben - und somit interessant fuer jeden, der einfach effektiver arbeiten moechte.

Inzwischen existiert ein gut ausgebautes Oekosystem an Tools und Erweiterungen. Wir werfen einen Blick auf das, was mit PowerShell heute fuer Administratoren und Entwickler moeglich und sinnvoll ist und schauen uns an, was uns mit PowerShell V3 erwartet.

Eine Reihe Beispiele werden zeigen, wie man mit PowerShell Werkzeuge nutzt, erweitert und baut. Wie kann ich mit PowerShell Entwicklungaktivitäten automatisieren? Wie bringt man PowerShell und ein GUI zusammen? Wie kann die eigene Applikation mit der PowerShell besser administrierbar werden? Diese Fragen werden wir nach dem Motto 'Less Slides, more Code' beantworten.

Über Thomas Krause

Neben meinem Leben als Mainstream-Entwickler mit Mainstream-Programmiersprachen (ObjectPascal, C++, .NET/C#) war ich lange auch auf der 'dunklen Seite der Softwareentwicklung' unterwegs - Datenbankentwicklung (PL/SQL, T-SQL, SQL etc.). Mit der Zeit lenkte dies meine Aufmerksamkeit auf 'unsichtbare' Themen wie Backup, Troubleshooting, Konfiguration, Migration, Monitoring etc.

Das interessante Spannungsdreieck zwischen Datenbank-Entwicklern, Administratoren und 'Client'-Entwicklern wurde eines meiner Interessengebiete. Seit dem Erscheinen der PowerShell 2006 suche ich intensiver nach Praktiken und Konzepten für die Entwicklung besser administrierbarer Systeme. Wichtig ist mir, Administrations-Anforderungen schon beim Systemdesign zu berücksichtigen.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbeps1.

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

Empfehlenswerte Podcasts rund um Ruby

Johnny Graber — Sat, 24 Mar 2012 10:45:22 Z

Das Ökosystem rund um Ruby entwickelt sich sehr schnell. Dies zeigt dass sich viele Leute dafür interessieren und auch mit der Sprache arbeiten. Wenn man aber erst daran ist sich in Ruby einzuarbeiten ist dies eine Herausforderung. Sobald man für ein Problem eine Lösung gefunden hat stösst man auf einen Blogpost der vom verwendeten Gem abrät oder man sieht eine viel einfachere Lösung.

Um auf dem Laufenden zu bleiben haben sich für mich Podcasts als sehr hilfreich erwiesen. Da ich wohl nicht der einzige bin der versucht sich in Ruby zu Recht zu finden möchte ich hier einige Podcasts vorstellen.

Ruby 5
Jeweils am Dienstag und Freitag liefert Ruby 5 eine kurze Übersicht zu den wichtigsten News rund um Ruby, Rails und hilfreiche Gems. Die Folgen dauern im Schnitt 5 Minuten und nennen die wichtigsten Punkt der Änderungen. In 5 Minuten bleibt keine Zeit um Details zu liefern, dafür ist es aber kurz und man braucht nicht viel eigene Zeit zu investieren.

The Ruby Show
Jeden Freitag wird eine Folge von “The Ruby Show” veröffentlicht. In 20 – 30 Minuten wird detailliert auf die News der Woche eingegangen. Die Themen sind oft ähnlich wie bei Ruby 5, werden aber mit mehr Tiefe behandelt.

Railscasts
Ryan Bates veröffentlicht jede Woche kurze Videos (10 – 15 Minuten) rund um Ruby on Rails. Thematisch variieren diese Videos vom Aktualisieren von Rails über Authentifizierung bis zu JavaScript. Ausgangslage ist immer eine Rails basierte Anwendung die um neue Funktionen ergänzt werden soll.

Wem die Videos gefallen kann für 9$ pro Monat jede Woche zwei zusätzliche Videos haben. Gerade die aktualisierten Folgen sind sehr praktisch, da in der Zwischenzeit oft sehr viel geändert hat.

Ruby Rogues
Ruby Rouges ist eine wöchentliche Diskussion rund um Ruby. Ich fand diesen Podcast zuerst ein wenig gewöhnungsbedürftig. Mir schien es ein wildes Durcheinander zu sein. Mit der Zeit gewöhnt man sich aber daran und erkennt das grosse Wissen der Teilnehmer.

Jede Folge hat ein Hauptthema und daraus entwickelt sich jeweils schnell eine angeregte Diskussion. Dabei können dann die unterschiedlichsten Punkte diskutiert werden.

Soweit die Podcasts die ich häufig höre. Falls jemand weitere Podcasts empfehlen kann würde ich mich über einen Kommentar freuen.

Einsortiert unter:webRuby Tagged: Ruby

Sharepoint Deployment API zwischen Version 2007 und 2010

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Thu, 15 Mar 2012 22:54:00 +0200

Meine Migrationsstory geht weiter. Nachdem der Export vorlag, stand ich das erste Mal an, weil mich bei einem Testimport die Fehlermeldung: The version of the package 12.0.10.0 is different from the current version this program supports, 14.0.0.0 begrüsste. Nach ein bisschen suchen fand ich einen Ansatz. Die Package Files, speziell die SystemData.xml muss angepasst werden, damit sich der Inhalt aus Sharepoint 2007 in Sharepoint 2010 importieren lässt. In der XML-Datei muss dazu auf SchemaVersion-Ebene die Version, dass aktuelle Patchlevel (Build) und die Datenbankversion (DatabaseVersion) angegeben werden. Nachfolgendes XML zeigt einen Ausschnitt aus der SystemData.xml:

70-515 Zertifizierung vorbereiten mit CampusMVP von Krasis

Johnny Graber — Sun, 11 Mar 2012 18:32:32 Z

Das Training Kit von Microsoft Press konnte mich als Vorbereitung für die Zertifizierung 70-515 (Web Applications Development) nicht überzeugen. Daher kam mir die Anfrage ob ich nicht einen Online-Training reviewen möchte gerade recht.

Krasis ist eine Firma die seit Jahren Kurse in Spanisch anbietet und nun ihr Angebot um englischsprachige Kurse erweitert. Ich durfte den Kurs zur Vorbereitung der 70-515 Zertifizierung während 2 Monaten eingehend testen. Als Gegenleistung wurde nur erwartet das ich geradeheraus meine Meinung zum Kurs und der Trainingsmethode blogge. Dies zur Offenlegung meiner Verbindung zu Krasis.

Kursaufbau

Das praktische an einem webbasierten Training ist das man sich die Zeiten selber einteilen kann. Wenn man aber keine fixen Zeiten hat gibt es immer etwas was man sonst noch erledigen muss und so zieht sich der Kurs schnell einmal in die Länge. Dies weiss auch Krasis und empfiehlt daher für den 70-515 Kurs dieses Zeitraster:

Modul	Wochen
ASP.Net 4.0 Web Forms	6
ASP.Net AJAX	2
jQuery	1
ASP.Net MVC	1
MeasureUp Test	2
Total:	12

Mit dieser Planung füllt man die 3 Monate die man den Kurs nutzen kann voll aus und ist am Ende bereit für die Zertifizierung. Wem dieses Raster nicht gefällt oder mehr Zeit für jQuery oder ASP.Net MVC haben möchte kann nach Belieben bei den anderen Modulen weniger Zeit verbringen.

Steckt man einmal bei einem Thema fest oder hat sonstige Fragen kann man sich an einen Trainer wenden. Für diesen Kurs ist dies Jose Alarcón, Autor mehrerer Bücher über ASP.Net und zertifizierter Microsoft-Trainer. Ich fand den Kurs verständlich und konnte problemlos folgen, daher habe ich von dieser Möglichkeit keinen Gebrauch gemacht.

Web Forms

Der Kurs orientiert sich an den in der Zertifizierung geprüften Themen. Der grösste Teil widmet sich daher Web Forms. Nach jeweils einer Seite Text folgt ein Video das die Theorie aufnimmt und ihre praktische Anwendung zeigt. Der gleichmässige Wechsel von lesen und anschauen fand ich sehr angenehm.

Bis man sich selber an die Übungen in Visual Studio macht hat man mehrmals gezeigt bekommen wo die behandelten Controls liegen und wie man damit arbeiten kann. Dies ist gerade für Einsteiger sehr hilfreich, da man sich so bei den Übungen auf die Aufgabe konzentrieren kann und nicht an Visual Studio scheitert.

Um selber aktiv zu werden kann man die gezeigten Beispiele nachprogrammieren und die grösseren Übungen am Ende der Module lösen. Auch hier kann man selber entscheiden wo man wie viel Zeit aufwenden will.

ASP.Net AJAX und jQuery

Das Ajax Control Toolkit von Microsoft bietet einige interessante Funktionen im Zusammenspiel mit Web Forms. Wenn auch die Zukunft dieses Toolkits ungewiss ist, so muss man für die Zertifizierung doch etliche Details kennen. Leider konnte mich dieses Modul nicht ganz überzeugen. Die Texte waren zwar gut geschrieben, doch zeigten die Videos nur genau das was man auf der vorderen Seite lesen konnte. Im Gegensatz zu den anderen Modulen wurde hier Visual Studio 2008 gezeigt und auch die Tonqualität war deutlich schlechter als sonst. Es scheint als ob hier ein Modul aus einem älteren Kurs wiederverwendet wurde.

Das Modul zu jQuery hätte von mir aus gerne tiefer gehen können. Es werden alle prüfungsrelevanten Themen behandelt und die Übersicht zu allen möglichen Selektoren ist sehr gut. Dennoch hätte man Themen wie die Fehlerbehandlung bei AJAX-Aufrufen oder die Kombination mit WebMethods noch ausführlicher zeigen können.

ASP.Net MVC

Wie wohl alle Erklärungen zu MVC wird auch hier erst einmal die einzelnen Teile (Modell, View und Controller) erklärt. Auch wenn ich dies bereits mehrmals gelesen, gehört und gesehen habe, so gab es auch hier Neues zu entdecken:

Diese Grafik ist nur ein Beispiel von vielen. In fast allen Erklärungen wird das Zusammenspiel von Modell, View und Controller immer reduziert auf diese 3 Teile gezeigt. Krasis zeigt für einmal auch den Benutzer und wie dieser mit einer MVC-Anwendung arbeitet. Ist man erst am Einstieg in MVC ist diese Grafik deutlich verständlicher als eine reine textuelle Beschreibung der Abläufe.

MeasureUp als hilfreicher Zusatz

Der Fragenkatalog bei Krasis kommt nicht wirklich an die Prüfungsfragen heran. Daher sollte man sich auf jeden Fall noch die Fragebogen von MeasureUp dazu kaufen. Dessen Fragen sind nicht nur näher an der Prüfung, sondern es wird auch erklären was bei den falschen Antworten nicht korrekt ist.

Kosten

Der Kurs hat seinen Preis und der scheint auf den ersten Blick hoch zu sein. Vergleicht man diesen aber mit dem Preis eines mehrtägigen Kurses von anderen Anbietern ist er moderat. Wo kann man sonst während 3 Monaten auf eine Zertifizierung hin lernen und hat bei Fragen einen Experten auf Abruf?

Bis Ende März gibt es alle Kurse mit einem 50% Einführungsrabatt. Wer interessiert ist sollte nicht zu lange warten.

Fazit

Krasis bietet einem ein gutes Konzept zum nachhaltigen Wissensaufbau. Obwohl ich seit Jahren ASP.Net nutze konnte ich schon bei den ersten Seiten etwas Neues lernen. Viele Themen begegnen einem zwar im täglichen Einsatz, doch stellt man sich oft nicht so detaillierte Fragen wie man es für die Zertifizierung muss.

Der Kurs ist gut gelungen und liefert mir das nötige Wissen um die Zertifizierung 70-515 zu bestehen. Obwohl es bei AJAX einige Schwächen gibt kann ich den Kurs weiterempfehlen.

Einsortiert unter:.Net, webDotNet Tagged: .Net, C#, Zertifizierung

Parallelisierung wenn eine relationale Datenbank im Spiel ist

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sat, 10 Mar 2012 23:09:00 +0200

Nachdem ich mir das erste Mal eine CLR-Funktion für eine Datenmigration gebaut habe, geht es nun daran Codeteile zu parallelisieren, damit die Migrationsdauer verkürzt werden kann. Ein paar Herausforderungen dabei: Ich habe die Auflage das Ganze in .NET 3.5 zu entwickeln, sodass ich die TPL nicht nutzen kann.Direkte Insert, Update und Delete-Anweisungen dürfen nicht ausgeführt werden. Es muss die Sharepoint Content Deployment API verwendet werden. Im Blogpost fand ich einen interessanten Ansatz, wie in .NET 3.5 eine parallele Schleife realisiert werden kann. Also den ersten Test erstellt. Eine Stub-Methode die 10 Sekunden wartet, geschrieben und 5-mal aufgerufen. Testkriterium: Ausführungsdauer weniger als 15 Sekunden bestehen, funktioniert. Anschliessend den integrativen Test in Verbindung mit einer Datenbank. Testkriterium: Auditinformationen in Datenbank schreiben nicht erfüllt, tatsächlich: Transaction (Process ID XX) was deadlocked on lock | communication buffer resources with another process and has been chosen as the deadlock victim. Rerun the transaction. at System.Data.SqlClient.SqlConnection.OnError(SqlException exception, Ein Codestück, das die Verbindung zur Datenbank herstellt, hat folgenden Aufbau:

SQL Server - Indexfragmentierung feststellen

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Wed, 07 Mar 2012 14:29:00 +0200

Bei sehr vielen Einfügeoperationen kann ein Index sehr schnell seine Wirkung verlieren und muss entweder reorganisiert oder neu erstellt werden. Da ich die Abfrage des öfteren brauche, lege ich diese mal hier ab:

Mein Einstieg in Kanban

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Tue, 06 Mar 2012 23:26:00 +0200

Zukünftig will ich verstärkt mit der Unterstützung von Kanban arbeiten. Primär erhoffe ich mir Vorteile im Bereich der ständigen Verbesserung, Entwicklungseffizienz und der Lokalisierung von Zeitfressern, sowie ein nützliches Hilfsmittel für "Continuous Delivery". Seit knapp 3 Wochen visualisiere ich so meine Arbeit und versuche anhand des Value Stream Mapping die Effizienz zu ermitteln. Innerhalb der nächsten Wochen werde ich wohl ein paar tiefere Einblicke haben. Ein grober Überblick befindet sich in folgendem Mind Map.

Sharepoint 2010 Best Practices

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Wed, 29 Feb 2012 22:03:00 +0200

Sharepoint gehört immer noch zu meinen Aufgabengebieten. Gute Anleitungen zu finden ist auch nicht einfach, gerade im Bezug was man tun oder lassen sollte. Das Produktteam hat eine Übersicht mit Best Practices unter dem Link bereitgestellt. Mal sehen, ob es brauchbar ist... Weitere Informationen zum Thema: Bewährte Methoden für Sharepoint FoundationBewährte Methoden für Sharepoint (sehr dürftig)

WCF DataContracts synchronisieren mit Entity Framework Klassen

schaedlerdaniel — Tue, 28 Feb 2012 15:32:33 Z

Im Rahmen einer Projektarbeit haben wir das Ziel Businessdaten über die WCF zu transportieren. Die Daten sind im Entity Framework gespeichert. Schön wäre es wenn wir diese Entitäten direkt über den Kommunikationskanal schicken könnten. Leider ist dies nicht möglich da ein direktes Versenden der Entitäten, durch Projektrestriktionen nicht erlaubt ist, oder man ganz einfach keine Referenzen auf dem Client auf den Namespace System.Data haben möchte.

Also muss eine Lösung her die einigermassen hilfreich sein kann. Diese Lösung erledigt das Mapping eines einkommenden DatenVertrages mit der entsprechenden Entität.

Vorbereitungen

AddressManagement.BusinessModel
AddressManagement.PersistanceModel
AddressManagement.ServiceLayer

Für das Hosten der WCF können wir verschiedene Möglichkeiten nutzen, die aber in diesem Blogpost nicht abgedeckt werden. Es soll nur die Möglichkeit einer generischen Mapping Methode aufgezeigt werden, damit die Daten vom Entity Framework nicht direkt über den Kommunikationskanal versendet werden müssen, sondern gekapselt werden.

Wir erstellen uns ein Entity-Modell dass wie folgt aussieht: (Dieses erstellen wir im Projekt AddressManagement.Persistance)

Anschliessend erstellen wir uns unseres eigentliche Businessklassenmodell welches wir im Projekt AddressManagement.BusinessModel anlegen.

Das Businessklassen Model

Wichtig hierbei ist, dass die Beziehungen, Phones, Addresses genau gleich heissen wie im Entity Model. Auch alle anderen Eigenschaften müssen die gleiche Schreibweise haben, da sonst im Mapper keine Übereinstimmung gefunden wird.

Die Businessklassen sollen dann mit der WCF übertragen werden. Hierzu werden die Klassen mit den entsprechenden Attributen versehen.

Die Klasse Person

namespace AddressManagement.BusinessModel
{
    [DataContract]
    [KnownType(typeof(Address))]
    [KnownType(typeof(Phone))]
    public class Person : IPersistance
    {        
        #region IPersistance Members
        [DataMember]
        public Int32 Id { get; set; }
        #endregion
        [DataMember]
        public string FirstName { get; set; }
        [DataMember]
        public string LastName { get; set; }
        [DataMember]
        public IEnumerable<IPersistance> Addresses { get; set; }
        [DataMember]
        public IEnumerable<IPersistance> Phones { get; set; }
    }
}

Die Klasse Phone

namespace AddressManagement.BusinessModel
{
    [DataContract(IsReference = true)]
    [KnownType(typeof(ObjectType))]
    public class Phone : IPersistance
    {
        #region IPersistance Members
        [DataMember]
        public Int32 Id { get; set; }
        #endregion
        [DataMember]
        public string SubScriberNumber { get; set; }
        [DataMember]
        public ObjectType PhoneType { get; set; }
    }
}

Die Klasse Address

namespace AddressManagement.BusinessModel
{
    [DataContract(IsReference = true)]
    [KnownType(typeof(ObjectType))]
    public class Address : IPersistance
    {
        #region IPersistance Members
        [DataMember]
        public Int32 Id { get; set; }
        #endregion
        [DataMember]
        public string StreetName { get; set; }
        [DataMember]
        public Int16 StreetNumber { get; set; }
        [DataMember]
        public Int16 PostalCode { get; set; }
        [DataMember]
        public string CityName { get; set; }
        [DataMember]
        public ObjectType AddressType { get; set; }
    }
    [DataContract]
    public enum ObjectType
    {
        [EnumMember]
        Private,
        [EnumMember]
        Business
    }
}

Der Mapper/Synchronisierer

Damit wir nun beide Welten miteinander abgleichen können ist der Mapper zu erstellen, welche ich Schritt für Schritt erläutere. Wir erstellen uns als erstes eine Statische Klasse mit dem Namen DataContractToEntityMapper oder DataContractAndEntitySynchronizer und erstellen als erstes folgende Methode:

        /// <summary>
        /// Maps a given datacontract to the appropriate entity.
        /// Check's if the datacontract is new or must be updated
        /// and return the newly persisted contract back or it's updated
        /// values, if it was already persisted before.
        /// </summary>
        /// <typeparam name="T">Type of the datacontract</typeparam>
        /// <typeparam name="U">Type of the entity</typeparam>
        /// <param name="dataContract">The datacontract to interact with.</param>
        /// <returns>A new or updated datacontract from the database.</returns>
        public static IPersistance SynchronizeDataContractAndEntity<T, U>(T dataContract)
            where T : IPersistance
            where U : EntityObject
        {
            IPersistance persistance = Activator.CreateInstance<T>();
            // 1. a) Determine if the datacontract is already persisted.
            if (dataContract.Id == 0)
            {
                // 1. b) Map the newly created entity to the datacontract.                
                PersistDataContract<T, U>(dataContract);
            }
            else
            // 2.) Map an existing entity to it's datacontract pendant
            {
                U persistedEntity = Activator.CreateInstance<U>();
                using (AddressRepository<U> repository = new AddressRepository<U>(new AddressManagementPersistanceModelContainer()))
                {
                    persistedEntity = repository.GetByKey<U>(dataContract.Id);
                    persistance = UpdateProperties<T, U>(dataContract, persistedEntity);
                }
            }
            return persistance;
        }

Diese Methode führ folgende Aktionen durch:

Existiert der eingetroffene DataContract schon in der Datenbank?
Ist die Id 0, dann muss eine neue Entität angelegt werden
Ist die Id > 0 ist der Contract bereits in der Datenbank vorhanden und muss mit den vorliegenden Werten aktualisiert werden.
Zum Schluss, nachdem die Entity und der DataContract miteinander synchronisiert worden sind, wird ein aktualisierter DataContract zurück gegeben.

Als nächster Schritt erstellen wir uns eine Methode die für den Abgleich der Property-Werte zuständig ist. Diese unterscheidet ob es sich bei der Eigenschaft um eine Collection oder um eine einfache Eigenschaft handelt und führt dementsprechend die Aktualisierung aus:

        /// <summary>
        /// Updates the properties from a datacontract.
        /// </summary>
        /// <typeparam name="T">The type of datacontract</typeparam>
        /// <typeparam name="U">The type of the entity</typeparam>
        /// <param name="dataContract">The datacontract to update the values.</param>
        /// <param name="entity">The entity that is persisted and owns the actual values.</param>
        /// <returns>Updated datacontract.</returns>
        private static IPersistance UpdateProperties<T, U>(T dataContract, U entity)
            where T : IPersistance
            where U : EntityObject
        {
            IPersistance persistance = (IPersistance)CreateInstance<T, U>(dataContract, entity);
            entity.GetType().GetProperties().ToList().ForEach(entityPropertyInfo =>
            {
                string propertyName = entityPropertyInfo.Name;
                PropertyInfo dataContractPropertyInfo = persistance.GetType().GetProperty(propertyName);
 
                if (entityPropertyInfo != null && !entityPropertyInfo.PropertyType.Name.Contains(typeof(EntityCollection<U>).Name))
                {
                    var entityPropertyValue = entityPropertyInfo.GetValue(entity, null);
                    if (entityPropertyValue != null && dataContractPropertyInfo != null && !dataContractPropertyInfo.PropertyType.IsEnum)
                    {                        
                        dataContractPropertyInfo.SetValue(persistance, entityPropertyValue, BindingFlags.Default, null, null, null);
                    }
                }
                else if (entityPropertyInfo != null && dataContract.GetType().GetProperty(entityPropertyInfo.Name) != null)
                {
                    var ienumerableValues = (IEnumerable)HandleRelatedEnds<T>(dataContract, (IEnumerable)entityPropertyInfo.GetValue(entity, null));
                    persistance.GetType().GetProperty(entityPropertyInfo.Name).SetValue(persistance, ienumerableValues, BindingFlags.Default, null, null, null);
                }
            });
            return persistance;
        }

Der erste Teil aktualisiert alle flachen Eigenschaften des DatenContracts. Der zweite Teil kümmert sich um die Collections.

        /// <summary>
        /// Handles the collections an creates for the datacontract
        /// appropriate items to add them to the list.
        /// </summary>
        /// <typeparam name="T">Type of datacontract</typeparam>
        /// <param name="dataContract">The specific contract where the list belongs to.</param>
        /// <param name="entityCollectionToDuplicate">The entitycollection to map to the datacontract.</param>
        /// <returns>A List of IPersistance objects (BusinessModel Objects).</returns>
        private static List<IPersistance> HandleRelatedEnds<T>(T dataContract, IEnumerable entityCollectionToDuplicate) where T : IPersistance
        {
            List<IPersistance> persistances = new List<IPersistance>();
            IEnumerator it = entityCollectionToDuplicate.GetEnumerator();
 
            while (it.MoveNext())
            {
                EntityObject entity = ((EntityObject)it.Current);
                IPersistance ipersistance = CreateInstance<T, EntityObject>(dataContract, entity);
                ipersistance = UpdateProperties<T, EntityObject>(dataContract, entity);
                persistances.Add(ipersistance);
            }
 
            return persistances;
        }

Damit die Items erstellt werden können braucht es eine weitere Hilfsmethode die uns entsprechende Instanzen zurück gibt.

        /// <summary>
        /// This method creates a specific instance from the Businessmodell Assembly
        /// given by the entity type.
        /// </summary>
        /// <typeparam name="T">The IPersistanceObject to create</typeparam>
        /// <typeparam name="U">The entity that contains the values</typeparam>
        /// <param name="dataContract">The datacontract to add /remove or update</param>
        /// <param name="entity">The entity that was created /updated depending on the passed datacontract.</param>
        /// <returns></returns>
        private static IPersistance CreateInstance<T, U>(T dataContract, U entity) where T : IPersistance
        {
            IPersistance persistance;
            string typeOfEntity = entity.GetType().Name;
            Assembly assembly = Assembly.GetAssembly(typeof(IPersistance));
            Type type = assembly.GetTypes().FirstOrDefault(assemblyType => assemblyType.Name.ToLower().Equals(typeOfEntity.ToLower()));
            persistance = (IPersistance)assembly.CreateInstance(type.FullName);
 
            return persistance;
        }

[/csharp]
<p>Der Funktionsumfang der oben beschriebenen Methode ist einfach. Nimm den Entity-Namen und suche in der BusinessModel Library nach dem entsprechenden Typ und instanziiere einen solchen und gib diesen dann zurück, damit er in der aufrufenden Methode in die Liste eingefügt werden kann.
Eine weitere Methode brauchen wir, damit wir einen DataContract, der über keinen Wert in der Id verfügt, persistieren können. (Das Repository ist nicht Teil dieses).
</p>
[sourcecode language="csharp"]
        /// <summary>
        /// A newly passed datacontract with it's properties
        /// will be persisted in the entity framework.
        /// </summary>
        /// <typeparam name="T">DataContractType</typeparam>
        /// <typeparam name="U">EntityType (must macht with the datacontract type)</typeparam>
        /// <param name="dataContract">The datacontract to persist.</param>
        private static void PersistDataContract<T, U>(T dataContract) where T : IPersistance where U : EntityObject
        {
            U entityToPersist = Activator.CreateInstance<U>();
            entityToPersist.GetType().GetProperties().ToList().ForEach(dataContractPropertyInfo =>
            {
                string propertyName = dataContractPropertyInfo.Name;
                PropertyInfo entityPropertyInfo = dataContract.GetType().GetProperty(propertyName);
 
                if (entityPropertyInfo != null && entityPropertyInfo.PropertyType != (typeof(RelatedEnd)))
                {
                    var entityPropertyValue = entityPropertyInfo.GetValue(dataContract, null);
                    if (entityPropertyValue != null)
                    {
                        dataContractPropertyInfo.SetValue(entityToPersist, entityPropertyValue, BindingFlags.Default, null, null, null);
                    }
                }
            });
 
            using (AddressRepository<U> repository = new AddressRepository<U>(new AddressManagementPersistanceModelContainer()))
            {
                repository.Add(entityToPersist);
                repository.SaveChanges();
            }
        }

Mit dieser letzten Methode haben wir den Mapper erstellt. Nun ist es uns möglich von einem Sender ein Objekt der Businessklassen zu erstellen und müssen uns keine Sorgen machen, ob dies bereits persistiert worden ist oder nicht. Wir erhalten als dann die aktualisierten oder neuen Werte von der Datenbank als Resultat zurück und können somit auf dem Client weiter arbeiten.

Fazit

Der Mapper hat nicht den Anspruch 100% aller Fälle abzudecken, er versucht zu zeigen wie man eine grösstmögliche Modularisierung anstreben kann, ohne dass auf dem Client Server DLL’s refernziert werden müssen. Und natürlich ein nicht zu unterschätzender Punkt ist der Aufwand einmal für die WCF Seite und einmal für die Persistance-Seite ein Modell zu führen.

Sollte Ihnen der Artikel gefallen haben, würde ich mich über einen kick freuen. Gerne beantworte ich auch Fragen und Kritik.

Sharepoint - Der Unterschied der Versionsbezeichnung zwischen Frontend und Datenhaltung

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Mon, 27 Feb 2012 22:56:00 +0200

Bei einem grösseren Migrationsprojekt hatte ich eine interessante Aufgabenstellung im Bezug auf die Versionsbezeichnung von Dokumenten. Im Frontend und im Export-XML (Manifest.xml) werden diese in für Benutzer lesbarer Form als 0.1, 0.2 bzw. 1.0 angezeigt. Intern ist die Version dagegen als 1, 2 bzw. 512 abgelegt.

Are stale data evil?

Patrick — Mon, 27 Feb 2012 11:38:51 Z

When you’re a software engineer who produces software for enterprises like banks or assurances, then it is normal you have huge databases (several gigabytes). Such systems have an operative application where users do the daily business of the company and there are more informative parts (or strategic parts) of the systems which the management uses. At a first glance, there isn’t a problem with those two views, but as you probably know, those companies have for the second part for the management a data ware house solution.

But what if your customer doesn’t want a data ware house solution? Or if he couldn’t afford one? Then you will probably add reports, search views to your application. In this blog post I describe some of the aspects if you’ve to choose this variation.

Stale data as a requirement

Unfortunately the question "how old can the data on this report/search be?" is rarely asked. When the answer is "The report/search has to show the right data", then you have to ask the customer again. The problem is, the data is maybe already stale after the query, because somebody changed some data.

In my experience there are only a few reports, which need as little as possible stale data. But it is essential that you ask this question.

Isolate only as far as needed

Most searches or reports need essential tables in your relational database, so it is important that those searches or reports don’t have an effect to your daily business. You ask yourself maybe now, how those queries could have any impact?

If you use Microsoft SQL Server, then the default isolation level is "Read committed". If a query isn’t that clever made, it could happen, that the query blocks a whole table (Intended Shared Lock which blocks any inserts or updates). If that happen, your users will remark that by waiting while they try to save their data.

When you create a search or an report you have to ask yourself always, which Isolation level you will use. When you use dirty reads (Isolation level "Read uncommitted"), then you’ll probably never generate any locks, but you have to deal with data which is wrong. This because data could be roll backed and the same query wouldn’t bring the roll backed data again.

Conclusion

Stale data or even wrong data on a search or an informational report hasn’t to be wrong or a mistake. Sometimes it’s just good enough to fulfil the requirements and make the customer happy. And that’s what it’s all about.

Anti-Pattern ‘Validation by Execute ‘n’ Rollback’

Patrick — Tue, 21 Feb 2012 20:53:12 Z

Recently in some reviews I saw an anti-pattern. First you have to know, in the code, there was a validation of the data before it was stored in the database. So far so good. But when I looked at the validation code, I saw the following:

public void Validate()
{
	DoProcess(true);
}

And the persist logic (with some business logic) looked like this:

public void Process()
{
	DoProcess(false);
}

So, I asked myself, what the Boolean means. Well, here is the method signature:

public void DoProcess(bool bValidate)

Hmm, the code looks quite magic so far and the argument (and the method name) itself is more or less an anti-pattern already. But when I checked the DoProcess method, I saw something more or less like this:

public void DoProcess(bool bValidate)
{
	using (SqlConnection con = new SqlConnection(connectionString))
	{
		con.Open();
		SqlTransaction transaction = con.BeginTransaction();

		// Some business logic here...

		if(bValidate)
		{
			transaction.Rollback();
		}
		else
		{
			transaction.Commit();
		}
	}
}

The idea behind this code is, if it could be executed successfully, that means a successful validation. If there are any problems during the execution, those problems are the result of the validation. The execution itself wouldn’t be a problem after a successful validation (now I need a drink…).

Doing it better

It’s easy to find bad things, but it’s sometimes harder to do things right. But in this case, the better way is easy. First, you have to separate your business logic from the data access logic. This means following the separation of concern principle.

The next point is, that you’re able to validate your model. So put the logic where it should be. If you use a domain model, the logic to validate an entity has to be on that entity. Or if you have a table module approach, the logic to validate an entity has to be on the corresponding table module.

Side effects

There are also other problems with this anti-pattern. There are some side effects with the data.

As you know, transactions should be as short as possible to prevent lock problems with your data. But if you have combined the business logic and data access logic, your transactions are much longer than needed. To make it worse, this anti-pattern forces you to do it at least twice.

There are reasonable use cases for dirty reads: For example fast searches. In this case you accept dirty reads and you don’t want any locks on your data in the database. Normally, the chance to have a dirty read isn’t that high, but with this anti-pattern the chances to get a dirty read are significantly higher.

Thoughts about Dependency Injection

noreply@blogger.com — Tue, 21 Feb 2012 17:49:00 +0100

I just discovered, that a quote of me made it to the cover of Dependency Injection in .NET:

Looking at the book in its final form, I am surprised at how well that quote fits my current thoughts.

I like the style of the author. This stackoverflow answer is just a nice example of his style: dependency injection can be dangerous for your career.

A quote from my original review of the manuscript:

This is one of the best programming books I have read in the last three years. I like about everything in this book. The technical insights. The way it focuses on concepts and not on tools or technologies. [...] It is definitely suited for programmers that want to learn good design and development techniques. It is not a reference book for a technical framework.

However I have a problem with the hype of dependency injection in general. It definitely goes into the direction of accidental complexity. I mean 584 pages, is a bit heavy for a promise to get better internal quality ... given I do everything else right. Especially compared to other, much wider topics that can have a much broader impact on your development:

From this perspective "All you need to know ... and more!" fits quite well: You will learn a lot reading the book, but it is sad that the current state of software development is that loaded with accidental complexity so that you have to be concerned with that much non-essential overhead ...

I also recommend reading a real critique of the current state of dependency injection: "Dependency Injection" Considered Harmful

If you like this, follow me on twitter ...

CLR Funktion für den SQL Server erstellen

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Fri, 17 Feb 2012 22:18:00 +0200

Lange habe ich auf die Gelegenheit und einen Anwendungsfall gewartet, um eine CLR Funktion für den SQL Server schreiben zu können. Für ein Migrationsprojekt habe ich nun einen Einsatzzweck gefunden. ;-)

Wieder gefunden

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Wed, 15 Feb 2012 20:38:00 +0200

Wenn Du ein Schiff bauen willst, dann trommle nicht Männer zusammen um Holz zu beschaffen, Aufgaben zu vergeben und die Arbeit einzuteilen, sondern lehre die Männer die Sehnsucht nach dem weiten, endlosen Meer. Antoine de Saint-Exupery

Who should make decisions about technologies?

Patrick — Mon, 13 Feb 2012 16:00:00 Z

One of the biggest problems of software engineering companies in Switzerland is currently to get new software developers. To get new employees there are several points as for example salary, environment, career possibilities and technologies. The last point looks easy but in reality it isn’t that easy. Why are essential technology decisions (like languages, frameworks, application servers or big libraries) not only made by developers? Why does the management mostly make those decisions?

In this blog post I try to see the technology aspect for creating software from different perspectives. Those views based on experiences and talks I had during the last ten years.

Customer

As expected the technology used for the software is for the customer irrelevant. But for him counts the working functionality and some non-functional requirements as usability or performance.

Product owner or product manager

The product owner neither is interested in the used technology directly. He’s mainly interested to get the functionality in time and in budget. But he’s also interested to get a good quality of the product, else he’ll receive complaints from the users (of the customer).

IT department

The IT department who has to operate the system is somehow interested in technology. They usually don’t like new technology. One reason is for sure "never change a running system". Another reason is the needed knowhow for every technology. They have to concern the cost of maintaining that knowhow.

Software Architect

The software architect (and I am currently one) is special. When he’s interested in technology, he should take responsibility in the project. If not, you have an architect who lives in the "ivory tower". Mainly the architect should concern more about structure, integration of components or other systems, maintainability and quality.

Human resource management

In most of the companies this part get lost. Today it is hard (specially in Switzerland) to get new developers. So, new and fancy technologies make a job or company more attractive. This means, that the human resource management is interested to use up-to-date technologies.

Developer

Well, most developers care about technology. Specially younger developers more because they had the possibility to try those at the university or in little projects with their colleagues. For those developers technology is essential for the daily job and to be motivated. If they have not the possibility to use new technology they will leave the company after one or two years. And that isn’t cheap for the company.

Management

Today most companies use some self-made frameworks. One reason they spent money to create one is the fear of creative developers who want "to fulfil themself". This means for the management that those developers are out of control and create overcomplicated things with a lot of different technologies. I think this fear is unjustified today, but in the days when everybody could call himself a developer it was not only rightless.
But the management has the difficult task to concern all the roles I described before and make a reasonably decision.

Conclusion

It seams there is a fight between the developers and the management who should make decisions about technologies. It is important that the management has all the information it needs and can concern all the risks of an introduction of a new technology. But the management has to be open to all the facts and arguments and should not presume to make a decision based on old experiences, assumptions or prejudices.
If the decisions are too offensive, then you have at the end quite everything in the IT department (for example all java application server products). On the other hand, if the decisions are too defensive, then you will have a stagnation. This will be very expensive to solve because you have to spend a lot of many to get up-to-date again.

Seismic Explorer Europe im Android Market

noreply@blogger.com — Sun, 12 Feb 2012 17:36:00 +0100

Heute habe ich den Seismic Explorer Europe im Android Market veröffentlicht.

Aus aktuellem Anlass eventuell auch in der Schweiz relevant. https://market.android.com/details?id=ch.kripp.seismic

Die Applikation listet Erdbeben Ereignisse primär in/aus Europa. Die meisten im Marktet verfügbaren Apps beziehen sich auf nicht-europäische Dienste. Als Datenquelle dient http://www.seismicportal.eu/jetspeed/portal/

Weitere Features wie Waveform Data, Map-Search etc. sind bereits in Arbeit - Feature requests, Lob, Kritik ist stets willkommen!

Beyond Windows Azure Roles mit Roland Krummenacher

Tue, 07 Feb 2012 18:00:00 +0100

.NET User Group Bern Event

Dienstag, 7. Februar 2012 (18:00 bis 21:00 Uhr)

Beyond Windows Azure Roles mit Roland Krummenacher

Nachdem wir im ersten Teil die grundlegenden Konzepte kennengelernt haben, beschäftigen wir uns im zweiten Teil mit dem Thema Beyond Windows Azure Roles.

Abstract:

Im zweiten Teil der Serie werden verschiedene Dienste vorgestellt, welche auf der Azure Plattform zusätzlich zu den Web- und Worker-Roles und SQL Azure angeboten werden. Die Themen sind Azure Connect, Azure Content Delivery Network, SQL Azure Reporting Services, SQL Azure Data Sync, SQL Azure Federations, Azure AppFabric Service Bus, Azure AppFabric Access Control sowie Azure AppFabric Caching. Das Ziel ist, zusammen mit dem ersten Teil der Vortragsreihe einen kompletten Überblick über den aktuellen Stand der Azure Plattform zu bieten.

Über Roland Krummenacher

Roland Krummenacher ist Software Entwickler bei der bbv Software Services AG. Das Projekt „TrueSense“ seiner Masterarbeit zu Windows Azure wurde 2011 mit dem Microsoft Schweiz Technology Innovation Award ausgezeichnet. Er berät verschiedene Firmen in Azure Projekten.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbeaz2.

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

The future smells like JavaScript

noreply@blogger.com — Thu, 02 Feb 2012 21:48:00 +0100

Of course I am only repeating what others are preaching about the recent rise of JavaScript.

But I think the movement is significant and can't be overstated. And recent developments are really even making it more and more interesting.

Nobody can deny hat JavaScript is the de facto programming language of Html5. Every other language trying to bolt itself onto Html5 looks like pure friction so far. And Html5 is looking upon a prospering future.

Today we are used to some established JavaScript frameworks that make working with JavaScript more fun and productive. jQuery seems to emerge as the clear leader by popularity here.

More recently tons of javascript application frameworks (so called MVC frameworks) are emerging, that facilitate programming complex applications inside the browser and taking most of the traditional presentation-logic away from the server.

On the other hand we have the node.js ecosystem that takes JavaScript to the server and allows us to use the same language, concepts, libraries and tools for the full application development stack.
And that ecosystem is thriving! JavaScript is the most popular langage on GitHub ... and have a look at the impressive node modules list.

Now this is all well and alpha-geeky, but there are showing up the first "real-world" success stories: Voxer, Walmart, LinkedIn ...

Of course there are the critics.

Surprisingly Microsoft recently positioned itself to become one of the most influencing conveyor of the JavaScript hype. It seems that they are investing heavily into JavaScript on different frontiers:

Microsoft was pushing node.js onto the the Windows environment.
Now they are pushing it into their Azure cloud platform. And evolving a 3rd party ecosystem around that.

But probably the biggest step for the future of JavaScript is the new strategy of Microsoft for Windows 8 desktop and tablet applications (Metro style apps). While there are several options for developing Metro style apps, JavaScript seems to become a major pillar.
This move opens up yet another area for JavaScript and JavaScript developers, completely adjacent to the web.
Developing for the desktop (or tablet) will most likely always be pretty different than for the web. For Metro style apps there will be a lot of new concepts, libraries and tools that are different to the ones that are used in web development (just have a look at WinRT, WinJS ...).
But the desktop- and the web-stack will move closer together and JavaScript with HTML5 and CSS will be the common denominator. Which I think is a very interesting evolution.
For instance look at this example of a drum sequencer (a traditional client application) that is using JavaScript and jQuery for its UI.
The prospect of reusing code and knowhow between desktop-ui- and web-ui-programming seems tempting ... even if a lot of .NET developers and other gurus are not so thrilled by the prospect of omnipresent JavaScript.

Of course another interesting thing will be to see how Metro style apps will change the architecture of future desktop applications. I think some concepts from web development will get adopted into desktop development. A stricter enforcement of separation between UI- and backend-components within a single application will most probably be a result (i.e. there seems to be no notion of traditional data-access in WinRT).

PS: This is my first cross-post between my blog and planetgeek.ch. Thanks @danielmarbach for inviting me.

If you like this, follow me on twitter ...

TF.exe or maybe the most useful tool for TFS

Patrick — Tue, 31 Jan 2012 22:51:17 Z

When you’ve to use TFS, then there are moments when you’re missing some features in the UI tools in Visual Studio. In those situations the console tool tf.exe is very useful. In this short blog post I summarized the commands I used the most.

Update an old version of a branch

It could happen, that the production branch or an older feature branch isn’t up-to-date, because somebody forgot one or several merges from the main branch. To fix that, there could be used the following statement:

tf.exe merge /recursive /force /version:T $/Project/Main/Source $/Project/Production/Source

Delete a branch permanently

After a while the number of merged feature branches increase. Normally, you would delete the merged feature branches, so they aren’t any longer visible in Visual Studio. But in my case, I display also the deleted items and this means, that I see all the deleted feature branches. To remove the old merged feature branches, there could be used the following statement:

tf.exe destroy $/Project/Development/FeatureX

Einführung in die Azure Plattform mit Kay Herzam

Tue, 31 Jan 2012 18:00:00 +0100

.NET User Group Bern Event

Dienstag, 31. Januar 2012 (18:00 bis 21:00 Uhr)

Einführung in die Azure Plattform mit Kay Herzam

Im November 2011 haben wir einen Anlass zum Thema HTML, Javascript und Azure mit Tim Fischer durchgeführt. Diese Themen wollen wir im Jahr 2012 intensivieren und mit einen vertieften Blick auf Azure beginnen. Im ersten Teil der Serie werden wir uns mit den Konzepten und wichtigsten Bestandteilen beschäftigen.

Abstract:

Im ersten Vortrag werden die verschiedenen Bestandteile der Azure Plattform und die grundlegenden Konzepte dahinter vorgestellt. Nebst einer technischen Übersicht der einzelnen Komponenten werden auch Themen wie die Kosten einer Cloud Applikation, sowie die technischen und architektonischen Herausforderungen an den Cloud Entwickler beleuchtet.

Über Kay Herzam

Kay Herzam arbeitet seit über 14 Jahren in der Software Entwicklung. Er hat in verschiedenen Positionen im Engineering, der Entwicklung und Teamleitung und im Consulting mit diversen Technologien und Plattformen gearbeitet. Seit 2007 leitet er seine eigene Firma in Bern.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbeaz1.

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

Education in companies

Patrick — Tue, 31 Jan 2012 17:00:00 Z

I do a lot of trainings and courses in the company where I work currently. And I was also in a lot of courses too. But I think, that those courses or trainings don’t work really. The reason, why is that they are just so called "sheep dips".

Sheep dip training doesn’t work

The first time when I heard the expression "sheep dip" was in the excellent book "Pragmatic Thinking and Learning". It means a training where a lot of people receive a lot of information, mostly just by sitting, listening and watching a lot of PowerPoint slides.

A sheep dip is in real the following (from "Pragmatic Thinking & Learning"):

A sheep dip (for real) is a large tank in which you dunk the unsuspecting
sheep to clean them up and rid them of parasites (see picture). The sheep line up (as sheep do) you grab one and dunk in the tank for an intensive, alien, and largely toxic experience. It wears off, of course, so you have to dip them again.

The problem is the exact same with the education trainings in companies. A lot of employees spend time and the revenue is very, very little.

Doing it better

The question is "How can we do education better?". In my experience there are some better ways:

Pair programming
Little workshops (just the team)
Collaboration platforms
Good documentation

One of the best ways to learn is to get feedback fast. In a "sheep dip" training/course there is nearly no chance to have a such feedback. Therefor pair programming is very good, but hard to do. At least one of the two developers has to be experienced, so the knowledge transfer could happen.

Another way I like very much are little workshops. Normally I ask a developer team, if they are interested in some kind of workshops (reviews, designing, architecture, etc.) based on some reviews of their outcome. The feedback what I received so far is very positive.

I think collaboration platforms, like wikis or OneNote, are still underestimated in corporate environments. But I had a chance to participate in a team where they used OneNote. It was really great, because they added all little tricks and tips how to handle problems with the frameworks and tools in this collaborative platform.

The last way is a good documentation. But what is a good documentation? Well, for me it has to be up-do-date, clear, short, contains examples and easy to read. Another point is, that the documentation has to be searchable. It should be easy to find things fast and just in one place.

Services and customer orientation

Patrick — Tue, 31 Jan 2012 16:30:00 Z

Usually I don’t blog here about personal topics. But as some friends know, I was some days ago in the united states – to be more precise, at the west coast. I visited the cities San Francisco, Las Vegas and Los Angeles. I was a great trip and I enjoyed the cities, the landscape (Grand Canyon) and a lot more.

To be honest, one of the most things which impressed me on the trip was the service and customer orientation of the staff in the hotels, restaurants or taxis. I think there is a gap between what Europe (specially Switzerland) and the USA regarding services and customer orientation. The old world – or Europe – could learn one or more things from the USA.

In the following chapters I try to describe some experiences and conclusion about my experiences during the trip.

Be professional

When I did the helicopter flight to the Grand Canyon, the whole service chain (chauffeur from the hotel, the pilot, the service staff) was just perfect and everything works. They know what they are doing and how the whole process works.

It’s a great experience for a customer when he feels, when a service provider has everything under control and his a master at what he’s doing. Such an experience builds also trust and the customer will return again.

Be personal

This point is where I think the biggest gap between Europe and the USA is. For example at Starbucks they ask you for your first name so they call you when they finished the coffee or bagels. In Switzerland for example you have to guess if the coffee which was finished is for you or not.

One of the most important things to do as a service provider is to make the customer happy. For that you have to build trust and make him feel safe. To build trust, the customer has to know you, so it isn’t unprofessional to speak not only about things which are work related.

Conclusion

It was a great experience to see another way of customer orientation. But there were also some problems, which also exists in Europe. As a service provider you need very good and competent staff. Unfortunately, in some hotels I met a concierge, which wasn’t able to help or understand my need really. And that is what destroy trust, which is unfortunately a really fragile thing.

DataSet and deleted rows

Patrick — Tue, 31 Jan 2012 16:00:00 Z

Yes, I know, the DataSet isn’t the leading edge technology, but as the company where I work currently, there are several companies who use DataSet as data access technology.

Recently, I had to migrate the DataSet subclasses of the framework of my current employer to .NET 4.0 and add LINQ support. After this migration I made some unit tests and I found a surprising fact: If you using LINQ with a DataSet, then you have to handle deleted rows, which isn’t as you would expecting the behaviour.

First, here a little setup to run the tests:

TestDataSet ds = new TestDataSet();
TestDataSet.BECRow row = ds.BEC.NewBECRow();
row.BecId = Guid.NewGuid();
row.RunDat = DateTime.Now;
row.MachineName = Environment.MachineName;
row.CrtDat = DateTime.Now;
row.CrtUsr = "pw";
ds.BEC.AddBECRow(row);
ds.AcceptChanges();

The old way

In the ages before LINQ you get the preferred rows in the following way out of a typed or untyped DataSet:

string strFilter = string.Format("{0} = '{1}'", ds.BEC.CrtUsrColumn.ColumnName, "pw");
TestDataSet.BECRow[] rowsBEC = (TestDataSet.BECRow[]) ds.BEC.Select(strFilter);
Console.WriteLine("Row count: {0}", rowsBEC.Length);

As you expecting, the result here is one row. The ugly thing is the magic filter string and the casting for the variable rowsBEC. But if you’re using DataSets, you are used to such code.

The new way?

With LINQ, the code could look much nicer:

var query = from r in ds.BEC
			where r.CrtUsr == "pw"
			select r;
Console.WriteLine("Row count: {0}", query.Count());

That’s better and I thought that I had the job done. But I was wrong, seriously wrong. This code behaves differently because you will get also the deleted rows (when no where clause exists) or even worse get a DeletedRowInaccessible exception. This exception occurs, when you try to access a property on a deleted row, which will be the case here, if there are deleted rows in the DataTable.

Why? Well, if you look at the code of the Select method (for example with the tool Reflector) you will see, that there is an implicit filtering on the current rows (added, modified and unchanged).

The solutions

So, how could you fix this issue? There are at least two ways. First, the nearest one:

var query = from r in (TestDataSet.BECRow[]) ds.BEC.Select()
			where r.CrtUsr == "pw"
			select r;

This solution works, but you have to do the ugly cast. Well, because we have a framework and we subclassed every DataSet class, we could fix that by an override in the generic base class.

If you don’t have a framework, where you subclassed all the DataSet classes, then there is an alternative way:

var query = from r in ds.BEC
			 where r.RowState != DataRowState.Deleted && r.CrtUsr == "pw"
			 select r;

The order here is important, because you have to check first the RowState and after that you can add the real where clause. Also the "&&" is important, because it has to break if the row is deleted.

Conclusion

There are some pitfalls with DataSet and LINQ, because you wouldn’t expect that behaviour with deleted rows. It doesn’t make any sense at all, because I nearly never saw a reason why my business logic would like to deal with deleted rows. Also the behaviour is unnatural because you think of the DataSet as an in-memory-database, and on the database you have not to deal with deleted rows, unless you have to implement a trigger.

WCF Service über JQuery ansprechen leicht gemacht

schaedlerdaniel — Tue, 31 Jan 2012 13:13:13 Z

Zur Zeit bin ich an einer Weiterbildung für die Verwendung von .NET im Grossfirmenumfeld. Ein Thema darin ist ist Windows Communication Foundation (kurz WCF genannt).

Da ich aus der Ecke der Webprogrammierer komme interessiert es mit primär, wie ich einen WCF-Service von einer Webseite her ansprechen kann.

Was brauchen wir denn für einen Service der auf der Basis der WCF für einen Webseitenzugriff konfiguriert ist?

Vorbereitungen

Erstellen eines neues ASP.NET Projektes über den Menüpunkt “Neues Projekt erstellen…”
Mit NuGet zuerst die JQueryUI und dann die JQuery
Libraries hinzufügen
Erstellen Sie einen Ordner Services in der Solution
In den zuvor erstellten Service fügen Sie ein neues Item hinzu (Vorlage für einen
WCF-Service) und benennen Sie diesen mit “ImageService”
Visual Studio erstellt uns eine .svc und ein entsprechendes Interface ImageService.cs.
Hier stehen noch nicht allzu viele Sachen drin sodass wir die DoWork Methode im
Interface ein wenig anpassen. Nach dem Hinzufügen des Service sollte die Solution
mit den aktuellen JQuery Referenzen ausgestattet sein und folgende .NET Dll’s als
Referenz aufweisen:
- System.Service.Model
- System.Runtime.Serializatin

WCF Konfiguration

Soweit so gut. Wir sind bereit den WCF Service zu implementieren. Hierzu wird in die Solution noch ein Verzeichnis Images hinzugefügt, dass einfach mit den Beispiel Bildern von Windows befüllt wird. Zuerst fangen wir mit der Konfiguration der Web.Config für unseren Dienst an.

Konfiguration der Web.Config mit dem „WCF Service Configurator“ (Finden Sie unter Tools bei Visual Studio 2010)

Erstellen eines neuen Services

Auswahl der DLL von welcher her der Service generiert werden soll. Sollte im bin
Verzeichnis keine DLL vorliegen so kann man dies mit dem „Erstellen der Solution“
beheben
Den Vertrag (Contract) können wir stehen lassen und weiter klicken.
Da wir einen ImageService für’s Internet bereitstellen wollen, lassen wir die Konfiguration
auf http sein.

Auch weitere Optionen belassen wir auf dem Standard. Wir wollen einen einfachen
ImageService ohne Duplex Funktion und lassen den Vorschlag des Assistenten so wie
er ist.

Zum Schluss erstellen wir die Endpunkt-Adresse über welche der Service erreicht
werden soll.

Wir haben einen neuen Service erstellt, wie uns der Assistent nun mitteilt.

Anpassen des WCF Service für unsere Bedürfnisse

Nun haben wir den Service deklarativ in der Web.Config erstellt. Nun müssen wir noch Anpassungen vornehmen, damit der Service auch mit einer WebHttpBinding angesprochen werden kann (das Programmiermodell http von WCF).

Anpassen des erstellten Service für die Verwendung mit ASP.NET (WCF Service Configurator).

Selektieren Sie den zuvor erstellten Endpunkt

Das Binding muss mit der DropDownListe auf webHttpBinding gewechselt werden.

Nun müssen wir dem Binding noch eine Konfiguration zuordnen. Dies können wir tun
indem wir den Punkt „Bindings“ auswählen und ein neues hinzufügen. ACHTUNG:
Man muss das WebHttpBinding auswählen, damit die erstellte Konfiguration darauf
wirkt.

Wir geben der neu erstellen Konfiguration einen Namen und belassen die Standardwerte
so wie sie sind (Die Ausnahmen werden nachstehend aufgelistet).

Konfigurationselement	Wert	Grund
ByPassProxyOnLocal	True	Lokale Adressen werden nicht über einenProxy-Server aufgelöst.
CrossDomainScriptAccessEnabled	True	Zugriff von überall her möglich per Script (Internet Service).

Nun wechseln wir wieder zu den Endpunkten und wählen unseren erstellten Endpunkt
aus. Danach können wir in der Bindungskonfiguration die neu erstellte Bindung auswählen.

Den WCF Service zum Leben erwecken

Wir erstellen uns eine Global.asax die für das Starten und Beenden der WebApplikationen die entsprechenden Methoden bereitstellt. Interessant sind die Methoden Application_Start und die Application_End.

Wir fügen unserem Webprojekt eine Global.asax mit dem Befehl Add new Item… hinzu.

Damit wir webHttp verwenden können müssten wir System.ServiceModel.Web referenzieren
damit wir ein Objekt vom Typ WebserviceHost erstellen können.

Die Global.asax sieht dann wie folgt aus:

 using System; using System.ServiceModel.Web; using
                Sample.WebHttpImageService.Services; namespace Sample.WebHttpImageService { public
                class Global : System.Web.HttpApplication { ///
                <summary>
        /// Host is declared here to not been removed by
        /// the carbage collector.
        /// </summary>
                private static WebServiceHost host = new WebServiceHost(typeof(ImageService), new
                Uri("http://localhost:8099")); ///
                <summary>
        /// Occurs when application is staring up.
        /// </summary>
                ///
                <param name="sender"></param>
                ///
                <param name="e"></param>
                protected void Application_Start(object sender, EventArgs e) { try { host.Open();
                } catch (Exception exception) { host.Abort(); } } ///
                <summary>
        /// Occurs at application shutdown.
        /// </summary>
                ///
                <param name="sender"></param>
                ///
                <param name="e"></param>
                protected void Application_End(object sender, EventArgs e) { host.Close(); } } }

Startet man nun das Projekt kann unter Umständen die Fehlermedung kommen, dass man
eine nicht registrierte URL versucht aufzurufen. Abhilfe schafft hier das Visual
Studio als Administrator zu starten (generell mit WCF zu empfehlen).

Nun wollen wir prüfen ob der Service mit der Methode GetImages angesprochen werden
kann. Die machen wir indem wir http://localhost:8099/ImageService/GetImages in den
Browser eingeben. Wir eine Fehlermeldung, die besagt dass die Methode nicht ausgeführt
werden kann.

Ist ja eigentlich logisch, denn unsere momentane Service Methode erwartet einen
Parameter der über Web „GET“ übermittelt wird. Dies wurde noch nicht implementiert.

Ist das Attribut im Interface angegeben können wir zum Beispiel mit dem Auftruf
http://localhost:8099/ImageService/GetAllImages?path=Test einen Methodenaufruf machen
und erhalten das folgende Beispiel Resultat.

Anpassen der WCF Methode GetImages

Nun wollen wir doch, dass der Service über einen AJAX Aufruf per JQuery angesprochen werden kann. Hierzu gehen wir wie folgt vor. Da die Service-Methode noch nicht so tut wie wir das gerne wollen, dekorieren wir die Methode im Interface mit dem Attribute WebGet. Das Interface sieht nun wie folgt aus:

[ServiceContract]
public Interface IImageService{
[OperationContract]
[WebGet]
public List<string> GetImages(string path);
}

Die Implementierungsklasse sieht dann so aus:

public class ImageService : IImageService{
public List<string> GetImages(string path){
List<string> result = new List<string>(){ "Hello WCF"};
return result;
}
}

Clientseitige Implementierung

Nun kommen wir auf die Clientseite. Wir fügen, falls es nicht schon getan wurde, ein Default.aspx WebForms zur Solution hinzu.

Hierzu erstellen wir uns unter dem Verzeichnis (Scripts) ein Unterverzeichnis mit dem Namen „Custom“ und fügen uns dort eine ImageService.js Datei hinzu, die folgenden Inhalt aufweist. (Vergessen Sie nicht die JQuery Scriptreferenz im Header der Default.aspx hinzuzufügen).

Unser erstelltes Clientscript sieht dann so aus:

$(document).ready(function () {
    var imagesUri = "http://localhost:7777/Images/";

    jQuery.support.cors = true;

    $.ajax({

        type: "GET",
        url: "http://localhost:8099/ImageService/GetImages?path=" + imagesUri,
        dataType: "text",
        contentType: "application/text; charset=utf-8",
        success: function (message) {
            //$('#Result').append(message);
            var xmlDocument = jQuery.parseXML(message);
            var images = xmlDocument.getElementsByTagName("string");

            for (var index = 0; index <= images.length - 1; index++) {

                $('#Result').append("<img src=\'" + images[index].textContent + "\' />");

            }
        },
        error: function (message) {

        }
    });

});

Die Default.aspx braucht dann nur noch eine Script-Referenz auf diese Datei.

<head runat="server">
    <title>Zugreifen auf WCF mittels JQuery</title>  
    <script type="text/javascript" language="javascript" src="Scripts/jquery-1.7.1.js"></script>  
    <script type="text/javascript" language="javascript" src="Scripts/Custom/ImageService.js" ></script>
</head>

Der httpQuery muss mit dem Parameter der im Inteface für die Servicedefinition festgelegt worden ist übereinstimmen. Nun ist es nicht wirklich ansprechend ein Hallo reinzugeben und dann als Resultat Hallo WCF, mit den geschweiften Klammern zu erhalten.

Wichtig hierfür ist das JQuery für CrossDomain zugriff konfiguriert wird. Dies geschieht wie folgt:

	jQuery.support.cors = true;

Nun da WCF und ASP.NET nicht im gleichen Kontext beheimatet sind kann die Grundlage beider genommen werden. Beide bauen auf System.Web.Hosting auf. Folgenes Beispiel lässt alle Bilder die vom Pfad übergeben worden sind mit dem DirectoryInfo suchen und finden.

using System;
using System.Collections.Generic;
using System.IO;
using System.Web.Hosting;
using System.Linq;

namespace Sample.WebHttpImageService.Services
{
    /// <summary>
    /// Get's the images from the path given by parameter.
    /// </summary>
    /// <param name="path">ImagePath to look for images.</param>
    public class ImageService : IImageService
    {
        public string[] GetImages(string path)
        {
            List<string> result = new List<string>();
            
            Uri uri = new Uri(path, UriKind.Absolute);
            
            FileInfo[] images = new DirectoryInfo(HostingEnvironment.MapPath(uri.LocalPath)).GetFiles();

            images.ToList().ForEach(image =>
                                        {
                                            string imageUrl = string.Format(@"{0}{1}", path, image.Name);
                                            result.Add(imageUrl);
                                        });

            return result.ToArray();
        }

Unser Image Service muss so dann nicht im ApsNetCompatibilityMode betrieben werden und wir können trotzdem auf Files auf dem WebServer zugreifen. Nähere Details können hier gefunden werden WCF Service and ASP.NET

Zu guter Letzt Verarbeiten wir Client-seitig das XML das wir vom Server zurück erhalten und zeigen die Bilder an.

Das Bilder anzeigen haben wir ja in die ImageService.js ausgelagert.

Fazit

Mit eigentlich ganz wenig Aufwand ist es möglich einen Service zur Verfügung zu stellen der von allen Interessierten konsumiert werden kann. Trickreich an den ganzen Recherchen war auf jeden Fall das Zusammenspiel zwischen ASP.NET und der WCF die ja nicht im gleichen Kontext laufen, ohne dass man das AspNetCompatibilityReruirement Attribut braucht, oder den WCF-Service im Kompatibilitätsmodus laufen lässt. Weiter werde ich versuchen in den nächsten Wochen ein wenig mehr um die Daten die ausgetauscht werden, zu beleuchten.

Wenn Ihnen dieser Artikel gefallen hat, würde ich mich über einen Kick freuen und bin auch empfänglich für Rückmeldungen und Kritik.

Vacation Books and Screencasts

noreply@blogger.com — Fri, 27 Jan 2012 23:52:00 +0100

I am looking forward to spend another vacation mostly under water.

For the travel and the time above the water I am filling my Kindle and my iPad with the following material:

Thanks to bertolami, mbaumeler and j_graber for the recommendations.

Themenwahl Git oder MSpec mit Alexander Groß

Fri, 20 Jan 2012 18:00:00 +0100

.NET User Group Bern Event

Freitag, 20. Januar 2012 (18:00 bis 22:00 Uhr)

Themenwahl Git oder MSpec mit Alexander Groß

Im neuen Jahr werden wir uns, Dank der Zusammenarbeit mit der .NET User Group Zentralschweiz, spontan etwas früher treffen können. Du hast die Möglichkeit mitzuentscheiden welches Thema Du gerne hören möchtest. Git, MSpec oder sogar beides? Zur Person benötigen wir wohl keine weiteren Erläuterungen. ;-)

Abstract Git:

Git ist ein fortschrittliches und äusserst flexibles Tool zur Verwaltung von Quellcode. Alexander zeigt alles was Du für den Einstieg benötigst: Beginnend beim grundlegenden Einsatz von Git-Befehlen, über die Arbeit mit Entwicklungszweigen (Branches) bis hin zu Tools für die Kommandozeile, für Visual Studio und zum Lösen von Merge-Konflikten.

Abstract MSPec

Machine.Specifications (MSpec) ist ein Context/Specification-Framework für den Einsatz bei TDD und BDD das sich durch eine einfache API und Prägnanz bei der Benamung von Spezifikationen auszeichnet. Alexander zeigt in seinem Vortrag Einsatzmöglichkeiten von MSpec und spricht über die Vorteile die man aus der Verwendung von MSpec ziehen kann.

Über Alexander Groß

Alexander Groß ist freiberuflicher Softwareentwickler und Berater. Seine Spezialgebiete sind Backend-Systeme und Tools zur Verbesserung des Entwicklungsprozesses. Seit 2006 leitet er gemeinsam mit Torsten Weber die .NET User Group Leipzig und organisiert den jährlich stattfindenden .NET Open Space in seiner Heimatstadt. In seiner Freizeit schärft er gern seine Kochmessersammlung und trägt die eine oder andere Zeile Code zu Open Source-Projekten bei.

Anmeldung

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist. Ohne Xing-Konto kannst Du auch unser Kontaktformular nutzen.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbetw.

Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf Deine Teilnahme!

Martin Affolter, Kay Herzam und René Leupold

Entity Framework 4.3 - Schema Migrations für Code First (DbContext)

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sun, 15 Jan 2012 22:47:00 +0200

Eine Anwendung lebt bekanntlich von Änderungen. Nicht selten haben diese Änderungen auch Auswirkungen auf das Datenbankmodell. Das Entity Framework unterstützt mittlerweile DB First, Model First und Code First. Für DB First und Model First ist es kein grösseres Problem Änderungen auf der Datenbank nachzuführen, mit ein paar Tricks und Tools sind sogar Roundtrips zwischen Datenbank und Modell möglich.

Presentation: Can JavaScript be elegant?

noreply@blogger.com — Mon, 02 Jan 2012 16:50:00 +0100

Last month I was invited again to speak at the SBB Developer Day 2011. Here is the presentation I held about JavaScript:

Kann JavaScript elegant sein?

View more presentations from jbandi

I enjoyed the event very much, and I hope to be invited again next time.

Sharepoint 2010 - Business Prozesse mit Workflows

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Fri, 23 Dec 2011 21:14:00 +0200

In meinen ersten Beitrag habe ich ja schon über die interessanten Nebeneffekte von Sharepoint berichtet. Auch diese Woche hatte ich wieder Nebeneffekte, die schon arg Grenzwertig waren. Eine Technolgie, die sich als Zeitfresser entpuppte war Linq to Sharepoint.

Entity Framework ein pragmatischer Ansatz

schaedlerdaniel — Fri, 23 Dec 2011 11:49:48 Z

Was meine ich damit?

Ganze einfach, da ich recht pragmatisch bin und nicht gerne all zu viel schreibe, dachte ich mir es muss doch eine Möglichkeit geben, dass ich genau eine Methode habe, die mir aufgrund eines übergebenen Typ’s die Resultate der Datenbank zurückliefert.

Normalerweise hätte ich das mit einer Vererbung gelöst.

1.) Eine BaseEntität erstellen
2.) Alle anderen Entitäten erben von dieser Basis-Entität.

So ist es mir möglich mit folgendem Code die entsprechenden Tabellen anzusprechen.

using(MyContext context = new Context())
{
      context.BaseEntity.OfType<Person>().ToList();
}

Nun der Ansatz ist nicht schlecht, hat aber seine Tücken, nähmlich dann wenn man grosse Datenmengen verarbeiten muss, dann muss er zuerst alle Daten die dem übergebenen Typ in der BaseEntität entsprechen laden und nochmals die der vererbten Entität.

Was wäre die Lösung?

Keine Vererbung. Gibt natürlich ein wenig mehr zu tun, man hat aber bei einem nicht bekannten Mengengerüst den Vorteil, dass die Datenbank schneller wachsen kann, ohne dass man ein Refactoring am Code vornehmen müsste.

Das ganze einfache Model sieht man nachstehend.

Jetzt kommt aber der entscheidende Punkt, den man beim Desing der Eintitäten beachten soll. Das Entity FrameWork kann mit dem EntitySet Namen umgehen. Wenn wir den EntitSet Namen gleich wie die Entität erfassen, so kann man ohne Probleme mit

 myEntity.GetType().Name;

das EntitySet so angeben. Wenn man aber den generierten Namen lassen möchte, muss man bewusst sein, dass man sich dann den EntitySet-Name, bestehend aus dem Objekt-Typ Namen und einem Postfix vor einer Abfrage erstellen sollte.

Ich habe den ersten Weg gewählt und mir den EntitySet Namen gleichgesetzt wie der EntityName (im Grunde weiss ich ja dass die Tabelle Person heisst, die Menge aber Personen sind).

Wie sieht den nun der Ansatz aus?

Zu diesem Zweck habe ich mir einen ContextHelper erstellt. Interssant ist hier die Methode Get, die anhand eines ObjectQuery die Abfrage an den Kontext sendet.

Was brauchen wir dazu?

1.) Ein ObjectQuery mit entsprechenden ObjectParametern dass sich aus dem übergebenen Objekt und dessen Eigenschaften zusammensetzt.
2.) Ein string Query, welches die die Parameter aufnimmt und anhand des übergebenen Objekts erstellt wird.

Die Get Methode sind dann so aus:

        /// <summary>
        /// Get method for deleting a row in the database.
        /// </summary>
        /// <typeparam name="T">Type of object to get.</typeparam>
        /// <param name="entity">The search object which has to retrieve all matching entires in the database.</param>
        public static IEnumerable<T> Get<T>(T entity) where T : EntityObject
        {
            IEnumerable<T> result = null;
            using (BlogModelContainer container = new BlogModelContainer())
            {
                string queryCommand = string.Format("SELECT VALUE {1} FROM {0}.{1} WHERE 1=1", container.DefaultContainerName, entity.GetType().Name);

                // Creating the query, depending on how much of the properties in the given object are filled out
                // In this case only string properties will be read.
                queryCommand = CreateQueryString<T>(entity, queryCommand);

                ObjectQuery<T> entityQuery = new ObjectQuery<T>(queryCommand, container);
                CreateParameters<T>(entity).ForEach(entityQuery.Parameters.Add);

                result = entityQuery.ToList();
            }

            return result;
        }

Damit diese Methode bedient werden kann sind drei weitere notwendig.

1.) Eine die nur PropertyInfo’s zurückgibt welche auch einen Wert haben.
2.) Eine die den QueryString anhand der PropertyInfo’s abfüllt.
3.) Last but not least eine Methode die anhand der PropertyInfo’s die ObjectParameter erstellt.

Die PropertyInfo Methode sieht wie folgt aus:

        /// <summary>
        /// Get's all properties from an object that where
        /// filled, or they have a value and returns it.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">The entity to look for the properties.</param>
        /// <returns>List of propertyInfos (each propertyInfo has a value)</returns>
        private static List<PropertyInfo> GetProperty<T>(T entity) where T : EntityObject
        {
            List<PropertyInfo> result = new List<PropertyInfo>();

            entity.GetType().GetProperties().ToList().ForEach(property =>
            {
                if (property.PropertyType.Equals(typeof(string)))
                {
                    string propertyValue = property.GetValue(entity, new object[] { }) as string;

                    // Determining if the the property value of type string is filled out.
                    if (!string.IsNullOrWhiteSpace(propertyValue))
                    {
                        result.Add(property);
                    }
                }
            });

            return result;
        }

Da nur PropertyInfo’s zurückkommen die auch einen Wert aufweisen (momentan nur einen string-Typen, werde auch keine leeren Properties zurückgegeben.

Die Methode für den QueryString sieht dann so aus:

        /// <summary>
        /// Creates the appropriate querystring depending
        /// on the object that was passed.
        /// </summary>
        /// <typeparam name="T">The specific objectType</typeparam>
        /// <param name="entity">The entity to query against</param>
        /// <param name="queryString">The</param>
        /// <returns></returns>
        private static string CreateQueryString<T>(T entity, string queryString) where T : EntityObject
        {
            List<ObjectParameter> parameters = new List<ObjectParameter>();
            GetProperty<T>(entity).ForEach(p =>
            {
                string propertyValue = p.GetValue(entity, new object[] { }) as string;
                queryString += string.Format(" AND {0}.{1} = @{1}", entity.GetType().Name, p.Name);
            });

            return queryString;
        }

Für die ObjectParameter Erstellung wird eine ähnliche Methode verwendet:

        /// <summary>
        /// Creates the queryparameters to pass to the objectquery
        /// depending on the filled out properties in the parameter
        /// object.
        /// </summary>
        /// <typeparam name="T">Specific objectType which must be at least of type EntityObject</typeparam>
        /// <param name="entity">The entity with the filled properties for use in the query.</param>
        /// <returns>The ObjectParameters Array to add it to the ObjectQuery.</returns>
        private static List<ObjectParameter> CreateParameters<T>(T entity) where T : EntityObject
        {
            List<ObjectParameter> parameters = new List<ObjectParameter>();
            GetProperty<T>(entity).ForEach(p =>
            {
                string propertyValue = p.GetValue(entity, new object[] { }) as string;
                ObjectParameter parameter = new ObjectParameter(p.Name, propertyValue);
                parameters.Add(parameter);
            });

            return parameters;
        }

Somit werden die QueryParameter und der Query generisch anhand des “Suchobjektes”, das an die Get-Methode übergeben wird zusammengestellt.

Für Fragen, Kritik und Anregungen freue ich mich über einen Kommentar.

Ich wünsche allen frohe Festtage und einen guten Rutsch ins 2012, auf dass weider viele neue Sachen im .NET 4.5 endeckt werden können.

Das Beispielprojekt kann hier heruntergeladen werden.

Sharepoint 2010 - Mein Einstieg

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sat, 17 Dec 2011 14:07:00 +0200

Sharepoint gehört nun seit 2 Monaten zu einem meiner Aufgabenfelder und ich muss sagen, die Lernkurve ist aus meiner Sicht nicht zu unterschätzen. Der Hauptgrund dafür: Es kann viel, aber einiges davon doch noch nicht so richtig oder mit interessanten Nebeneffekten.

Entity Framework 4.1 - Change Tracking

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sat, 10 Dec 2011 11:36:00 +0200

Zwei Monate lang keinen Blogpost mehr verfasst. Was Sharepoint alles anrichten kann, aber das ist eine andere Geschichte.

.NETworking Lunch Software Design

Wed, 07 Dec 2011 12:00:00 +0100

.NET User Group Bern Event

Mittwoch, 7. Dezember 2011 (12:00 bis 14:00 Uhr)

.NETworking Lunch Software Design

Am 7. Dezember treffen wir uns zum zweiten und letzten .NETworking Lunch zum Thema Software Design in diesem Jahr. Patrick wird uns durch das Thema führen und aus seiner Sicht folgende Fragen näher beleuchten:

Ist Software Design heute mit modernen Frameworks überflüssig?
Wird Software Design eigentlich überbewertet?
Ist Software Design einfach nur UML?

Diese Fragen wirken auf den ersten Blick offensichtlich falsch. Doch was ist die Aufgabe von Software Design heute wirklich? An diesem Event erklärt Patrick anhand von Praxisbeispielen und Theorie wo Software Design einen Wert zur Software Entwicklung beisteuern kann und wo die Risiken liegen, wenn Software Design als überbewertet angeschaut wird.

Dieser Event richtet sich an Software Entwickler, Software Architekten sowie an Projektleiter.

Dieses Treffen findet erneut in der Schmiedstube statt. Die Anfahrtdetails sind hier beschrieben.

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist und gebe unter Bemerkungen und Hinweise deinen Menüwunsch an (Menu 1 oder Menu 2 (Vegetarisch) ca. CHF 30.-).

Das Mittagessen wird von jedem Teilnehmenden direkt vom Restaurant verrechnet und muss vor Ort in bar bezahlt werden.

Abmeldung

Bei Nichterscheinen ohne Abmeldung bis 3 Arbeitstage vor dem Anlass werden allfällige Unkosten, die uns dadurch entstehen, bis CHF 50.- weiterverrechnet.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbesd. Die Aktivitäten können hier betrachtet werden.

Wir freuen uns auf deine Teilnahme!

Speaking at the .NET Usergroup Bern

Patrick — Sun, 04 Dec 2011 19:27:22 Z

During a Lunch event organized by the .NET Usergroup Bern at the 7 December 2011 in Bern I will speak about the following question:

Is Software design overrated?

Yes, I know, it’s provocative. And obviously wrong. Really? I’m not so sure. After 10 years as software engineer and some years as software architect I saw too often no design, just a transformation from requirements directly in code. And what is the problem with that?

Interested? So come to my talk, here is some more information. The twitter hashtag will be #dnugbesd.

Opinions: Scala

noreply@blogger.com — Fri, 02 Dec 2011 18:17:00 +0100

Can you spot the difference:

Scala is a serious option for organizations developing on a JVM platform.

- Martin Fowler

The friction and complexity that comes with using Scala instead of Java isn't offset by enough productivity benefit or reduction of maintenance burden for it to make sense as our default language.

- Yammer moving from Scala to Java

If you like this, follow me on twitter ...

Model, model thou art my riddle!

noreply@blogger.com — Wed, 23 Nov 2011 14:09:00 +0100

Can you spot the difference:

In a Model View Controller application, you only ever want to see SQL code in the model.

- Rails Receipes

The domain model should be independent of persistence implementation details.

- Domain Driven Design and Development In Practice

Probably we should accept that models come in different flavors...

... or maybe the grand master was right:

Using C means that people [...] don't screw things up with any idiotic "object model" crap.

- Linus Torwalds

If you like this, follow me on twitter ...

Speaking at the .NET Usergroup Zentralschweiz

Patrick — Fri, 18 Nov 2011 16:17:35 Z

I’m holding at the .NET Usergroup Zentralschweiz a short talk about "Know your warm-up", see my last blog post. I’ll explain what I developed exactly and how I train new employees with this warm-up. I will also demonstrate the sample application which a new employee develops from scratch.

Come to see me speaking the 24. November, 18:00 at the following address: bbv Software Service AG, Blumenrain 10, Luzern, 1. Stock.

Thanks @danielmarbach and @ursenzler for having me.

Update:
There is a wrap-up on the site of the .NET Usergroup Zentralschweiz with some pictures. The slides are now available.

Watch out: The world is changing!

noreply@blogger.com — Fri, 18 Nov 2011 07:50:00 +0100

Lately I seem more susceptible to realize how fast the world is changing. Probably I am getting old...

At a recent lecture, Martin Herdina (CEO, Wikitude) showed how the mobile phone changes our lives (and he displayed slides you don't usually see in lectures…)

Once again I realized that the iPhone was only launched in 2007. I think it is amazing how our use of technology can change in only 4 years ...

Another striking example underlying the perception of technical change in relation to other areas of our lives:

What crosses your mind when you see the following picture?

Old-school, clumsy, clunky, retro …

...at least that are impressions that pop up in my head…

Now, what crosses your mind when you see the following picture:

Cool, highlight, milestone in movie history, top-10-movies of all times, re-defining science fiction movies …

...again that are my personal associations.

But you remember that the Nokia 7110 phone in the above picture was actually designed after being inspired by the Matrix movie:

I think it is remarkable how time is not having the same effect on movies as on technology. The Matrix definitely aged better than the Nokia phone.

In context: Great video about living in exponential times.

If you like this, follow me on twitter ...

Crosspost - Ready to RHoK

noreply@blogger.com — Wed, 16 Nov 2011 09:34:00 +0100

Crosspost - Ready to RHoK / rhokch.blogspot.com

Ready to RHoK?

What is Random Hacks of Kindness - RHoK

RHoK is a global community which has a mission to make the world a better place by developing innovative and open technical solutions to real and practical local and global problems. We do that by bringing together organizations and individuals that are dealing with social and humanitarian problems as their everyday jobs and from the other side experts in technology field whose daily job is to solve problems.

On December 3rd and 4th, the whole worldwide RHoK community is gathering on the locations around the world. One of these locations is Zürich HUB space where Swiss RHoK stars are going to meet to hack the problems away and compete to build the best RHoK solution.

Get involved!

Because we need you to help us in solving growing number of interesting problems which humanity and our local environment is facing every day. There is no better way to use your RHoK star skills. During the RHoK weekend you'll meet different people that share same passion to make the world better and a lot of knowledge in different fields. We encourage innovation, creativity and exploration and try to have as much fun while learning from each other.

Visit our event page and register for participation through EventBrite form: http://www.rhok.org/event/zurich-switzerland

We will provide space, power, food, refreshments, lot of positive energy and challenging problems. You should bring your equipment, expertise, positive spirit and big smile to RHoK the weekend.

Are you a problem owner?

Crucial part of our success is providing solutions for the practical problems. Beside organizing technical community we want to get in contact with organizations and individuals that are working with social and humanitarian issues as their everyday job. If you or your organization needs a team to solve a hard problem, we invite you to join us for the weekend and work with the teams on defining the problems and steering solutions to the best possible effect in real world application.

Contact us and we will work with you so you can prepare your problem definition for the RHoK weekend.

RHoK Switzerland: rhokch@gmail.com

Projects we are working on.

Some of the projects we started working on during the last RHoK event in Basel

Hazard maps for field use - http://www.rhok.org/solutions/hazards-map-field-use

Mobilization of Disaster Response Teams in Adhoc Crisis Situations - http://www.rhok.org/solutions/mobilization-disaster-response-teams-adhoc-crisis-situations-0

Upload tool for person finder - http://www.rhok.org/problems/upload-tool-person-finder

Join some of the problems by contacting problem owners or check the list of the problems which our community is trying to solve on www.rhok.org/problems. We are sure you will find some real food for your brain there :)

How to RHoK?

Go through the introductory slides: http://www.slideshare.net/ivan.jovanovic/rhok-introduction-slides

Tell us more about yourself: https://docs.google.com/spreadsheet/viewform?hl=en_US&formkey=dDVPT0N2bFBsSUtkSGZSRElBa1hDOEE6MQ#gid=0

Where/When is RHoK Zürich going to happen

December 3rd and 4th, 2011.

The Hub Zürich

Viaduktstrasse 93-95

CH-8005 Zurich

Switzerland

Map: http://goo.gl/cJQtN

What is the event agenda

Saturday:

9:30 event opening, introduction to problems of particular interest and forming teams

13:00 lunch

18:30 dinner

21:30 closing the first day, starting informal social part

Sunday:

9: 30 starting the day

13:00 lunch break

16:00 team presentations, voting, promoting winners

17:00 closing the event

Learn more about Random Hacks of Kindness

Official website: www.rhok.org

RHoK comes to Zurich - http://ivanjovanovic.com/2011/10/12/random-hacks-of-kindess-come-to-zurich/

RHoK Basel blog post - http://ivanjovanovic.com/2011/06/06/random-hacks-of-kindness-building-better-world-commit-by-commit/

Dysfunction: Headhunters & Short Time Contracting

noreply@blogger.com — Mon, 14 Nov 2011 21:26:00 +0100

I blogged before about the desolate state of our industry.

Here is one clear symptom underlining once more that there is something wrong:

Regularly when a government IT project here in Switzerland has an open vacancy for some months, I am getting calls, emails and XING requests from headhunters from Germany and the UK that want to mediate me for this job.

There is so much wrong in this setup...

For a start, the whole setup represents the idea that constructing software is like putting bricks on top of each other to build a pyramid. You can hire some more hands and you will finish sooner, because once a brick is laid, somebody else can put the next brick on top of it. This analogy is completely wrong (and that is not an expression of the unprofessionalism of our industry)!

On the other hand what does anybody expect when he goes through headhunters like this (I even have seen cases where several hierarchies of headhunters were involved)?

Do develoers think they don't get jobs without them? Do employers think they do get better developers through those headhunters?
What added value does a headhunter provide in this case? He hardly even looks at my CV, which is online anyways, and...? The employer wants to do an interview with me anyways, and the headhunter does not provide any guarantees, does he?

The result is that another layer of indirection is introduced that legitimates just another bureaucratic overhead. Headhunters like this are neither interested in the project nor in the developers they mediate.
Also (probably as a consequence) developers recruited in this manner usually are not very committed to the project. Why should they? The next recruitement is already waiting around the corner...

I strongly believe we should stop this headhunter/short-time contracting in IT projects. Hire developers for goals not time-periods. Cut the middle-men and get developers committed and responsible.

Further reading:

Recent Thoughts On Hiring and Being Hired
Headhunter tries to recruit DHH (funny comments...)
5 things that are wrong with recruiters! (Update 2011-11-29)

If you like this, follow me on twitter ...

Impressumspflicht für Schweizer Websites

Mon, 14 Nov 2011 00:00:00 Z

* RHoK Zürich *

noreply@blogger.com — Tue, 08 Nov 2011 22:08:00 +0100

#RHoK Zürich *** registration via http://t.co/6qnUUuzV is now open! Developers and SMEs: come and join hacking for humanity *** #rhokCH at The Hub ***

SQL Server Performance Tuning and Troubleshooting Workshop

info@dnug-bern.ch — Mon, 07 Nov 2011 08:00:00 Z

It's Friday, 05:00pm. You are just receiving an email that informs you that your SQL Server has enormous performance problems! What can you do? How can you identify the problem and resolve it fast? Which tools provides you SQL Server for this task?

In this workshop you will see a lot of different tools with which you can do effective SQL Server troubleshooting. You will learn how to identify performance bottlenecks with those tools, and how to resolve the identified bottlenecks. We will also look into the most prominent performance bottlenecks inside SQL Server and how you can troubleshoot those problems effectively.

Rich-Internet Apps & Mobile Anwendungen mit HTML5, Javascript und Azure

Tue, 01 Nov 2011 18:00:00 +0100

.NET User Group Bern Event

Dienstag, 1. November 2011 (18:00 bis 20:00 Uhr)

Rich-Internet Apps & Mobile Anwendungen mit HTML5, Javascript und Azure mit Tim F. Fischer

Am Dienstag, den 1. November 2011 werden wir uns mit dem Thema Rich-Internet Apps & Mobile Anwendungen mit HTML5 und Javascript beschäftigen. Bevor wir aber mit diesen Vortrag beginnen, wird uns Johnny die Neuerungen zu Windows 8 und WinRT präsentieren.

Abstract:
Mit HTML5 und auch bereits HTML4 können anspruchsvolle Rich Internet Anwendungen erstellt werden, die sogar einen Windows-Look, komplexe Funktionen wie Pivot-Charts, editierbare Data-Grids und mehr mitbringen. In diesem Vortrag zeigt Tim Fischer, wie Du solche modernen AJAX-Anwendungen erstellen und auf Windows Azure bereitstellen kannst. Dieselben Techniken können auch für mobile Anwendungen verwendet werden und das werden wir auch tun. Zudem werden wir auch Sencha ExtJS, Sencha Touch und T4 als nützliche Begleiter kennenlernen.

Über Tim Fischer
Dipl.-Inf. Tim Fischer ist Developer Evangelist für ISV/Azure bei der Microsoft Deutschland GmbH. Tim Fischer hat langjährige Erfahrung in der Software-Entwicklung auf der Microsoft Plattform insbesondere mit COM-Technologien und .NET sowie in der modellgetriebenen Software-Entwicklung und Cloud-Computing.

Zuvor hat er an der Entwicklung von Visual Studio 2008 als Program Manager gearbeitet und über 10 Jahre bei einem deutschen Software-Hersteller für Entwicklungswerkzeuge wertvolle Praxis-Erfahrung gesammelt.

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbejs1. Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf deine Teilnahme!

Know your warm-up

Patrick — Mon, 31 Oct 2011 15:00:00 Z

I was this month in Berlin at the NHL match between the LA Kings and the Buffalo Sables. Half an hour before the game you could watch both teams doing a warm up session (see photo). They practice the techniques, moves and collaboration which they will use during the game.

After the match I asked myself, how do we do a warm up? How were we introduced into the development environment of our current employer? After how many hours or days had we have to be productive? Fortunately I realized this gap already and I developed a training kit for a duration of a month for new employees for my current employer.

The warm-up

I recognized that the learning curve is quite steep for new employees and so it is a risk for the company to give them immediately productive tasks. Therefore I developed a training program for a duration of a month – the warm-up. During this training the new employees learn the following:

Infrastructure of the company
Frameworks and tools
Responsible persons for the framework and tools
Guidelines and good practices (not best practices)
Realize software with the frameworks and tools based on uniformed requirements

Before the main part of the training starts there a two days of school where I teach them in traditional manner the architecture, the framework and the workflow component.

The main part is the development of a little insurance application with the same tools, frameworks and libraries which the new employee has to use also in the production environment. For this little application I developed the requirements and also a guideline for the responsible person to teach the new employee. I also implemented the application as a reference solution.

The insurance application itself is designed that the first tasks are easier than the last ones. This way gives the new employee constantly success experiences and he will be motivated to go on and have fun with the whole development environment.

And yes, having fun is important to be motivated. Working doesn’t mean that it isn’t allowed to have fun.

Teaching and documentation aren’t enough

There are several slides for the two school days and there are two papers for the school-application as well. Even for the whole framework exist a lot of paper. But this stuff is more or less useless if the new employee hasn’t anybody who is there for him or her. As in agile practices, feedback is the most important thing. Only the contact person, who is responsible for the education, can give the exact feedback which the new employee need. This because the responsible person knows where the new employee currently stays and what the context is.

Conclusion

We had already several new employees which did the warm-up successfully. The feedback of the new employees was also very positive because they could learn the whole development environment in a protected manner and try out things without any risk.

Speaking at the .NET Usergroup Zentralschweiz

Heirate mich (ASP.NET und JQuery Accordion)

schaedlerdaniel — Thu, 27 Oct 2011 08:18:29 Z

Was ganz nützlich für die Darstellung von Daten ist, ist das Accordion, welches ja auch bereits im AjaxControlToolkit vorkommt.

Nun die meisten werden das Ganze sicherlich rein nativ client-seitig mit JQuery und der Herumschlagerei von Div-Elementen verwendet haben.

Meine Überlegung war es, in Abhängigkeit zu einer Quelle (IEnumerable) die Accordion-Items generieren zu lassen.

Wie bin ich vorgegangen?

Als erstes habe ich mir das Markup eines Demo-Accordions auf der Webseite von JQuery angesehen.

Da es im .NET die Klasse HtmlGeneric gibt kann man mit dieser mit ein wenig Geschick viel anstellen

Also wir brauchen folgendes:

Eine ASP.Seite mit einem Div-Element dass den Container für das Accordion darstellt
Als nächstes brauchen wir eine Klasse, die uns den Accordion Markup generiert
Und last but not least ein Model Element (Klassenelement aus unserem Modell

1. Erstellen der ASPX Seite

Der nachfolgende Markup-Code ist keine Magie und ziemlich schlank

<%@ Page Title="" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="AspNetWebFromJQueryUI.Index" %>
<asp:Content ID="Content1" ContentPlaceHolderID="HeadContent" runat="server">
<link type="text/css" href="Content/themes/base/jquery.ui.all.css" rel="Stylesheet" />	
<script type="text/javascript" src="/Scripts/jquery-1.6.4.js"></script>
<script type="text/javascript" src="/Scripts/jquery-ui-1.8.16.js"></script>
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
<script>
    $(function () {
        $("#Accordion").accordion();
    });
	</script>
<div id="ResultDiv" runat="server">
</div>

</asp:Content>

Einzig das Referenzieren von JQuery und JQueryUI sollte beachtet werden. Hierzu findet man auf JQueryUI die entsprechende Anleitung im Get started Teil.

2. Den Helper für das Accordion

Nun kommen wir zum Helper für die Erstellung des Markups für das Accordion, der wie folgt aufgebaut ist:

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.UI;
using System.Web.UI.HtmlControls;

namespace AspNetWebFromJQueryUI.Controls
{
    /// <summary>
    /// Responsible for creating an accordion base
    /// for using it with JQueryUI
    /// </summary>
    public static class AccordionHelper
    {
        /// <summary>
        /// Returns the complete HTML code for the accordion.
        /// </summary>
        /// <typeparam name="T">The model type.</typeparam>
        /// <param name="datasource">The items to show in the accordion</param>
        /// <see cref="http://jqueryui.com/demos/accordion/"/>
        /// <returns>The HTML Markup for an accordion in JQuery manner</returns>
        public static HtmlGenericControl CreateAccordion<T>(IEnumerable<T> datasource)
        {
            HtmlGenericControl accordion = new HtmlGenericControl {TagName = "div", ClientIDMode = ClientIDMode.Static, ID = "Accordion"};
            accordion.InnerHtml = CreateContentDiv(datasource);

            return accordion;
        }

        /// <summary>
        /// Creates the content div's for putting the model
        /// content to it.
        /// </summary>
        /// <typeparam name="T">The model item (for example from the businessmodel)</typeparam>
        /// <param name="datasource">The items that are the datasource for the accordion</param>
        /// <returns>The HTML string for the accordion</returns>
        private static string CreateContentDiv<T>(IEnumerable<T> datasource)
        {
            StringBuilder sb = new StringBuilder();

            if (datasource != null)
                for (int index = datasource.Count() - 1; index >= 0; index--)
                {
                    if (index == 0)
                    {
                        sb.AppendLine(string.Format("<h3><a href=\"#\">{0}</a></h3>", CreateTitleElement(datasource.ToList()[index])));
                        sb.AppendLine(string.Format("<div>{0}</div>", CreateContentItemFromModel(datasource.ToList()[index])));
                    }
                    else
                    {
                        sb.AppendLine(string.Format("<h3><a href=\"#\">{0}</a></h3>", CreateTitleElement(datasource.ToList()[index])));
                        sb.AppendLine(string.Format("<div>{0}</div>", CreateContentItemFromModel(datasource.ToList()[index])));
                    }
                }

            return sb.ToString();
        }

        /// <summary>
        /// Foreach property in the model item it will be crated a desing
        /// like label: value of the property.
        /// </summary>
        /// <typeparam name="T">The model object</typeparam>
        /// <param name="model">The model item to treat</param>
        /// <returns>The content for the contentItems in the accordion</returns>
        private static string CreateContentItemFromModel<T>(T model)
        {
            StringBuilder sb = new StringBuilder();
            model.GetType().GetProperties().ToList().ForEach(property => sb.AppendLine(string.Format(@"{0}: {1} <BR/>", property.Name, property.GetValue(model, null))));

            return sb.ToString();
        }

        /// <summary>
        /// Takes the first property of an object an set's it 
        /// as title.
        /// </summary>
        /// <typeparam name="T">The model object</typeparam>
        /// <param name="model">The model item to treat</param>
        /// <returns>The content for the title in the accordion</returns>
        private static string CreateTitleElement<T>(T model)
        {
            StringBuilder sb = new StringBuilder();
            PropertyInfo info = model.GetType().GetProperties().FirstOrDefault();
            string title = string.Format(@"{0}: {1}", info.Name, info.GetValue(model, null));

            return title;
        }
    }
}

Was macht der Code?

Er erstellt das Grundgerüst in welchem die Items reingepflanzt werden.
Er erstellt einen Titel aus dem ersten Property des Modells und setzt diesen mit dem Wert des ersten gefundenen Properties von der Modellklasse
Ist alles erledigt, gibt er den gesamten erstellen Markup zurück

3. Die Modellklasse

Meistens findet ja so ein Accordion bei einem Newsreader Verwendung. Eine solches News-Items hat die folgenden Eigenschaften:

Titel
Inhalt
Veröffentlichungsdatum

Nachstehend die sehr einfache Modellklasse für ein News-Item.

using System;

namespace AspNetWebFromJQueryUI.Model
{
    public class NewsItem
    {
        public string Title { get; set; }

        public string Content { get; set; }

        public DateTime PublishDate { get; set; }

    }
}

Wirklich ganz trivial…

4. Einbindung in unsere Seite

Die Einbindung in die Seite geschieht dann wie folgt:

ResultatDiv der Seite mit einem runat=”server” versehen
Im Codebehind dem Control das generierte Accordion hinzufügen.

using System;
using System.Collections.Generic;
using System.Linq;
using AspNetWebFromJQueryUI.Controls;
using AspNetWebFromJQueryUI.Model;

namespace AspNetWebFromJQueryUI
{
    public partial class Index : System.Web.UI.Page
    {
        protected void Page_Init(object sender, EventArgs e)
        {
            //Create dummyData
            List<NewsItem> datasource = new List<NewsItem>();

            for (int index = 0; index < 10; index++)
            {
                datasource.Add(new NewsItem() { Content = string.Format(@"Neuigkeitsinhalt {0}", index.ToString()), 
                                                Title = string.Format(@"Neuigkeit {0}", index.ToString()), 
                                                PublishDate = DateTime.Now.Subtract(new TimeSpan(index, index, index)) });
            }
            
            this.ResultDiv.Controls.Add(AccordionHelper.CreateAccordion(datasource.OrderByDescending(n => n.PublishDate)));
            
        }
    }
}

Somit wird beim Starten, alles in einem schönen von JQuery verwalteten Accordion gerendet.

ACHTUNG: Reflection funktioniert nicht in Abhängigkeit zu den .NET Sicherheitseinstellungen, daher muss zuerst überprüft werden, ob mit Reflection gearbeitet werden kann.

Für Anregungen und Fragen würde ich mich auf einen Kommentar freuen

Vorlagen mal anders…

schaedlerdaniel — Sun, 23 Oct 2011 17:24:22 Z

… und die Möglichkeit auch ohne JQuery Templates auszukommen. Wie soll man das verstehen? Nun ganz einfach, wenn wir eine XML basierte Daten getriebene Webanwendung haben, so ist es nicht immer notwendig mit JQuery Templates das Verschönern der Seite vorzunehmen. Hierzu kann XML /XSL(T) ein wahres Traumpaar sein. Anhand von drei Beispielen soll dann auch gezeigt werden wie es mit dem XMLControl von ASP.NET, rein Client seitig und rein Code-behind bewerkstelligt wird.

XML Data Control

Zuerst erstellen wir uns eine neue ASP.NET WebForms Anwendung und fügen in unsere Seite das XML Data Control ein.

<%@ Page Title="Home Page" Language="C#" MasterPageFile="~/Site.master" AutoEventWireup="true"
    CodeBehind="Default.aspx.cs" Inherits="XMLDataDrivenWeb._Default" %>

<asp:Content ID="HeaderContent" runat="server" ContentPlaceHolderID="HeadContent">
</asp:Content>
<asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">
    <h2>
        XML Driven Web Development
    </h2>
    <p>
        XML DataControl to apply XSL to the XML Document.

        <asp:Xml ID="XmlContainer" runat="server" 
            DocumentSource="~/App_Data/KontaktAngaben.xml" 
            TransformSource="/App_Data/KontaktFormatierung.xsl" onload="XmlContainer_Load" ></asp:Xml>
    </p>
</asp:Content>

Damit wir das Control mit den notwendigen Daten füttern können, erstellen wir zwei Dateien im App_Code Ordner.

Die XML Datendatei

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="text/xsl" href="KontaktFormatierung.xsl"?>
<Kontakangaben>
    <Person>
        <Salutation>Herr</Salutation>
        <FirstName>Hans</FirstName>
        <LastName>Müller</LastName>
        <Street>Müllerstrasse 14</Street>
        <City>3205 Müllhausen</City>
        <Phone>0132542254</Phone>
        <Phone>0123655447</Phone>
        <Role>Präsident</Role>
        <EMail href="hans.mueller@muellergmbh.com">Müller Hans</EMail>
    </Person>
    <Person>
        <Salutation>Frau</Salutation>
        <FirstName>Heidi</FirstName>
        <LastName>Müller</LastName>
        <Street>Müllerstrasse 14</Street>
        <City>3205 Müllhausen</City>
        <Phone>0766778939</Phone>
        <Phone>0324546688</Phone>
        <Role>Vizepräsidentin</Role>
        <EMail href="heidi.mueller@muellergmbh.com">Heidi Müller</EMail>
    </Person>
</Kontakangaben>

Die dazugehörige XSL(T) Datei sieht dann wie folgt aus.

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" >
    <!-- Define the outputtype -->
    <xsl:output method="html"/>
    <xsl:template match="/*">
        <table class="tableStyle">
            <tr>
                <th>Kontaktangaben</th>
                <th>Rolle</th>
                <th>Telefon(e)</th>
                <th>E-Mail</th>
            </tr>
            <xsl:for-each select="Person">
                <tr>
                    <td>
                        <xsl:value-of select="FirstName"/> <xsl:value-of select="LastName"/>
                        <br/>
                        <xsl:value-of select="Street"/>
                        <br/>
                        <xsl:value-of select="City"/>
                    </td>
                    <td>
                        <xsl:value-of select="Role"/>
                    </td>
                    <td>
                        <ul>
                            <xsl:for-each select="./Phone">
                                <li>
                                        <xsl:value-of select="."/>                            
                                </li>
                            </xsl:for-each>
                        </ul>
                    </td>
                    <td>
                        <a>
                            <!-- The xml attribute sets the value for the <a> tag and adds an attribute to it-->
                            <xsl:attribute name="href">mailto:<xsl:value-of select="../Person/EMail/@href"/></xsl:attribute>
                            <xsl:value-of select="../Person/FirstName"/>
                            <xsl:value-of select="../Person/LastName"/>
                        </a>                                                                                                                               
                    </td>
                </tr>
            </xsl:for-each>
        </table>
    </xsl:template>
</xsl:stylesheet>

Wichtig ist dass der output mode auf HTML gestellt wird, ansonsten wird es mit dem Link in der E-Mail Adresse schwierig diesen korrekt darzustellen.

Der Ouput wird dann automatisch vom XML Control gerendert.

Reine clientseitige Verarbeitung

Eine weitere Möglichkeit, für alle die JavaScript über alles lieben, ist mit JQuery die Transformation vorzunehmen.

<%@ Page Title="" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true" CodeBehind="Index.aspx.cs" Inherits="XMLDataDrivenWeb.Index" %>
<asp:Content ID="Content1" ContentPlaceHolderID="HeadContent" runat="server">    
    <script type="text/javascript" language="javascript">
        var xml = null;
        var xsl = null;

        $(document).ready(function () {

            $.ajax({
                type: "GET",
                url: "XMLData/KontaktAngaben.xml",
                data: "{}",
                contentType: "application/xml; charset=utf-8",
                dataType: "xml",
                success: function (msg) {
                    xml = msg;
                },
                error: function (msg) {
                    alert(msg);
                }
            });

            $.ajax({
                type: "GET",
                url: "XMLData/KontaktFormatierung.xsl",
                data: "{}",
                contentType: "application/xml; charset=utf-8",
                dataType: "xml",
                success: function (msg) {
                    xsl = msg;
                    TransformXml();
                },
                error: function (msg) {
                    alert(msg);
                }
            });
        });

        function TransformXml() {

            $('#ResultDiv')[0].innerHTML = xml.transformNode(xsl);
        }
    </script>
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
<div id="ResultDiv">

</div>
</asp:Content>

Code behind Bearbeitung

Zu guter letzt kann alles natürlich mit C# erledigt werden, was eigentlich auch keine Hexerei darstellt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Xml.Linq;
using System.Xml;
using System.Xml.Xsl;
using System.IO;
using System.Text;

namespace XMLDataDrivenWeb
{
    public partial class PureDotNet : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            GetDocument();
        }

        private void GetDocument()
        {
            XmlDocument x = new XmlDocument();
            x.Load(XmlReader.Create(Server.MapPath(@"/App_Data/Kontaktangaben.xml")));

            XslCompiledTransform transform = new XslCompiledTransform();
            transform.Load(XmlReader.Create(Server.MapPath(@"/App_Data/KontaktFormatierung.xsl")));
            transform.Transform(x.BaseURI, Server.MapPath(@"/App_Data/Result.xml"));

            // Loading the generated result file
            string[] xmlResult = File.ReadAllLines(Directory.GetFiles(Server.MapPath(@"/App_Data")).ToList().Where(f => f.ToLower().Contains("result")).FirstOrDefault());
            
            xmlResult.ToList().ForEach(s =>
                                           {
                                               ResultDiv.InnerHtml += s;
                                           });
            
        }
    }
}

Zu guter letzt soll das Ganze auch ein wenig ansprechend aussehen. Dies machen wir wie gewohnt über CSS. Die folgenen Styles werden nachfolgend aufgeführt:

th 
{
    font-size: x-large;
    font-family: cursive;
    background-color: silver;  
    padding: 2px;    
}

td 
{
    font-size:medium;
    font-style: normal;
    border: thin solid black;
}

Wie wir sehen gibt es immer mehrere Wege nach Rom und das Ganze, ach Microsoft will C# etc. abschaffen und nur noch Richtung JavaScript gehen, eher übertrieben. Es kommt immer noch auf uns Entwickler an wie wir eine Lösung zu einem Problem finden.

Anhand dieses einfachen Beispiels sehen wird, dass es möglich ist für ein Problem die eine oder andere Lösung zu wählen, je nachdem was einem beliebt.

Für Anregungen und Kritik bin ich gerne offen

Tidbit: Lines of Code

noreply@blogger.com — Tue, 18 Oct 2011 11:33:00 +0200

According to a claim in the Non Relational Data Stores Panel, the query parser in MySQL alone spans 100'000 lines of code in C and the whole Cassandra Database is 30'000 lines of Java.

I don't know what to deduce from that, but it is certainly interesting.

Some directions of thought:

Java is a more powerful language than C
MySQL is much more sophisticated than Cassandra
NoSQL databases are much less complex than relational databases
...

follow me on twitter, I need some friends :-)

Pimping my MacBook

noreply@blogger.com — Tue, 11 Oct 2011 09:06:00 +0200

I am attempting probably one of the most stupid things: pimping a MacBook ...

The patient is ready. Let's get started.

Patient is opened. Pulse is steady.

The offending organ has been removed.

The replacement organs fit well ...

Surgery finished, patient hopefully ready to wake up ...

... however the doctor is not completely pleased with the result. Another operation is due next week...

Enterprise IT: immature and simple?

noreply@blogger.com — Thu, 06 Oct 2011 15:04:00 +0200

Once you've admitted to yourself that you're a bad programmer, you can stop all the silly posturing and pretending that you're great, and you can look around and find the best possible tools to help you look smarter than you are.

- You're a Bad Programmer. Embrace It.

People pile layers on top of layers, abstractions on top of abstractions, complications on top of complications, crap on top of patches, and patches on top of crap until everything collapses onto itself and the singularity appears.

- Comment to Ryan Dahl

Recently I was confronted with the following problem:

Which x maximizes u?

I remember that I had solved similar problems in analysis lectures about a decade ago, but I had no clue how to approach the task today.

I also have the impression that it would take weeks if not month for me to get back into the subject. Ok, I can read the wikipedia article about the quartic functions but I don't think I will get it without investing some major timespan. I am even doubtful if I could suck the knowledge I need from the internet, or if I finally would have to go to the bookstore and buy an analysis book ...

This made me think about my everyday work as a "coder for hire"/consultant working in the trenches of enterprise IT projects.

I am confronted with problems I have never dealt with almost on a daily basis. However this makes me not nervous at all ...
For instance in a recent project it turned out that I had to write reports with SSRS and integrate them in some custom SharePoint controls. I have never done that before. I never came near to SSRS before and I delibarately had kept a long distance between me an SharePoint. Still I was not afraid of those tasks. I was quite confident that I could solve the tasks within the expectations of the customer (however I am sure there are many developers that would have provided better value for the customer). When I look at the quartic function above I am much less confident and would be get quite nervous if I had to solve that task ...

I started wondering about that fact and came up with some theories:

I am just a natural talent in everything related to enterprise IT ... nah, I don't think so :-)
Enterprise IT is a simple domain. We don't really deal with substantially complex or challenging problems, at least not in the technical realization. We mostly deal with trying to understand technology that has been created by other people. Trying to find out what the assumptions and intentions of those other people were and how to match that as good as possible to our context. If we are good, we try not to apply the technologies in a wrong way. (note that I differenciate enterprise IT from other areas in IT like i.e. scaling a cloud infrastructure like facebook or developing new algorithms for video compression, there I think we still have real innovation and technical challenges).
In the IT industry, especially in enterprise technologies, knowledge is extremely easy to come by. Probably the only real skill you need, is to effectively search the internet. Then you can almost solve any problem. Just ask Goolge and spend some time on Stackoverflow ... you don't need a CS degree for that. Of course that was deliberately provocative: The small challenge remaining is how you combine and apply the knowledge you sucked from the internet. And of course the ability to know when not to apply a technology and look for another solution.
The IT industry is very immature, at least in the enterprise environments I usually find myself. For each project I get hired, I usually have to go through an interview process. These interview processes have quite different flavors of sophistication but the people conducting the interviews think they check that I am suitable for the job. They usually get the requirements for the job through some obscure windings in the organization, but in most cases it has nothing to do with what I end up doing once I really get in touch with the project. It seems the enterprise IT industry has a hard time defining its specialists. The result is that a bunch of generalists like me are stumbling along doing a mediocre job ...

If you like this, follow me on twitter...

Thinking out of the Box

noreply@blogger.com — Fri, 30 Sep 2011 00:35:00 +0200

In requirements analysis we learn to pop the why stack and to challenge business requirements.

The goal of these techniques is to find the real business value at the heart of a given requirement. This real business value is often hidden by an already envisioned solution. Once we know this underlying business value, we might come up with a better/easier solution. Most often the reason why we can come up with an alternative solution is that we can look at the problem in another context and from different perspectives than the original requester of the feature.

This matches with the concept of 2nd order solutions in systems theory: 1st order solutions work within the existing system while 2nd order solutions modify the system itself.

The classical example from requirements engineering is the requirement that a software system must be able to print each UI-screen. The underlying reason was, that employees manually copied data from the given system into another system by printing them out and then typing them into a terminal of the other system. Once this underlying reason was discovered, an alternative solution could be realized: integrating both systems and digitally export/import data. This solution was cheaper to realize for the implementator and provides more business value for the enduser.

A more trivial example to illustrate this "out of the box thinking" is the following task:

Connect all the 9 dots in a single move, using 4 straight connected lines:

Can you do it with three lines?

Can you do it with one line?

If you like this, follow me on twitter...

Back at University - Things have changed

noreply@blogger.com — Wed, 28 Sep 2011 00:08:00 +0200

Recently I started studying for MAS-MTEC at ETH Zürich.

A characteristic of this post graduate studies is that most lectures are shared with graduate students.

I am impressed at how much studying today has changed from when I was studying a decade ago. This impressively shows how fast technology is changing the way we live, which I seem to forget in my every-day life.

The internet is ubiquitous when studing today: The studies are officially organized over the internet (lecture selection, examination registration, learning material distribution, task assignments, group formation for exercises ...).
On the first week I got a invitation to a DropBox share from somebody I actually do not know (probably a higher semester student) which contains over 1GB of "semi-official" studying material (solutions for exercises, example examinations, additional material ...)
One lecture even has a twitter hashtag.

Consequently practically every student is bringing a laptop or tablet to the lectures. I never have seen such a high local density of MacBooks as in the Marketing lecture :-)

Comparing that to when I started studying 12 years ago: I did not even own a cell-phone yet ... I also clearly remember when a lecture assistant suggested to use "Google", and I had never heard that strange term ...

Promotion: Usabilty-to-Go for Developers

noreply@blogger.com — Mon, 26 Sep 2011 23:13:00 +0200

Claudia and Stefan from TechTalk are presenting their Usabilty-to-Go Workshop on 3.11.2011 in the Technopark Zurich.
In this one day workshop developers can learn how to apply efficient usability-design in their enterprise project.

Check it out: Details and registration.

Asynchrone Programmierung nach synchroner Art

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Mon, 26 Sep 2011 21:32:00 +0200

Die asynchrone Programmierung mit Callbacks erfordert schon ein wenig mehr Disziplin. Mit der TPL begann der Schritt darin die Programmierung und die Fehlerbehandlung dahin gehend zu vereinfachen.

Metaprogramming in .NET

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Wed, 21 Sep 2011 05:41:00 +0200

Es gibt viele Ansätze, um mehr Flexibilität in den Entwicklungsprozess zu bekommen, einer davon ist Metaprogrammierung. Dabei handelt es sich meist um ein zusätzliches Level in Softwaresystemen, das zu mehr Flexibilität beitragen soll. In .NET gibt es dafür mehrere Ansätze. Aus diesem Grund habe ich damit angefangen, ein Mindmap zu erstellen, da mich das Thema schon seit längeren interessiert und in diversen Projekten auf die eine oder andere Weise begleitet hat.

Entity Framework 4 - Der Designer stottert bei zusammengesetzten Schlüsseln (CompositeKey)

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Mon, 19 Sep 2011 22:28:00 +0200

Heute wurde ich mit einem interessanten Problem im Entity Designer bei zusammengesetzten Schlüsseln konfrontiert. Das Modell wurde mit dem Assistenten angelegt. Dabei war die Einstellungen "Fremdschlüsselspalten in das Modell einbeziehen" aktiviert und es wurde die Standard-Code Generierungsvorlage verwendet.

ASP.NET Optimization Bundling

schaedlerdaniel — Sun, 18 Sep 2011 10:08:26 Z

Im ganzen HTML 5/ CSS3 etc. Gepredige habe ich doch noch was gefunden was im ASP.NET 4.5 kommen wird. Nun wenn man NuGet mal durchsucht, dann wird man es auch für ASP.NET 4.0 finden. Das Optimization Bundling (Im .NET 4.0 wird es mit Microsoft.Web.Optimization, und dann später mit System.Web.Optimization referenziert). Das Video ASP.NET 4.5 loves HTML5, CSS3 & JavaScript habe ich als sehr informativ empfunden, obwohl nicht wirklich viel neues kommt, oder die Änderunge nicht gerade revolutionär sind.

Damit ich das Pack auch produktiv nutzen kann, habe ich es mal analog dem Video nachgespielt, damit ich, falls ich in meinem gesetzten Alter, nicht mehr alles auswendig weiss, nachlesen kann. Also anfangen, ich von meiner Warte aus entwickle immer noch mit ASP.NET WebForms entgegen dem Hype zu MVC. Also starten wir wie folgt, indem wir eine neue WebForms Solution erstellen.

Kurzübersicht was wir alles machen werden

Erstellen einer ASP.NET 4.0 Solution
Installation des Optimization Bundling per NuGet
Analyse Vorher /Nachher
Fazit

Also fangen wir damit an:

Erstellen einer ASP.NET Solution

Wir starten unser Visual Studio 2010 (Express/Professional/Premium/Ultimae), wählen die Rubrik Web und dann die Vorlage für ASP.NET WebForms. Ein Klick darauf und unsere Solution ist erstellt.

Installieren des ASP.NET Optimization – Bundling

Ist eigentlich keine Hexerei und kann bequem über NuGet erfolgen, dass dann alle notwendigen Schritte übernimmt, und auch die Referenzen im Projekt richtig setzt.

Nach der Installation ist alles bereit, damit wir unsere ASP.NET Lösung optimieren können

Analyse Vorher /Nachher

In diesem kleinen Beispiel hole ich per XHTML-Request drei Personen aus meinem Model und zeige diese an (der XHTML Request kann in seiner Dauer variieren, da interessiert uns die Zeit primär erstmal nicht.) Starten wir die jungfräuliche Solution und drücken im IE9 die Developer Tools mit F12 sehen wir folgende Verkehr:

Interssant sind folgende zwei Punkte

/Styles/Site.css
/Scripts/jquery-1.4.4.min.js

Nun, da wir das Optimization Pack bereits mit NuGet installiert haben, entfällt eine Referenz darauf, denn diese ist bereits vorhanden. Was wir noch machen müssen ist in der Global.asax dafür sorgen, dass die Dateien auch wirklich gebündelt übertragen werden.

        void Application_Start(object sender, EventArgs e)
        {
            BundleTable.Bundles.EnableDefaultBundles();
            Bundle myBundle = new Bundle("~/Scripts", typeof(JsMinify));
            myBundle.AddFile("~/Scripts/jquery-1.4.4.min.js");
            myBundle.AddFile("~/Scripts/PersonScript.js");
        }

Anschliessend passen wir in der Site.Master die Referenz auf JQuery an:

Vorher:

<script type="text/javascript" src="Scripts/jquery-1.4.4.min.js"></script>

Nachher:

<script type="text/javascript" src="Scripts/js"></script>

Anschliessend starten wir unsere Solution wieder und analysieren mit den Developer Tools nocheinmal den Netzwerk-Verkehr. Und siehe da, die zwei vorherigen Kandidaten (Scripts und CSS) haben einen kleinen Hypersprung ausgefürht

Fazit

Wir haben einen Performance Anstieg erhalten, der unsere Webseite schneller übertragen lässt. In diesem sehr, sehr kleinen Beispiel und auch dem localhost mögen die Einsparungen vielleicht nicht enorm sein, betrachtet es man aber so, dass viele Wege zu einer Webseite führen können und nicht immer alles übertragen wird (Package los), dann ist dies sicher ein guter Weg die Daten zu komprimieren.

Bei sehr vielen JavaScript- und CSS-Dateien lohnt es sich auf alle Fälle. Die Demo Lösung kann hier heruntergeladen werden. (Das MVC Beispiel wird im Video erläuter, sodass ich dies nicht erstellt habe.)

Using the JPA metamodel annotation processor

noreply@blogger.com — Tue, 13 Sep 2011 21:39:00 +0200

Some time ago I claimed that the JPA 2.0 metamodel API has the potential to revolutionize Java development.

I still think that the concept is very interesting by showing an approach to strongly typed meta programming in Java. However I think it does not have any relevance in real world projects. One reason is that strongly typed JPA criteria queries are very verbose and bring their own accidental complexity compared with JPQL. The other reason is the actual usage of an annotation processor in any build environment is still too complicated.

In the following I show how to configure the JPA metamodel annotation processor of EclipseLink for different environments. A working example for this is exercise 6.3 in our jpaworkshop.

Maven

EclipseLink documentation is (once again) lacking, ignoring the reality that Maven is currently the most prominent build environment in the enterprise.

Fortunately this is well documented here and here.

You need to configure a maven processor plugin in the pom that triggers the annotation processor in the generate-sources phase:

There are different maven processor plugins. I am using maven-annotation-plugin, an alternative is the Apt Maven Plugin.

Now Maven was easy, lets tackle the IDEs...

NetBeans

NetBeans excels in this task. When opening the Maven pom, it automatically recognizes the above configuration with the maven-processor-plugin and configures itself to use the EclipseLink annotation processor: No additional configuration whatsoever needed! Metadata API classes get generated on the fly with each compilation and even with background compilation ... I wish NetBeans was my favorite IDE :-)

IntelliJ IDEA

Configuration of an annotation processor is nicely documented in this post by JetBrains. The good things:

annotation processors get picked up from the classpath, you dont have to specify the jar (which is a good thing, since the jar name might change when updating the version)
In combination with IDEA the EclipseLink annotation processor detects the default META-INF/persistence.xml automatically without explicit configuration.

The bad thing:

You need to know the exact full qualified name of the annotation processor class.
Generation of JPA metadata API classes works only on compilation (or on explicitly triggering annotation processing). It does not work on the fly when editing files, since IDEA does not have real background compilation.

Eclipse IDE

One might be tempted to think that configuration should be especially easy since Eclipse IDE and EclipseLink imply some kind of close relation...

The EclipseLink documentation explains how to configure the annotation processor ... except it does not work:

In combination with Eclipse the EclipseLink annotation processor does not detect the default META-INF/persistence.xml. You have to configure it manually. This is not documented and not trivial. The problem is reported as bug, but the bug was closed without fixing the problem! I wonder how many people gave up on using the metadata API just because of that shortcoming...

Here is how to configure the EclipseLink annotation processor in Eclipse:

As described in the documentation you have to include three jars on the factory path of the annotation processing configuration:

This approach is bad from the beginning, since those jars might change their name when you update them and they might not versioned together with your sources (this is the case when using Maven) . The approach of IDEA of locating annotation processors in the classpath by their class name is much better in this regard.

But as mentioned above, this does not yet work. You get the following error written in the eclipse error log:

The persistence xml file [META-INF/persistence.xml] was not found. NO GENERATION will occur!! Please ensure a persistence xml file is available either from the CLASS_OUTPUT directory [META-INF/persistence.xml]

The solution is to pass the persistence.xml explicitly to the annotation processor. This is achieved by configuring an annotation processor option. The key is eclipselink.persistencexml. The value is the path to your persistence.xml relative from your CLASS_OUTPUT directory. In case of using Maven, your CLASS_OUTPUT directory is target/classes, so you have to prepend ../../ to your path to arrive in the project root directory ... not trivial indeed ... (note that the path separator might vary on Windows)

Finally generation of JPA metadata API classes is also working in Eclipse. With the great background compilation of Eclipse it is nicely working on the fly when editing files.

If you like this, follow me on twitter...

Das Agile Development Framework (ADF)

Mon, 12 Sep 2011 18:00:00 +0200

.NET User Group Bern Event

Montag, 12. September 2011 (18:00 bis 22:00 Uhr)

Das Agile Development Framework (ADF) mit Golo Roden

Am Montag, den 12. September 2011 wird uns Golo Roden durch das Thema "Das Agile Development Framework (ADF)" führen. Doch bevor wir mit den Thema beginnen, wird uns Stefan einen Überblick in die Kinect-Programmierung geben.

Abstract ADF:
Bestehende agile Methoden wie Scrum und Extreme Programming (XP) bedienen verschiedene Zielgruppen und Aspekte der Softwareentwicklung. Daher werden sie in der Regel kombiniert, um ein umfassendes Rahmenwerk zu erhalten – dies ist jedoch aufwändig, fehleranfällig und erfordert viel Erfahrung.

Zudem enthält jede der bestehenden agilen Methoden Aspekte, die kritisch oder wenig praktikabel sind – wie beispielsweise die Forderung von XP nach dem generellen Programmieren in Paaren. Was also fehlt ist ein umfassendes Rahmenwerk, das die erfolgreichen Elemente der bestehenden agilen Methoden vereint, das jedoch – wenn erforderlich – auch eigene Wege einschlägt.

Das Agile Development Framework (ADF) ist eine mehrstufige, den gesamten Entwicklungsprozess und alle beteiligten Rollen umfassende Stream-basierte agile Methode für vereinte, verstreute und verteilte Teams zur flexiblen, konstruktiven und evolutionären Entwicklung qualitativ hochwertiger Software.

Über Golo Roden
Golo Roden ist freiberuflicher Wissensvermittler und Technologieberater für .NET, Codequalität und agile Methoden. Zu diesen Themen berät er Firmen bei der Evaluierung, Erforschung und Verwendung geeigneter Technologien und Methoden. Darüber hinaus ist er journalistisch für Fachzeitschriften und als Referent und Content Manager für Konferenzen tätig. Für sein qualitativ hochwertiges Engagement in der Community wurde Golo von Microsoft als Most Valuable Professional (MVP) für C# ausgezeichnet.

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbeadf. Die Aktivitäten können während der Veranstaltung hier betrachtet werden.

Wir freuen uns auf deine Teilnahme!

Quotes of the Week: Bashing Hibernate

noreply@blogger.com — Fri, 09 Sep 2011 19:03:00 +0200

Abstracting SQL often isn't a good idea from my experience.

- @codemonkeyism

Hibernate should be to programmers what cake mixes are to bakers: beneath their dignity. [...] As professional programmers, we should be more sceptical of generic frameworks like hibernate.

- Session at JavaZone 2011

There are easier ways to do it, rather than hitting your domain model over the head with NHibernate.

- Rob Conery, Hanselminutes 249

If you like this, follow me on twitter ...

Entity Framework Präsentationen

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Wed, 07 Sep 2011 23:24:00 +0200

Die TechDays 2011 in Basel liegen schon einige Zeit zurück und wir haben es als .NET User Group Bern nun endlich geschafft, einen kleinen Rückblick online zu stellen.

QuickTip: Logging SQL statements in EclipseLink

noreply@blogger.com — Wed, 07 Sep 2011 08:41:00 +0200

Documentation for EclipseLink is quite lacking.

While for Hibernate it is quite easy to find out how to log SQL statements, I had some trouble to find out how to accomplish this in EclipseLink.

The solution are the following properties in persistence.xml:

 <property name="eclipselink.logging.level.sql" value="FINE"/>
 <property name="eclipselink.logging.parameters" value="true"/>

This solution I finally found here.

An alternative is also to use log4jdbc or log4jdbc-remix (the latter is available in the sonatype maven repository). An example is available in exercise 10 of my jpaworkshop.

Programming Humor: Private Coder Soundtrack

noreply@blogger.com — Thu, 01 Sep 2011 17:37:00 +0200

A while back on a dysfunctional project some colleagues of mine started being creative and adapted the lyrics of the famous Tina Turner song "Private Dancer" (lyrics) to our sad project environment:

WELL THE Managers COME IN THESE PLACES
AND THE MEN ARE ALL THE SAME
YOU DON`T LOOK AT THEIR certifications
AND YOU DON`T ASK THEIR qualifications
YOU DON`T THINK OF THEM AS equal
YOU DON`T THINK OF THEM AT ALL
YOU KEEP YOUR MIND ON THE MONEY
KEEPING YOUR EYES ON THE Screen

[CHORUS]

I`M YOUR PRIVATE Coder
A Coder FOR MONEY
I`LL DO WHAT YOU WANT ME TO DO
I`M YOUR PRIVATE Coder
A Coder FOR MONEY
AND ANY OLD PC WILL DO

I WANT TO MAKE A MILLION DOLLARS
I WANT TO LIVE OUT BY THE SEA
HAVE An IPhone AND SOME IPods
YEAH I GUESS I WANT A Widescreen TV
ALL THE Managers COME IN THESE PLACES
AND THE MEN ARE ALL THE SAME
YOU DON`T LOOK AT THEIR FACES
AND YOU DON`T ASK THEIR NAMES

[CHORUS TWICE]

Swissfrancs OR DOLLARS
WTO or PBroker WILL DO NICELY - THANK YOU
LET ME LOOSEN UP YOUR processes
TELL ME DO YOU WANT TO SEE THE flipchart AGAIN

[CHORUS]

... now we are looking for a director to create the music video, the cast would be ready :-)

follow me on twitter, I need some friends :-)

From SVN to TFS: The Good, The Bad and The Ugly

noreply@blogger.com — Mon, 29 Aug 2011 23:03:00 +0200

For my recent MSDN TechTalk I did some research how to migrate a source control repository from SVN to TFS. While I am not advocating this migration, here are the options:

The Good:

Currently you have a choice of three tools:

svn2tfs:
svn2tfs is a simple tool written in VB.NET. You need to have SVN installed in order for this tool to work. It basically replays every revision from SVN as changeset into TFS.

TFS Integration Platform:
The TFS Integration Platform is the Swiss army knife for many possibilities to get data in and out of TFS. The TFS integration platform is available as supported Microsoft product on Visual Studio Code Gallery and as bleeding-edge release on Codeplex. The SVN adapter is currently only part of the codeplex release.

Timely Migration:
Timely Migration is a commercial tool. There are different modules for different source version control systems. To migrate from SVN to TFS the SVNToTFS module is needed. It costs $1995. Trial versions can be requested, but they do not migrate the content of the files.

svn2tfs	Integration Platform	Timely Migration
open source	open source, from Microsoft	commercial, $1995
simple and easy to use	many features, complex, complicated	powerful features, easy to use
enough documentation	sparse documentation	good documentaion
SVN tags can be migrated as branches	SVN tags are migrated as branches	SVN tags are migrated to TFS labels
user-mapping is enforced	user-mapping is possible but not enforced	user-mapping is enforced and comfortable
migration is aborted in case of an error	some errors can be manually resolved and migration can be then be resumed	migration gets resumed when restarting after error resolution

With each tool I was able to successfully migrate an example project from a local SVN repository.

The Bad:

svn2tfs: I was not able to migrate SVN repositories from Google Code. The tool systematically failed, because the initial repository revision for the project layout (dirs for trunk, tags and labels) has not author. The tool can not deal with that. On the positive side was, that the source code of the tool is very simple so that I was quickly able to create a patch, that fixed this problem. On the negative side was, that there was no reaction on the patch I submitted. The project seem pretty dead.

TFS Integration Platform: It seems not possible to do an aynonymous login to SVN. If you do not provide valid user/password, the migration fails with an ugly “NullReferenceException”. The documentation for the SVN adapter is sparse. For instance there was no documentation at all how to map svn users to TFS users. fortunately (after some nudging from my contact at Microsoft) my question in the forum was answered. Some days later even a blog post about the topic was published. Another shortcoming is, that the mapping from svn users to TFS users is not enforced. If no mapping is specified, each svn user is silently mapped to the user that is running the migration tool. There is no support in checking if all users from svn are mapped to TFS users.

Timely Migration: The only negative thing is the price since you probably need the tool only once.

The Ugly:

With none of the tools I was able to migrate the Nerd Dinner repository from Codeplex. Each tool either reported an error or froze indefinitely.

If you like this, follow me on twitter...

Is there any hope for other DVCS in the Git imperium?

noreply@blogger.com — Thu, 25 Aug 2011 18:32:00 +0200

As we are entering the era of language wars on the JVM there is another war looming on the horizon...

This new war is coming out of the realm of distributed version control systems:

Git seems to have a nearly undisputed imperium in this realm and recently has squished its known competitors:

GitHub is THE repository for thriving open source projects. Recently I find me browsing on GitHub much more often than on Google Code or CodePlex ... while BitBucket as the main Mercurial contener only plays a marginal role in my experience.
Google Code, who was favoring SVN and Mercurial for some time, recently added Git support ...
A lot of the new hot-and-hyped cloud based PaaS are using Git as their tool of choice for deployment: Heroku, JBoss OpenShift, AppHarbor ...

Despite the seemingly striking dominance of Git, there are still brave contenders sprouting out of the dvcs land:

Veracity by sourcegear
Plastic SCM
and older, yet still thriving: Mercurial, Bazaar, Fossil ...

All of them featuring some unique features (although features I am not always sure I would like to see coupled to a source control system ...) and most of them somehow promising more simplicity compared to Git.

I wonder if they have any chance against the massive momentum of Git and its ecosystem ...

If you like this, follow me on twitter...

Agile in the real world (construction analogy again)

noreply@blogger.com — Tue, 23 Aug 2011 23:06:00 +0200

There is a common claim that we should learn more from classical engineering disciplines like civil engineering. According to that claim the IT industry would be a better place if we would adopt best practices from the latter.

But when we look closer, then we can see similar problems in those real engineering disciplines ... this picture is a poignant example of that.

Prediction is difficult, especially of the future.

–Niels Bohr

If you like this, follow me on twitter...

Mein erstes Mal….

schaedlerdaniel — Sun, 21 Aug 2011 10:00:04 Z

an der See # Party in Kreuzlingen war super und ich werde auf jeden fall, sollte sie auch nächstes Jahr statt finden wieder hingegen

Wieso denn? Ganz einfach man sieht dort wirklich alle die in der Community aktiv sind und mit denen man per Facebook, Twitter oder irgendeinem Social Tool in Kontakt steht und kann ein wenig fachsimpeln oder auch über Gott und die Welt reden. Schon fast familiäre Stimmung

Welche Session’s habe ich den besucht?

Da die Autofahr ziemlich reibungslos verlief, trudelten ich und mein Fahrer bereits um 07.45 Uhr in Kreuzlingen ein. Ein bisschen früh für den Einlass.

Um 08.25 Uhr blickten wir noch mal rein und konnten uns dann die Badges für SFr. 110.– (was ich für einen sehr günstigen Preis halte) abholen.

Begrüssungsfazit

War nicht so show geladen wie an den Techdays und dass macht die Veranstaltung auch so sympathisch! Weiter so Jungs!

Keynote

Die Keynote war mal ein ganz anderes Thema als, C#, Silverlight und dergleichen. Es ging um den Stress den man sich selber machen kann, oder der durch äussere Faktoren ausgelöst wird. Sehr interessant fand ich dann auch wie sich der Wandel in der IT-Branche vollzogen hat (bis auf ein paar Namensänderungen der Ziele und Verschiebung unter den Top 15 Themen gabs keine grossen Wandel).

Nun ja, da ich meine Mail’s erst am Morgen und dann wieder am Abend kontrolliere und mein Handy so oder so auf lautlos eingestellt ist, hält sich mein Stressfaktor zum Glück in Grenzen.

Danach mal den Plan hervorgenommen und die Session’s gemerkt. Lustigerweise hatte ich 4 mal die Gelegenheit im gleichen Raum die Vorlesungen zu geniessen, was wiederum der Suche für die Örtlichkeit der nächsten Session, erheblich vereinfacht.

Die Sessions

Beruflich habe ich eigentlich immer mit ASP.NET WebForms zu tun. Da auch ich im Wandel bin habe ich die Sessions die sich mit ASP.NET befassten aussen vor gelassen und richtetet meinen Fokus eher Silverlight, XAML, Workflow Foundation.

XAML Deep Dive – Mehr als nur WPF

Dieser Vortrag war sehr lehrreich. Ich fand es super, dass die Einsatzmöglichkeiten von XAML, auch ausserhalb von WPF /Silverlight /Workflow Foundation verwendet werden kann und es ein offener Standard ist. Mein Fazit zu dieser Session: Gut

Falls man die Folien nicht herunterladen kann, findet man auf XAML – Mehr als nur eine einfache Beschreibungssprache einen sehr guten Blogartikel.

Windows Communication Foundation 4.0 – Die Neuerungen

Die Session hat sich mit den Neuerungen der Windows Communication Foundation 4.0 befasst und deren Änderungen die eingeflossen sind. Die Codebeispiele, liefen zu 80%. Es war für mich in dieser Hinsicht schade dass nicht alles funktioniert hat, aber einen positiven Teil kann man dem Ganzen auch abgewinnen: So qualifiziert und auch hohes Fachwissen die Speaker auch habe, auch sie sind Menschen denen Fehler passieren können und das ist sicherlich auch ein guter Aspekt. Schön fand ich wie die einzelnen WCF Neuerungen vorgeführt worden sind. Der Router blieb mir besonders, wegen Performanceeinschränkunen wenn man nicht alles bachtet im Gedächtnis und ich denke dass man dann diesen auch eher seltener einsetzen wird.

Mein Fazit zu dieser Session: Gut (Ich wusste gar nicht das hochdeutsch eine gleiche Geschwindigkeit wie Französisch an den Tag legen kann )

Accessebility

Auf diese Session habe ich mich besonders gefreut, zumal man den Jürgen mal live sehen konnte. Die Aspekte unter welchen man eine barriere freie Webseite baut sind sehr gut dargestellt worden. Auch die anschliessende Diskussion und Fragerunde war sehr aufschluss- und lehrreich. Was habe ich für mich mitgenommen? Am besten Back to the roots, die Webseite in purem HTML erstellen und dynamische Inhalte soweit es geht per CSS zu erstellen. Eine weitere Erkenntnis von mir auch ist dass ASP.NET WebForms eher weniger dazu geeignet ist mit den Boardmitteln einen solche barriere freie Webseite zu erstellen, da muss man eben bei der Generierung der Controls auf der Seite Einfluss nehmen und so kann man in ASP.NET MVC das Ziel einer barriere freien optimaler erreichen.

Mein Fazit zu dieser Session: Gut (ein paar Einstiegslacher lockerten das ganze ein wenig auf (obwohl es wohl Insiderlacher von Jürgen und Karsten waren)).

User Interface Pattern mit Silverlight

Eigentlich hätte ich es mir sparen können diese Session zu besuchen…. Dachte ich zumindest in den ersten 5 Minuten. Aber weit gefehlt: Denn es ist immer wieder gut wenn man die Do’s und Dont’s der UI-Erstellung auf erfrischende Art präsentiert bekommt. Der Sprecher war sehr versiert und auch die Fokusierung von Inhalten durch das menschliche Auge hat, hat mir einen anderen Einblick gegeben.

Rein theoretisch hätte man aber nicht unbedingt Silverlight nehmen müssen.

Mein Fazit zu dieser Session: Gut

Workflow Foundation 4.0

Das Ziel war eine Getting Started Session zu machen die einen Einblick in die Workflow Fondatin 4.0 bieten soll. Dieser Einblick ist nur teilweise geglückt. Dies hat zum einen damit zu tun, dass Features die selbstverständlich sind, also das suchen von Namepsaces à la Expression Blend, nicht wirklich neu waren. Es hätte mir auch mehr gefallen, wenn man eventuell nicht dass klassische Hellow World Beispiel genommen hätte, sonder ein wenig einen kleinen Geschäftsfall erstellt hätte.

Mein Fazit zu dieser Session: Schlecht

Schlusswort

Ich finde es war ein gelungeren Anlass und es hätte auch paar mehr Entwickler kommen können. Meiner Meinung hat ausser berufliche Besuch an einer Koferenz nicht’s mit Geek zu tun sondern mit Interesse an der Arbeit die man macht. Ein Koch der leidenschaftlich kocht, der wird auch zuhause noch gerne kochen und sich auch ausserhalb der Arbeitszeit weiter bilden, weil es ihm Spass macht. Wenn man das nun so auf die Entwickler abmüntzen möchte, dann könnte man es überspitzt sagen, dass diese den Job gar nicht gerne machen (ich weiss es ist überspitzt, aber ich denke dass entspricht so dem Wahrheit).

Auch möchte ich erwähnen dass die geübte Kritik an den Sessions keinesfalls persönlich gemeint sind. Ich selber könnte nicht vor so vielen reden ohne Schweissperlen zu entwickeln, also jedem der vor so vielen Leuten redet, der ist schon, unabhängig von der Kritik, ein Gewinner.

Es würde mich sehr freuen, wenn auch nächstes Jahr wieder eine See # Party statt finden und vielleicht ein wenig mehr Entwickler den Weg dorthin finden würden.

Tidbit: Big Data

noreply@blogger.com — Wed, 17 Aug 2011 22:56:00 +0200

The amounts of data that Twitter handles is astonishing:

12 TB per day (= 4 PB per year)
- ... this equals 17'000 CDs per day
- ... this equals 9 mio floppy disks per day ( = 26.5 miles high)

And the amount is doubling multiple times a year.

... this is according to the presentation NoSQL at Twitter from October 2010, so today the pile of floppy disks would probably already be 50 miles high...

.NETworking Lunch Sharepoint 2010

Wed, 17 Aug 2011 12:00:00 +0200

.NET User Group Bern Event

Mittwoch, 17. August 2011 (12:00 bis 14:00 Uhr)

.NETworking Lunch Sharepoint 2010

Wir wollen was Neues ausprobieren und starten unseren ersten .NETworking Lunch. Samuel Zürcher wird uns bei dieser Gelegenheit eine 360° Sicht zum Thema Sharepoint 2010 vermitteln.

SharePoint 2010 löst an verschiedenen Orten Euphorie aus. Hält das neue Produkt, was es verspricht? Wie integriert es sich in bestehende IT Umgebungen?

Die Rundumsicht:

Was macht SharePoint 2010 überhaupt
Das Instrument zum Verwalten Ihrer Geschäftsinformationen: Enterprise Content Management und Search
Die Automation Ihrer Geschäftsprozesse: SharePoint Formulare und Workflows
Ihr Web-Auftritt mit SharePoint: Web 2.0 und Social Networks
Die Kontrolle Ihrer Geschäftszahlen: Business Intelligence - und Self Service Dashboard
Die Integration: Schnittstellen zu Office und Exchange 2010. Kann SharePoint 2010 die Exchange Public Folder ersetzen?
Architektur und Systemaufbau: Von Single Server bis zur Enterprise Farm

Samuel Zürcher hat Langjährige Erfahrung mit SharePoint seit der Version 2.0, breites IT Know-how und ist seit über 12 Jahren in der IT tätig. Er ist im Projektmanagement in verschiedenen Projektgrössen und Komplexitätsstufen daheim, kennt sich aber auch mit dem innersten Kern von SharePoint aus. Verschiedene Zertifizierungen für SharePoint und der Microsoft Certified Trainer runden sein Profil ab, er ist bereits für SharePoint 2010 zertifiziert (MCTS, MCITP) und ist zudem SharePoint MVP. Er ist der Initiant und zusammen mit Stefan Heinz Begründer der www.sharepointcommunity.ch.

Unser Treffen findet dieses Mal in der Schmiedstube statt. Die Anfahrtdetails sind hier beschrieben.

Bitte beachte, dass für dieses Treffen eine Anmeldung erforderlich ist und gebe unter Bemerkungen und Hinweise deinen Menüwunsch an (Menu 1 oder Menu 2 (Vegetarisch) ca. CHF 30.-).

Das Mittagessen wird von jedem Teilnehmenden direkt vom Restaurant verrechnet und muss vor Ort in bar bezahlt werden.

Abmeldung

Bei Nichterscheinen ohne Abmeldung bis 3 Arbeitstage vor dem Anlass werden allfällige Unkosten, die uns dadurch entstehen, bis CHF 50.- weiterverrechnet.

Das Twitter-Hashtag für diese Veranstaltung: #dnugbelunch. Die Aktivitäten können hier betrachtet werden.

Wir freuen uns auf deine Teilnahme!

Test Driven: It is the mindset not the tool!

noreply@blogger.com — Mon, 15 Aug 2011 18:17:00 +0200

It is amazing to realize how old the notion of Test Driven Development (TDD) really is. Here are two quotes, that are older than I am, describing the ideas behind TDD :

Report of the NATO Software Engineering Conference 1968:

A software system can best be designed if the testing is interlaced with the designing instead of being used after the design. Through successive repetitions of this process of interlaced testing and design the model ultimately becomes the software system itself. I think that it is the key of the approach that has been suggested, that there is no such question as testing things after the fact with simulation models, but that in effect the testing and the replacement of simulations with modules that are deeper and more detailed goes on with the simulation model controlling, as it were, the place and order in which these things are done.

The humble Programmer, Edsger W. Dijkstra 1972:

But one should not first make the program and then prove its correctness, because then the requirement of providing the proof would only increase the poor programmer's burden. On the contrary: the programmer should let correctness proof and program grow hand in hand. [...] If one first asks oneself what the structure of a convincing proof would be and, having found this, then constructs a program satisfying this proof's requirements, then these correctness concerns turn out to be a very effective heuristic guidance. By definition this approach is only applicable when we restrict ourselves to intellectually manageable programs, but it provides us with effective means for finding a satisfactory one among these.

Today we mostly associate TDD with automated unit-tests and the family of xUnit Frameworks. We associate TDD with writing code.

Yet TDD today is far from being mainstream in my experience. And even teams that decided to adopt TDD are constantly struggling with implementing it in reality.

The participants of the NATO Software Engineering Conference from 1968 probably had quite a different notion of implementing TDD than we have today. Their implementation of TDD was probably far away from the automated unit-tests we strive for today. Yet they had the same mindset that we pursue today.

When Dijkstra was already preaching TDD, the xUnit-Frameworks were not to be born for another 26 years.

In the last few years I have come to the conclusion, that the most important aspect of TDD is the mindset that comes along with TDD.

This mindset is much more valuable than any tool, technology or methodology that is commonly associated with TDD today.

With the right mindset we can practice TDD even in environments where we can't write unit-tests (Lo and behold, I am even thinking of SharePoint Development). TDD does not have to be realized by writing code. Nor is writing unit-test always the best way to implement TDD.

With the right mindset we can even practice TDD with manual testing!

The actual implementation of the test is rather a detail of TDD. Much more important is the mindset of practicing baby steps, the mindset of gaining insights and evolving through rapid feedback, the mindset of leveraging trial & error as a methodology, where errors are not failures but valuable insights that guide the evolution of the project.

This mindset is the reason why children in kindergarden are scoring better than MBA graduates in the Marshmallow Challenge:

And it is our God Complex that prevents us from keeping that mindset.

But when we embrace this mindset, we realize that it is applicable in many other areas than writing software. It is applicable to any goals that we try to accomplish in unordered domains, where the result of an action is literally unknowable. Internet startups are the perfect example for this: In a lot of cases it is he best option to ship something, and then respond to the market reaction. The crucial requirement for this fast-feedback cycle is to establish a "safe-fail" environment, where we can embrace failure and leverage failures to guide us to success.

Steve Freeman writes about Test-Driven Development and Embracing Failure and Obie Fernandez writes about Testing against business metrics that has nothing to do with code.

If you like this, follow me on twitter...

Entity Framework Versionierung

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Thu, 11 Aug 2011 10:58:00 +0200

Versionierung ist in manchen Situationen nicht einfach. Ein Beispiel wie das Ganze recht komplex und mühsam für einen Anwender oder Developer werden kann, ist das Entity Framework. Um ein wenig Licht ins Dunkel zu bekommen, hat das ADO.NET - Team einen Blogpost verfasst und um Feedback gebeten. Weitere Informationen gibt es hier.

Erstes .NET Usergroup Event der .NET User Group Zentralschweiz

info@dnug-bern.ch — Mon, 08 Aug 2011 06:00:00 Z

Die UG Zentralschweiz freut sich auf ihr erstes .NET Usergroup Treffen am Freitag 09. September um 18:00 Uhr. Zusammen mit Golo Roden werden sie in die Tiefen von C# eintauchen.

Quotes of the Week: From NDC 2011

noreply@blogger.com — Tue, 02 Aug 2011 20:46:00 +0200

My favorite quotes from NDC 2011:

There is no measurement for technical dept. But the closest measurement is lines of code.

- James Shore

It is all very complicated but not magical!

- John Skeet

Their "one-click-deploy" involved a telephone call, copy-paste sql-scripts and chanting & praying.

- Gojko Adzic

Software development is about creating something specific not something generic.
(Else you can send the customer a virtual machine, that´s generic.)

- Kevlin Henney

Take your last shipping project: Probably you could power-type all the code in one day … How do we spend our time?

- Douglas Crockford

About productivity: How good are you in thinking while typing?

- Kevlin Henney

If you have git, you have source control - if you have TFS, you have my condolences.

- Hadi Hariri

If you like this, follow me on twitter ...

Entity Framework - DbContext und der 2nd-Level Cache mit dem EFCachingProvider

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Tue, 26 Jul 2011 00:44:00 +0200

Der DbContext stellt eigentlich ein Wrapper auf den ObjectContext dar. Ich bevorzuge mittlerweile den DbContext, da dieser einige Funktionalitäten bietet, die ich beim ObjectContext vermisse. Da wären bspw. das vereinfachte Change Tracking, der Support der DataAnnotations, der veinfachte Zugriff auf dem Context-Cache über die Local-Eigenschaft und das dieser neben Code First auch mit dem EDM-Designer verwendet werden kann. Ein Nachteil ist jedoch die fehlende Unterstützung für das Caching. Für den ObjectContext gibt es den EFCachingProvider, der seine Aufgaben relativ gut verrichtet. Über den Konstruktor im ObjectContext wird dieser aktiviert. Nun ist der DbContext ja nichts anderes als ein Wrapper und diesen kann auch eine ObjectContext-Instanz übergeben werden. Also kam ich auf eine ganz wilde Idee, um den DbContext mit einer Zusammenarbeit mit dem EFCachingProvider zu überreden. Alternativ liesse sich das auch mit dem Proxy-Pattern realisieren, aber ich gebe die Hoffnung nicht auf, dass der EFCachingProvider ein fester Bestandteil vom EF werden wird. Mit Hilfe der mitgelieferten T4-Vorlage, die den Einsatz des DbContext für DbFirst und ModelFirst ermöglicht, lässt sich der Caching-Support sehr einfach realisieren. Die angepasste T4-Vorlage sieht so aus:

T4 und der Zugriff auf die App.config

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sun, 24 Jul 2011 15:03:00 +0200

Zur Zeit sitze ich mal wieder tief in der T4-Materie. Dabei war mal wieder die zufällige Erstellung von AppDomains eine kleine Bremse. Das ist eine ganz spezielle Eigenart, die zum Beispiel auch dafür sorgt, dass auf die App.config der Solution nicht direkt zugegriffen werden kann. Im Blog von Sky Sander fand ich einen schönen Workaround, damit der Zugriff doch wieder ermöglicht werden kann. Bei Gelegenheit muss ich mal überprüfen, ob sich die zufällige Erstellung der T4-AppDomains irgendwie in den Griff bekommen lässt. Nachfolgend der Workaround, der bei mir in Form einer Include-Datei mit Namen ConfigurationAccessor.CS.ttinclude verwendet wird:

Entity Framework 4.2 - Facelifting am EDM-Designer

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Mon, 18 Jul 2011 23:08:00 +0200

Die JuneCTP des Entity Frameworks ist nun schon ein Moment verfügbar und ich nutzte die Gelegenheit, mir zuerst die Neuerungen im Designer zu betrachten. Ein Nachteil, der sich abzuzeichnen scheint ist die Tatsache, dass die zukünftige Version mit aller Wahrscheinlichkeit nicht mehr auf Rechnern mit Windows XP laufen wird. Einige werden denken: Wer hat noch so ein altes Betriebssystem installiert? Auf jeden Fall ein Teil der Fortune Global 500. ;-) In dieser Hinsicht könnte das recht interessant werden. Betrachten wir die Neuerungen. Neu gibt es bei den Datenbankobjekten eine Hierarchie nach Schema, das erleichtert schon mal die Übersicht der Schemaobjekte. Zusätzlich gibt es nun auch eine neue Checkbox, damit ausgewählte Prozeduren gleich in das Model importiert werden. Der bisherige Zwischenschritt über den Modellbrowser ist somit nicht mehr zwingend notwendig.

Prism 4.0 Navigation

schaedlerdaniel — Tue, 12 Jul 2011 11:17:06 Z

Momentan sitze ich gerade an der Navigation für Prism 4.0. Der Blogpost auf MSDN-Blogs war dafür sehr hilfreich. Mein Ziel war es wie so etwas darzustellen:
- Erste Seite
- Zweite Seite
- Dritte Seite

Diese sollten von sich aus auf die nächste navigieren können. Hierfür wurden die ViewModel erstellt die von der ViewModelBase erben. Wichtig hierbei ist, dass die ViewModelBase Klasse das Interface INavigateAsync implementiert (gemäss diesem Flow-Diagramm, das einzig zwingend notwendige für die Navigation unter Prism 4.0).

Damit die Views an der Navigation partizipieren können, dürfen sie nicht wie nachstehend in der InitializeModule-Methode registriert werden:

Falsch

regionManager.Regions["MainRegion"].Add(new MainView(), "MainView");

Richtig

regionManager.Regions["MainRegion"].RequestNavigate(new Uri("MainView", UriKind.Relative));

Der kleine, aber feine Unterschied liegt darin, dass mit RequestNavigate bereits das NavigationJournal “gefüttert” wird und man später darauf zugreifen kann. Der Nachteil an der Sache ist, dass die Views nicht in der Views-Collection der Region mit einem Schlüssel auffindbar sind.

Ein kleines Beispiel soll zeigen, wie man auf einfache Art und Weise eine Navigation mit den ViewModels in Prism erstellt.

Schlussendlich soll von Seite eins bis Seite 3 navigiert werden können, hierfür kann man wie folgt vorgehen:
1.) Erstellen eines WPF Projektes (Referenzen auf Prism und Prism Unity Extension mit NuGet durchführen)
2.) Erstellen eines WPF Projektes (In den Eigenschaften keine Windows Applikation auswählen, sondern anschliessend die Main.xaml und die App.xaml löschen, NuGetReferenzen wie vorhin hinzufügen).

Anschliessend kann mit dem WPF Projekt begonnen werden:
1.) Öffnen Sie die App.xaml und ändern sie diese so ab, dass sie wie unten aufgeführt aussieht (Ansonsten wird das MainWindow zwei mal gestartet).

<Application x:Class="Prism.NavigationTryOut.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

2.) Erstellen Sie eine Klasse die von UnityBootstrapper erbt und implementieren diese wie folgt:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.UnityExtensions;
using System.Windows;
using Microsoft.Practices.Unity;
using Microsoft.Practices.ServiceLocation;
using Prism.NavigationTryOut.NavigationModule;

namespace Prism.NavigationTryOut
{
    public class BootStrapper : UnityBootstrapper
    {
        protected override void InitializeShell()
        {
            base.InitializeShell();
            App.Current.MainWindow = (Window)Shell;
            App.Current.MainWindow.Show();
        }

        protected override DependencyObject CreateShell()
        {
            return ServiceLocator.Current.GetInstance<Shell>();
        }

        protected override void ConfigureModuleCatalog()
        {
            base.ConfigureModuleCatalog();       

            Microsoft.Practices.Prism.Modularity.ModuleCatalog catalog = (Microsoft.Practices.Prism.Modularity.ModuleCatalog)this.ModuleCatalog;

            // Nicht geeignet! Nehmen Sie stattdessen die Möglichkeit den catalog per XAML auszulesen.
            catalog.AddModule(typeof(NavigationModuleInitializer));
        }

        protected override void InitializeModules()
        {
            base.InitializeModules();
            
        }
    }
}

Anmerkung: Zum jetztigen Zeitpunkt kann noch nicht kompilliert werden.

3.) Öffnen Sie die App.xaml.cs Codebehind und ändern Sie diese wie folgt ab:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Windows;

namespace Prism.NavigationTryOut
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            BootStrapper bootstrapper = new BootStrapper();
            bootstrapper.Run();
        }
    }
}

Wir sind fast am Ziel und müssen noch zwei kleine Sachen erledigen. Die eine wäre
4.) Benennen Sie die Datei MainWindow.xaml um in Shell und machen Sie dies auch im Codebehind mit der von Visual Studio 2010 gebotenen Funktion “refactore” –> rename.

Jetzt haben wir das StartUp Projekt fertig konfiguriert und müssen uns an das zu implementierende Module zuwenden (ACHTUNG: in diesem Post wird eine Referenz, der Einfachheit halber auf das Module erstellt, was in der Praxis vermieden werden sollte).

5.) Erstellen Sie eine Klasse die das Initialisieren des Moduls und das Registrieren der Views übernimmt.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.Modularity;
using Microsoft.Practices.Unity;
using Microsoft.Practices.Prism.Regions;
using System.Windows.Input;
using Prism.NavigationTryOut.NavigationModule.Views;
using System.Windows.Controls;

namespace Prism.NavigationTryOut.NavigationModule
{
    public class NavigationModuleInitializer : IModule
    {
        private readonly IUnityContainer container;
        private readonly IRegionManager regionManager;      

        public NavigationModuleInitializer(IUnityContainer container, IRegionManager regionManager)
        {
            this.container = container;
            this.regionManager = regionManager;
        }

        public void Initialize()
        {
            this.container.RegisterType<Object, MainView>("MainView");
            this.container.RegisterType<Object, ViewOne>("ViewOne");
            this.container.RegisterType<Object, ViewTwo>("ViewTwo");
            
            regionManager.Regions["MainRegion"].RequestNavigate(new Uri("MainView", UriKind.Relative));
        }
    }
}

6.) Anschliessen können wir auch gleich die ViewModelBase Klasse erstellen, die von jeder anderen ViewModel Klasse geertbt wird. Diese sieht dann so aus:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Practices.Prism.Regions;
using Microsoft.Practices.ServiceLocation;
using System.Windows.Input;
using Microsoft.Practices.Unity;

namespace Prism.NavigationTryOut.NavigationModule
{
    public class ViewModelBase : INavigateAsync 
    {        
        private IRegionManager regionManager;
        private IUnityContainer container;
        protected IRegion mainRegion;

        /// <summary>
        /// Das NavigationsJournal beeinhaltet alle relevanten Uri's
        /// die in der Navigation betroffen sind und waren.
        /// </summary>
        public virtual IRegionNavigationJournal NavigationJournal
        {
            get;
            private set;
        }

        /// <summary>
        /// Command für das Anzeigen der nächsten Seite.
        /// </summary>
        public virtual ICommand NextCommand
        {
            get;
            private set;
        }

        /// <summary>
        /// Command für das Schliessen der Applikation.
        /// </summary>
        public virtual ICommand CloseCommand
        {
            get;
            private set;
        }

        /// <summary>
        /// Command für das Navigieren zur vorherigen Seite.
        /// </summary>
        public virtual ICommand PreviousCommand
        {
            get;
            private set;
        }        

        /// <summary>
        /// Konstruktor lokalisiert mit dem ServiceLocator bereits instantiierte Klassen
        /// die mit dem UnityContainer bereits registriert worden sind.
        /// </summary>
        public ViewModelBase()
        {
            regionManager = ServiceLocator.Current.GetInstance<IRegionManager>();
            IRegionNavigationService navigationService = regionManager.Regions["MainRegion"].NavigationService;           

            this.NavigationJournal = navigationService.Journal;
            mainRegion = regionManager.Regions["MainRegion"];
        }

        public void RequestNavigate(Uri target, Action<NavigationResult> NavigationCallback)
        {
            regionManager.RequestNavigate(mainRegion.Name, target, NavigationCallback);
        }

        /// <summary>
        /// Notwendige Methode um auf .RequestNavigate reagiren zu können.
        /// </summary>
        /// <param name="res"></param>
        public void NavigationCallback(NavigationResult res)
        {
            ClearUnusedViewsFromReagion(mainRegion, res.Context.Uri.OriginalString);
        }

        /// <summary>
        /// Diese Methode übernimmt, das Entfernen von Views, die nicht mehr angezeigt
        /// werden sollen. Da die Views nicht mit .Add zur Region hinzugefügt wurden, 
        /// werden hier die Namen mit dem ViewModel verglichen.
        /// </summary>
        /// <param name="region"></param>
        /// <param name="viewName"></param>
        protected void ClearUnusedViewsFromReagion(IRegion region, string viewName)
        {
            foreach (var view in region.Views.ToList())
            {
                if (!view.GetType().Name.Contains(viewName))
                {
                    region.Remove(view);
                }                
            }
        }
    }
}

7.) Erstellen der VieModels (vgl. SourceCode zum herunterladen). Exemplarische zeige ich hier nur das erste ViewModel (die anderen sind ähnlich aufgebaut)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;
using Microsoft.Practices.Prism.Commands;

namespace Prism.NavigationTryOut.NavigationModule.ViewModel
{
    public class MainViewModel : ViewModelBase
    {
        private ICommand _nextCommand;
        public override ICommand NextCommand
        {
            get { return _nextCommand; }
        }

        private ICommand _closeCommand;
        public override ICommand CloseCommand
        {
            get { return _closeCommand; }
        }

        private ICommand _previousCommand;
        public override ICommand PreviousCommand
        {
            get { return _previousCommand; }
        }

        public MainViewModel()
        {
            _nextCommand = new DelegateCommand(new Action(OnNavigateNext));
            _closeCommand = new DelegateCommand(new Action(OnClose));
            _previousCommand = new DelegateCommand(new Action(OnPrevious));
        }

        private void OnNavigateNext()
        {
            base.RequestNavigate(new Uri("ViewOne", UriKind.Relative), base.NavigationCallback);
        }

        private void OnClose()
        {
            
        }

        private void OnPrevious()
        {
            base.NavigationJournal.GoBack();
        }
    }
}

Die entsprechende View (die anderen zeigen nur ein aderes Bild an) werden wie in Punkt 8.) erstellt:

<UserControl x:Class="Prism.NavigationTryOut.NavigationModule.Views.MainView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             mc:Ignorable="d" 
             xmlns:mvvm="clr-namespace:Prism.NavigationTryOut.NavigationModule.ViewModel"
             d:DesignHeight="300" d:DesignWidth="300" Background="Beige">
    <UserControl.Resources>
        <mvvm:MainViewModel x:Key="MainMvvM"></mvvm:MainViewModel>
    </UserControl.Resources>
    <DockPanel>
        <Image Source="/Prism.NavigationTryOut.NavigationModule;component/Images/Autumn Leaves.jpg" DockPanel.Dock="Top" MaxHeight="400" MaxWidth="600"></Image>
        <Grid x:Name="NavigationGrid" VerticalAlignment="Bottom" DataContext="{Binding Source={StaticResource MainMvvM}}">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="0.3*" />
                <ColumnDefinition Width="*" />
                <ColumnDefinition Width="0.3*" />
            </Grid.ColumnDefinitions>
            <Grid.RowDefinitions>
                <RowDefinition Height="0.2*" />
            </Grid.RowDefinitions>
            <Button x:Name="Previous" Content="Previous" Grid.Column="0" Grid.Row="0" Margin="5" Command="{Binding PreviousCommand}" IsEnabled="{Binding NavigationJournal.CanGoBack}"></Button>
            <Button x:Name="Close" Content="Close" Grid.Column="1" Grid.Row="0" Margin="5" Command="{Binding CloseCommand}"></Button>
            <Button x:Name="Next" Content="Next" Grid.Column="2" Grid.Row="0" Margin="5" Command="{Binding NextCommand}"></Button>
        </Grid>
    </DockPanel>
</UserControl>

Anmerkung: Das ViewModel kann nicht erstellt werden, da im Konstruktor der ServiceLocator von Unity für das Auflösen des IRegionManagers verwendet wird. Dieser wird erst zur Laufzeit erstellt und daher erhält man eine NULL-Reference-Exeption im GUI-Design.

So damit hätten wir eine kleine, aber noch mit Verbesserungspotenzial versehene Navigationslösung erstellt, deren Ansatz man sicher weiter verfolgen kann. In diesem Sinne danke ich für das Lesen des Blogpost’s und freue mich auf konstruktive Kritiken.

Die dazugehörige Solution kann hier heruntergeladen werden.

Entity Framework 4 - ORM und die Unterschiede zwischen Domänen- und ER-Modell

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Tue, 05 Jul 2011 23:05:00 +0200

Brownfield bzw. DB First ist unter vielen Entwicklern unbeliebt. Am liebsten würden sie auf der grünen Wiese beginnen. Es gibt viele Begriffe und Ideologien, häufig stellt es aber eine Herausforderung dar, diese in der Praxis zu vereinen.

Entity Framework 4 - EfCachingProvider und die System.NotSupportedException: Command tree type System.Data.Common.CommandTrees. DbFunctionCommandTree is not supported bei Ausführung von gespeicherten Prozeduren

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Mon, 04 Jul 2011 15:01:00 +0200

Ich habe die neue Version des EFProviderToolkits heruntergeladen. Bei der Ausführung von Prozeduren hatte auch die frühere Version Probleme. Wie ich es dennoch in den Griff bekommen habe, ist hier beschrieben. Nun stand ich wieder an einer ähnlichen Stelle an. Der Code wurde überarbeitet, theoretisch lassen sich auch die gespeicherten Prozeduren ausführen. Theoretisch, denn der Caching Provider quittiert mir die Ausführung mit der Fehlermeldung: System.NotSupportedException: Command tree type System.Data.Common.CommandTrees.DbFunctionCommandTree is not supported. Bei der neuen Version tritt der Fehler jedoch in der Datei EFCommandDefinition.cs auf, also machte ich mich dort auf die Suche. Fündig wurde ich in der Methode GetAffectedEntitySets. Dort werden die Tree-Kommandos geparst und der Visitor angeheftet. Die Methode DbFunctionCommandTree fehlt jedoch in dieser Methode und dadurch wird eine Ausnahme ausgelöst, die in Zeile 170 steht. Also habe ich in der Methode diesen Part hinzugefügt und konnte so das Problem in den Griff bekommen. Da ich in diesem Projekt nur gespeicherte Prozeduren ohne Rückgabewert aufrufe, bleibt die Basisfunktionalität des Caching Providers erhalten. Die angepasste Methode im Projekt EFCachingProivder sieht wie folgt aus:

Cloud Security aus der Marketingperspektive

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sun, 03 Jul 2011 13:22:00 +0200

Ich habe mir die 3 teilige Webcastserie zu Sicherheitsgedanken in der Cloud angesehen und daraus ein grobes Mindmap erstellt. Eins vorweg, diese Serie reicht nicht aus, um sich mit der Cloud-Sicherheit auseinanderzusetzen. Ich werde mich jetzt auf die Suche nach Literatur von Gray-Hats machen, um einen objektiveren Überblick zu erhalten. ;-) Gut ich gebe es zu, die habe ich schon längst, aber noch nicht vollständig gelesen. Gut an der Serie ist, dass sie die 3 Bereiche Kunde, Applikation und Cloud im Bezug auf die Sicherheit betrachtet. Weniger gelungen finde ich allerdings die Sicherheitsaspekte des Cloud Providers, da wird im Bezug auf Azure mit Fachchinesisch um sich geworfen, damit lässt sich das Management nur schwer überzeugen. Der eigentliche Schwerpunkt liegt dann auch auf der Anwendungssicherheit und diese vermittelt einen soliden Eindruck. Nur sollten diese Punkte bei der Entwicklung von Webanwendungen jeden Entwickler bekannt sein, leider ist dies nicht so. In der Folge kann hier die Gefahr eines Ping Pong's zwischen Applikations- und Cloud-Provider bestehen. In dieser Hinsicht freue ich mich auf den Tag, an dem bei Gesprächen unter Entwicklern Begriffe wie SDL, CIA, AAA usw. zum Grundwortschatz gehören und nicht mit einem "Hää" beantwortet werden. Bei SOLID funktioniert es ja auch.

Entity Framework - Lange war es ruhig, aber jetzt tut sich wieder was

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sat, 02 Jul 2011 13:28:00 +0200

Kurz bevor der Juli begann, wurde noch schnell die JuneCTP für das Entity Framework veröffentlicht. Da ich bisher alle Download-Links in meinen Blog hinterlegt habe und das jetzt bei der Einrichtung eines neuen VM-Image für mich sehr hilfreich war, werde ich den Link auch hinterlegen. ;-) Details und die Downloadlinks zur EF June CTP 2011 gibt es hier. Liebevoll wird diese CTP bereits EF Enum Edition genannt. *fg* Eigentlich schon ein wenig unterhaltsam, da spricht man überall von Anwendungsintegration, Auswertungen, Data Mining, DWH und jetzt Enum. Ich hoffe nur, dass diejenigen Entwickler die so lauthals den Support dafür gefordert haben, auch Verantwortungsbewusst damit umgehen werden.

T4 - EntityFramworkTemplateFileManager durch den TemplateFileManager ersetzen

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Wed, 29 Jun 2011 22:48:00 +0200

Eigene Code-Generierungsvorlagen für das Entity Framework können sehr einfach erstellt werden. Es gilt nur eine Konvention zu beachten. Details dazu gibt es in diesem Beitrag. In der Basis arbeitet der EntityFrameworkTemplateFileManager, der in Verbindung mit den Code-Generierungsvorlagen häufig zur Anwendung kommt. Die Vorlagen für den Kontext und die Businessobjekte sind in der Regel auf zwei T4-Vorlagen aufgeteilt, damit ein gewisses Mass an Flexiblilät erreicht werden kann. So lässt sich bspw. die Vorlage für die Business-Objekte in eine andere Solution verschieben. Nach der Anpassung des Pfades zur EDMX-Datei funktioniert diese auch wieder. Bei grossen Modellen ist dieser Ansatz auch nicht immer die beste Lösung, da alle Klassen der Vorlage untergeordnet sind und die Generierung in einzelne Verzeichnisse nicht möglich ist. Da der EDM-Designer erweitert werden kann, wie es in diesem Beitrag beschreiben wird, besteht die Möglichkeit, dass für die Klassen ein Package-Namespace definiert werden kann, in dem die Klassen später hinein generiert werden. Mit dem EntityFrameworkTemplateFileManager ist das jedoch nicht möglich, sodass für die Vorlage ein anderer Lösungsansatz verwendet werden muss. Da der TemplateFileManager auf dem EntityFramworkTemplateFileManager basiert, kann dieser für die Aufgabe herangezogen werden. Der Austausch erfolgt nach dem klassischen Muster Suchen und Ersetzen. Warum das so ist, erläutere ich nicht noch mal. ;-) Betrachten wir diesen klassischen Ansatz an der mitgelieferten Code-Generierungsvorlage "Self Tracking Entities". Für die Klassen soll neu die Möglichkeit bestehen, dass diese in eine andere Projektmappe und der entsprechenden Unterverzeichnisse gem. Package-Namespace generiert werden. Dazu öffne ich die T4-Vorlage für die Klassen.

T4 - Wo steht die Version 2 des TemplateFileManager zur Verfügung

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Sat, 25 Jun 2011 03:47:00 +0200

Über die neuen Funktionen des TemplateFileManagers habe ich bisher nur geschrieben, öffentlich war dieser nicht. Das hole ich mit diesem Beitrag nach. Neben der Veröffentlichung in der Code Gallery des tangible T4 Editors steht die neue Version des TemplateFileManagers auch hier zum Download bereit.

T4 - Benutzerdefinierte Parameter für die StartHeader-Methode im TemplateFileManager

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Tue, 21 Jun 2011 21:58:00 +0200

Wie der einzige Standardparameter $filename$ verwendet werden kann, ist in diesem Beitrag beschrieben. Im Header können wiederkehrende Teile wie zum Beispiel der Dateikopf bzw. die Namensraumdefinition hinterlegt werden. Der Standardparameter wird dafür sicherlich nicht ausreichen und so können über die FileProperties weitere benutzerdefinierte Parameter festgelegt werden. Folgendes Szenario soll die Verwendung veranschaulichen. Im Bereich, der durch die Methode StartHeader festgelegt wird, sollen pro Datei weitere Parameter für den Namensraum und den Klassennamen verwendet werden. Der Aufbau könnte wie folgt aussehen:

T4 - Custom Tool ein weiteres neues Feature im TemplateFileManager

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Thu, 16 Jun 2011 23:18:00 +0200

Custom Tool, dabei handelt es sich um eine Komponente für Visual Studio mit der eine dem Projektitem untergeordnete Quellcode-Datei erstellt werden kann. Für T4-Templates zum Beispiel heisst das Custom Tool TextTemplatingFileGenerator und ist für den Output zuständig (Im Fall von T4 die Ausgabe anstossen). Es gibt Situationen, da ist es richtig praktisch, wenn bei der Codegenerierung so ein Custom Tool verwendet werden kann. In meinen Beispielen der ADC 2010 befindet sich dazu ein Szenario für Ressource-Dateien. In einem Beispiel benutze ich meinen VsAutomationHelper, um nach der Fertigstellung der Generierung das Custom Tool auf die Standardressource zu setzen. Der Vorteil sollte eigentlich jedem ersichtlich werden. Ich spare mir Zeit, in dem ich keine Templates schreibe, wofür in Visual Studio bereits ein fertiges Konzept besteht. Das Custom Tool habe ich bisher mit den AutomationHelper mit folgender Zeile gesetzt:

T4 Format Document, dass zweite neue Feature im TemplateFileManager

ipt:linkTo_UnCryptMailto('nbjmup+'); (René) — Tue, 14 Jun 2011 22:43:00 +0200

Beim erstellen der Vorlagen muss man selbst darauf achten, wenn die Ausgabedatei "wohlgeformt" sein soll. Ein Problem, welches dadurch auftreten kann, ist die verschlechterte Lesbarkeit der eigentlichen T4-Vorlage. Betrachen lässt sich das an folgendem Beispiel:

Dynamisch generiertes Bilder-Menu erweitern mit JQueryUI

schaedlerdaniel — Sun, 12 Jun 2011 16:55:09 Z

Im letzten Blogbeitrag wurden die Bilder im Verzeichnisbaum in das Menu gerendert (also die Struktur). Damit man noch ein wenig mehr Pepp in das Ganze bringen kann, ist es möglich JQueryUI zu verwenden. Zu diesem Zweck habe ich mir den Modal Dialog ausgesucht, dass wenn der Benutzer ein Bild, das verkleinert dargestellt wird, in einem Dialog angezeigt bekommt.

Was ist denn da alles notwendig?

Eigentlich nicht ganz viel:
1.) Man lade eines der vielen Themen herunter, dass von JQueryUI schon zur Verfügung gestellt wird.
2.) Grundlage bildet der vorherige Blogpost “Dynamisch generiertes Bilder-Menu”. Die Source kann hier herunter geladen werden.
Wie kommen wir denn nun zu dem modalen Bild

Als erstes passen wird den Menu-Click Event an. Hier werden dann dynamisch anhand der Anzahl Bilder die IMAGE-ASP.NET Controls in das entsprechende DIV gerendert.

        /// <summary>
        /// If menu is clicked the image will be rendered as image tag into the site
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void GalleryMenu_ItemClick(object sender, MenuEventArgs e)
        {
            MenuItem menuItem = (MenuItem)e.Item;
            string path = string.Format(@"Images/{0}", menuItem.ValuePath);
            DirectoryInfo directoryInfo = new DirectoryInfo(Server.MapPath(path));
            FileInfo[] files = directoryInfo.GetFiles("*.jpg");

            foreach (var picture in files)
            {
                Image image = new Image();
                image.Height = 200;
                image.Width = 200;
                image.ClientIDMode = System.Web.UI.ClientIDMode.AutoID;
                image.ID = string.Format(@"Image_{0}", picture.Length);
                image.ImageUrl = string.Format("{0}/{1}", path, picture.Name);
                image.Attributes.Add("onclick", string.Format(@"ShowImageInOriginalSize('{0}')", image.ClientID));
                ImageResultDiv.Controls.Add(image);
            }
        }

Das Ganze kann dann noch mit ein wenig JavaScript (JQuery) gepfeffert werden und sie dann auch entsprechend schön aus (sofern man das entsprechende Thema anhand der JQueryUI Hilfe eingebunden hat).

    <script type="text/javascript">
        function ShowImageInOriginalSize(imageClientId) {
            var image = $('#' + imageClientId + '');

            var modalPopUpImage = $('#ModalPopUpImage');
            modalPopUpImage[0].width = image[0].naturalWidth;
            modalPopUpImage[0].height = image[0].naturalHeight;
            modalPopUpImage[0].src = image[0].src;

            $('#ModalPopUp').dialog({ modal: true, height: image[0].naturalWidth, width: image[0].naturalWidth, maxHeight: image[0].naturalHeight, maxWidth: image[0].naturalWidth });
        }
    </script>

ACHTUNG:Die Stolperfalle, wenn man das angeklickte Bild dem ModalpopUp-Extender übergeben hat, dann wird es zwar angezeigt, aber nicht mehr in die Source (dort wo es angeklickt worden ist) “zurück” gelegt. Aus diesem Grund ist es wichtig ein modales Bild zu haben dass die Höhe und die Breite als 0 aufweist und erst, wenn der Dialog angezeigt wird, in die entsprechende Grösse verändert wird.

<body>
    <form id="form1" runat="server">
    <div runat="server"  id="ResultDiv">
    <div style="float:left; margin:5px;">
        <asp:Menu ID="GalleryMenu" runat="server" RenderingMode="List" 
            OnMenuItemClick="GalleryMenu_ItemClick">
        </asp:Menu>
        </div>
        <div id="ImageResultDiv" runat="server" style="float:left; position:relative; margin-left:200px; margin-top:5px;">            
        </div>
    </div>
    </form>
    <div id="ModalPopUp" style="margin-bottom:2px;">
        <img id="ModalPopUpImage" src="#" alt="Alternate Text" width="0" height="0" />
    </div>
</body>
</html>

Somit kann das “Fake”-Bildchen versteckt und spielt erst wieder eine Rolle, wenn es gebraucht wird. Für Anregungen und Kritik bin ich offen und hoffe auf Rückmeldungen.