Uli Armbruster: Schlanke Prozesse sind gute Prozesse oder warum wir Kanban einfuehren

In unserer IT Administration führen wir regelmäßige Retrospektiven durch. Das ermöglichte es uns Kategorien von Problem zu identifizieren, wie sie auf dem Bild zu sehen sind.

2015-03-04 18.36.43

  • Weniger wichtige Aufgaben wurden zuerst erledigt (Priorisierung)
  • Vermeintlich kurze Projekte haben sich stark in die Länge gezogen
  • Aufgaben wurden nicht vollständig erledigt
  • Zuständigkeiten / Ansprechpartner waren nicht klar
  • Aktuelle Projektstände waren nicht transparent
  • Aufgaben blieben bei Externen hängen bzw. blockierten uns
  • Engpässe / Verzögerungen machten uns das Leben schwer
  • Planung war schwierig
  • Häufiges “auf einen Stand bringen” und mehrfaches Besprechen gleicher Punkte

Die Systemadministration ist von Natur aus ein stark vom Tagesgeschäft abhängiges Umfeld mit viel Klein-Klein-Arbeit. Der Anwender ruft an, meldet PC Probleme (Spezifisches hört man selten), der Kollege unterbricht seine eigentliche Tätigkeit wie z.B. die Vorbereitung einer größeren Umstellung und kümmert sich um die Nöten des besorgten Anrufers. Kaum zurück und wieder in die Umstellung vertieft, kommt eine E-Mail, dass die Druckertoner leer sind. Erneut gilt es die aktuelle Arbeit zu unterbrechen.

Darüber hinaus laufen natürlich immer Projekte mit anderen Abteilungen oder Externen (Telekommunikationsanbieter, Dienstleister, etc.), die voran getrieben werden müssen. Selbst der Entwickler-Kollege aus der selben Abteilung ruft an und möchte einen neuen Testserver aufgesetzt bekommen – am besten vorgestern versteht sich.

Kurzum: Ein reges Tagesgeschäft parallel zu großen Projekten und das alles im Umfeld von unterschiedlichen Stakeholdern. So wie es auch in Marketingabteilungen oder Zentralen der Fall ist.

Nüchtern betrachtet handelt es sich um eine Warteschlangensystem. Da Menschen nicht gut darin sind viele Dinge parallel zu machen, vermuten wir hierin eine der Ursachen: Zu viele Dinge werden gleichzeitig erledigt. Außerdem stehen wir Dritten skeptisch gegenüber, welche uns rein gefühlsmäßig ausbremsen. Bei den Telekommunikationsanbietern können wir indes von einer Tatsache sprechen…Darüber hinaus meinen wir diverse weitere Hindernisse erkannt zu haben, die den Arbeitsfluss immer wieder stören.

Um weil wir uns gerne verbessern möchten, eine zu große Umstellung auf einmal eher scheuen und der Evidenz der Vermutung den Vortritt geben möchten, haben wir uns entschieden Kanban einzuführen. Auf einen Nenner gebracht liegen dem 3 Prinzipien und 5 Praktiken zu Grunde.

Prinzipien:

  • Starte mit dem, was du jetzt machst
  • Verfolge inkrementelle, evolutionäre Veränderungen
  • Respektiere initiale Prozesse, Rollen, Verantwortlichkeiten und Job-Titel

Praktiken:

  • Mache Arbeit sichtbar
  • Limitiere den WIP
  • Manage den Arbeitsfluss
  • Mach Prozess-Regeln explizit
  • Führe gemeinschaftliche Verbesserungen durch (basierend auf Modellen)

Alle Regeln werden penibel eingehalten, jedoch ist die erste Regel alle Regeln abzuschaffen, die nicht mehr funktionieren.

Über die ersten Ergebnisse werde ich demnächst berichten. Falls jemand schon gute Erfahrungen primär im Administrationsumfeld gemacht hat, dann würde ich mich über Input freuen. Gerne auch aus der Softwareentwicklung.


Einsortiert unter:CIO Topics, German, Projects Tagged: Agile / Lean, Kaizen, Kanban, Retrospektive

Uli Armbruster: Interview mit der dotnetpro mitgestalten

Am 12. März werde ich mit Tilman Börner ein Online Interview führen. Die Fragen beziehen sich natürlich primär auf die dotnetpro. Ein kleiner Vorgeschmack gefällig?

Kann jeder einfach Autor werden und einen Artikel schreiben?

oder

Wann können wir mit einer Kindle Ausgabe rechnen?

oder

Welche Änderungen sind dieses Jahr nach dem Design Relaunch noch zu erwarten?

Das Video veröffentliche ich dann auf meinem YouTube Channel. Ihr könnt die Richtung des Gesprächs mitgestalten, indem ihr bis zum 11 März eure Fragen in die Kommentare postet.


Einsortiert unter:German, Misc Tagged: Interview, Video

Uli Armbruster: Es gibt keine passive Kaizen-Kultur

Es braucht keine Retrospektiven und dedizierte Kaizen Phasen; schließlich hat das vorher auch alles geklappt und die Verbesserungen haben sich genauso eingestellt.

Aussagen wie diese hört jeder Change Agent früher oder später. Ich will gar nicht abstreiten, dass in jedem Unternehmen mehr oder weniger kontinuierlich optimiert wird. Jedoch geht durch das passive Verhalten viel Potential verloren. Das kann jeder ganz einfach kontrollieren. Der geneigte Leser soll dazu für einen kurzen Zeitraum – beispielsweise 2 Monate – jede Idee protokollieren, welche von Kollegen mit “das müssen wir mal machen” oder “das sollten wir demnächst angehen” kommentiert wird. Im Anschluss ist zu prüfen, was tatsächlich umgesetzt wurde. Ich wäre überrascht, wenn bereits 5% fertig sind. Wohlgemerkt fertig umgesetzt, nicht nur angefangen und wieder liegen gelassen. Ganz im Sinne von stop starting, start finishing. Bereits die Definition von Kaizen drückt das aus:

“Kaizen […] bezeichnet ein methodisches Konzept, in deren Zentrum das Streben nach kontinuierlicher und unendlicher Verbesserung steht.”Wikipedia

Es handelt sich um ein methodisches Konzept. Eine Methode ist ein systematisches Verfahren. Laissez faire im Kontext von Verbesserungen kann aber nicht systematisch sein. Passive Kaizen-Kultur ist also ein Widerspruch.

Ein klarer Indikator dafür für ungenutztes Potential, ist das wiederholte Auftreten des gleichen Problems. Der erste Gedanke, der einem dann kommt, ist: Mist, das wollten wir doch mal machen (siehe Aussage oben). Das können häufig kleine Dinge wie eine fehlende Fahrzeugpoolverwaltung oder eine Verwaltung für die ohnehin nicht gerade reichlichen Besprechungsräume sein. Aber auch komplexere Themen wie die hohe Informationsflut im Zeitalter der Wissensarbeit. Schon mal über eine SharePoint Dokumentenbibliothek oder ein Wikisystem nachgedacht? Und wenn ja, auch realisiert?

Unabhängig von den Implementations-Phasen solcher Ideen/Lösungen, gehören zu einer soliden Kaizen-Kultur auch Retrospektiven. Selbstverständlich werden hier wieder Stimmen laut, die behaupten, dass ich mir doch keine Zeit reservieren muss, in welcher ich reflektiere und nach Verbesserungsmöglichkeiten suche. Das ist leider eine ähnliche Floskel wie:

Wir brauchen keine Mitarbeitergespräche. Wir reden regelmäßig miteinander.

Wer sich aber mit den Themen intensiv beschäftigt und ganz darauf einlässt, stellt einen großen Unterschied fest. Persönlich habe ich sogar den Eindruck, dass durch kurze, oberflächliche Problemanalyse Lösungen entwickelt werden, die das Symptom kaschieren, nicht aber aber die Ursache beheben. Als Change Agent hat sich in dem Fall die sokratische Methode bewährt. Stelle solange W-Fragen (Warum, Wer, Was) bis – wie Goethe sagt – des Pudels Kern gefunden ist.

Der Leser kann sich dazu kurz in Erinnerung rufen wie es bei der Zulassungsstelle bei einer Ummeldung abläuft. An dem einen Schalter beantragt man die Anmeldung. Mit dem Papier geht man an den Schalter neben an. Natürlich muss dort wieder angestanden werden. Nach einer meist längeren Wartezeit wird dort das alte Schild vernichtet und das neue ausgegeben. Damit läuft man wieder an den ersten Schalter und nach noch längerer Wartezeit erhält man dann endlich die Papiere.

Wenn ich jetzt danach frage, wie sich der Prozess optimieren lässt, dann kommt ohne lange Überlegung die Antwort: Na indem am Schalter schneller gearbeitet oder mehr Personal eingestellt wird. Überstunden wären ebenfalls möglich. Das sind zwar alles Optionen, allerdings lange nicht die besten, da diese nur sehr beschränkt skalieren und teuer sind. Vielleicht ist das der Grund, warum bis heute die meisten Kfz Halter sich einen halben Tag Urlaub für das Ummelden nehmen müssen. Eine mathematisch nachweislich bessere Antwort gibt es hier.

Fazit

Keine Frage: Es braucht kleine, kontinuierliche Verbesserungen, damit die Unternehmen diese verdauen können. Evolution statt Revolution (manchmal auch letzteres!). Aber Evolution im Schneckentempo gleicht eher einem Rückschritt, weil die anderen schneller voran kommen. Wer jeden Tag 30 Minuten ins Fitnessstudio geht und sonntags ruht, hat am Ende der Woche auch 3 Stunden trainiert. Und genauso wie Trainings als feste Termine eingeplant werden müssen, bedarf es auch fester Zeiten für Retrospektiven und die Umsetzung der daraus resultierenden Ergebnisse.

Und wenn der Leser immer noch motiviert ist, dann kann er gerne einen Kommentar hinterlassen, ob in seinem Unternehmen bereits Kaizen an der Tagesordnung ist oder nicht und warum respektive warum nicht.


Einsortiert unter:CIO Topics, German Tagged: Kaizen, Retrospektive

Martin Richter: Advanced Developers Conference zu native C++ in München Erding vom 05.-06. Mai

Die Konferenz wird unter dem Thema Doing C++ The Right Way stehen. Bernd Marquardt wird als Content Manager mit für den Inhalt verantwortlich sein.

Da die Agenda noch nicht sehr voll ist, bin ich auf die endgültige Themenauswahl doch gespannt. C++11 ist ja fast schon ein alter Hut und Parallelisierung wird auch schon etwas langweilig. ;) Es stehen zumindest altbekannte Namen auf der Rednerliste.

Veranstalter ist die ppedv AG (hinter der Johannes Preishuber steht). Ich habe die Konferenzen der letzten Jahre, an denen ich teilgenommen habe, immer in guter Erinnerung. Sowohl in der Auswahl der Themen und Redner, als auch in der exzellenten Durchführung, mit immer sehr schon gewählten Konferenzorten und Hotels. Letztes Jahr hätten es ein paar mehr Leute sein können, aber das zeitgleiche Champions-League Spiel in München hat doch vielen einen Strich durch die Rechnung gemacht, weil es keine freien Hotelzimmer mehr gab.

Ich denke die Konferenz lohnt sich sicherlich.
Und ganz gespannt bin ich persönlich auf die Abendveranstaltung am Mittwoch, denn hier wird auf den ADC-Konferenzen den Teilnehmern immer etwas wirklich außergewöhnliches geboten und auch diesmal wird wieder zu etwas “Speziellem” eingeladen. Letztes Jahr das Essen in der Flugwerft Schleißheim war schon etwas besonderes.

Ich freue mich auch dieses Jahr wieder dabei sein zu können; alte Kontakte beleben zu können, neue Entwickler kennen zu lernen und Neues aus der C++ Welt zu hören.

ADC

 


Copyright © 2010 Martin Richter
Dieser Feed ist nur für den persönlichen, nicht gewerblichen Gebrauch bestimmt. Eine Verwendung dieses Feeds bzw. der hier veröffentlichten Beiträge auf anderen Webseiten bedarf der ausdrücklichen Genehmigung des Autors.
(Digital Fingerprint: bdafe67664ea5aacaab71f8c0a581adf)

Christian Binder [MS]: Open ALM: Lösungen mit TFS und VSO integrieren

Open ALM - Das Ziel ist, eine Plattform zu schaffen, welche über Industriestandards einfach erweiterbar ist und somit die Integration anderer Tools und Plattformen ermöglicht.

image

Zu diesem Zweck haben wir, Ulli Stirnweiß (Lead der .NET User Group Franken) und Karsten Kempe (MVP für Visual Studio ALM), das Thema REST API’s, OAuth 2.0 und Service Hooks mit VSO und TFS 2015 näher beleuchtet. Es gibt schon eine ganze Reihe von VSO Integrationen, die auf diesen Industriestandards aufsetzen - eine Übersicht gibt es hier. Unter folgendem Link findet Ihr ein Video zum Einstieg und Blog Posts zu den VSO REST API’s, OAuth 2.0 und Service Hooks.

Chris

Marco Scheel: Links for 2015-03-04 [del.icio.us]

Jens Häupel [MS]: Office 2010 VSTO Add-Ins mit .NET Framework 4.5?

Um mit Visual Studio 2013 bei VSTO Add-Ins die Version 4.5 des .NET Frameworks verwenden zu können, muss mindenstens Update 3 installiert sein. Wenn der Updatestand kleiner ist, werden beim Umschalten auf Version 4.5 alle 2010er Templates deaktiviert.

image

Update 4 ist derzeit übrigens aktuell.

 

Marco Scheel: Links for 2015-03-03 [del.icio.us]

Code-Inside Blog: Keep your test data with your tests

This post might lead to a religious debate (“What is the boundary of a Unit-Test?”, “You could mock that!”, “Unit Tests sucks…”, “You suck!” ) or to a simple “Yeah… I’m doing this… since forever…”, but the goal of this post is pretty simple: Making testing with “real world data” inside Unit-Tests easier with a simple trick.

The Problem (Long story…)

A while ago I needed to write a program which “synchronize” data from LDAP to another directory based on different rules. At first I needed to write the code to get the data from the LDAP and the code to store it inside the other directory, which was really low level plumbing. Now I needed to make sure my rules are applied correctly and that only certain users were synchronized. So this was a perfect fit for tests, right? I started with simple “fake” LDAP mocks, but soon I needed real world data to see if my logic was still correct.

I made the decision to map the incoming “System.DirectoryService.DirectoryEntry” to my own model, which I could also serialize as JSON, and used this inside my logic.

With this in place I could easily serialize our “Test-LDAP” and use that JSON in my own tests, so no mocking (at least no manual - in code - mocking), just real data.

Where should I put the sample-data?

Now the question is: Where should I store the sample data? I think such data should be very close to the actual test code. If you point to files on your disk you are doing it wrong. Why? Because the files are only on your machine and your build- or co-worker-machine didn’t have this file and tests will fail. If you hit the file system in your test you should be very careful. Ok, so you could do some Kung-Fu with build scripts, but this is pretty hard to maintain in my opinion.

The Solution

The solution to this problem is pretty simple, but I didn’t thought about it in a test project at first: Embedding the test data inside the assembly as a resource! Like you do it with other resources (images, localizations etc.)

x

Real world data!

Long story short, I used the same approach in this project, where I needed to parse Atom/Rss-Feeds and didn’t want to pollute the test code with hand crafted feeds. My tests projects there looks like this:

x

The sample files contains actual “real” Atom/Rss-Feeds.

Code

Whenever I need the test data I can now get it like that:

string gitHubAtomSamplePath = "FeedCrawlerTests.Samples.GitHubAtom.xml";
var staticFeed = SyndicationFeed.Load(new XmlTextReader(TestHelperForCurrentProject.GetTestFileStream(gitHubAtomSamplePath)));

With this “TestHelper”:

public static class TestHelperForCurrentProject
{
    private const string ResourcePath = "Sloader.Tests.{0}";

    public static Stream GetTestFileStream(string folderAndFileInProjectPath)
    {
        var asm = Assembly.GetExecutingAssembly();
        var resource = string.Format(ResourcePath, folderAndFileInProjectPath);

        return asm.GetManifestResourceStream(resource);
    }

    public static string GetTestFileContent(string folderAndFileInProjectPath)
    {
        var asm = Assembly.GetExecutingAssembly();
        var resource = string.Format(ResourcePath, folderAndFileInProjectPath);

        using (var stream = asm.GetManifestResourceStream(resource))
        {
            if (stream != null)
            {
                var reader = new StreamReader(stream);
                return reader.ReadToEnd();
            }
        }
        return String.Empty;
    }

}

Set the Build-Action to: Embedded Resource!

You just need to set the Build-Action to “Embedded Resource” to get this to work (of course).

x

Easy, right?

Marco Scheel: Links for 2015-03-02 [del.icio.us]

Karsten Kempe: 10 Jahre TFS – ALM Days 2015

ALM-Days15-Webbanner-336x200pxNächste Woche ist es soweit. Microsofts ALM Plattform der Team Foundation Server feiert seinen 10ten Geburtstag und wir feiern mit. Die ALM Days in Düsseldorf bieten dafür den perfekten Rahmen. In mehr als 30 Vorträgen können sich die Teilnehmer tagsüber über Neuigkeiten und Best Practices rund um agile Software Entwicklung und Application Lifecycle Management informieren und nachts das Jubiläum des TFS feiern.

Ich werde ebenfalls meinen Teil zum Gelingen der Veranstaltung beitragen und zu unterschiedlichen Themen mein Wissen weitergeben. Am ersten Konferenz-Tag könnt Ihr Euch in meinem Vortrag TFS 2015 – Versionsverwaltung mit Git über die Neuigkeiten der verteilten Versionskontrolle in Kombination mit dem TFS informieren. Am zweiten Tag werde ich zusammen mit Ulli Stirnweiss über die Integrationsmöglichkeiten der ALM Plattform berichten und zum Abschluss mit Rene Schumacher und Thomas Rümmler einen Deep Dive in die Anpassungsfähigkeit des TFS geben.

Die Agenda der ALM Days findet ihr hier.

 

ALM Days im Van der Valk Hotel Düsseldorf

Es war nie einfacher Anwendungen zu entwickeln, zu testen und bereitzustellen. Was vor einigen Jahren noch mit komplizierten Prozessen und großem Aufwand verbunden war, lässt sich in einer Welt von Cloud Services und App Stores häufig mit wenigen Klicks erledigen. Die gesamte Softwareindustrie ist deutlich schneller und dynamischer geworden, und wir erleben immer kürzere Innovations- und Releasezyklen – ganz gleich ob in agilen Startups, traditionellen Industrieunternehmen oder der Automobilbranche.

Für Entwickler-Teams bringt die Veränderung hin zu dynamischeren Märkten und diversifizierten Plattformen neue Anforderungen mit sich. Viele Unternehmen haben darauf bereits reagiert und agile Methoden etabliert, mit denen sich kürzere Zyklen realisieren lassen. Der nächste Entwicklungsschritt „DevOps“ erweitert das Konzept der agilen Softwareentwicklung und bezieht den IT-Betrieb mit ein. Damit die Zusammenarbeit aller Projektbeteiligten reibungslos funktioniert, ist aber auch ein tiefgreifender organisatorischer Wandel nötig. Nur so kann letztlich das erreicht werden, was als „Continuous Delivery“ und „Continuous Learning“ beschrieben wird: kundennahe Softwareentwicklung, die auf Informationen aus dem laufenden Betrieb reagieren kann und Investitionsentscheidungen auf Basis von Telemetriedaten ermöglicht. Damit Sie schnell qualitativ hochwertige Software bereitstellen können.

Johannes Renatus: Unit Test AngularJS directive mit templateUrl in VS und Chutzpah

Damit meine eigenen Direktiven übersichtlich bleiben, lege ich die Templates immer in einer extra HTML Datei ab und verwende entsprechend die “templateUrl” in meinen Direktiven. Leider ist das Füllen des AngularJS Templatecaches mit Chutzpah ein klein wenig umständlicher als wenn man Karma und dem ng-html2js Präprozessor zum füllen des AngularJS Templatecaches verwendet. Da ich bei […]

Kazim Bahar: Visual Studio 2015 mit neuen Tools und Optimierungen für WPF

Wer hätte das gedacht. Microsoft investiert wieder Zeit für das Tooling des in der Vergangeheit stark vernachlässigten WPF Frameworks. Das...

Fabian Deitelhoff: LEGO Mindstorms EV3: Einsteigerkurs bei der VHS Menden

Am Samstag den 17. Januar 2015 war es mal wieder so weit. Um 09.30 Uhr versammelten sich interessierte Kinder, Jugendliche und Erwachsene, um mehr über den LEGO Mindstorms EV3 zu lernen. Der Kurs, der sich an Einsteiger und Einsteigerinnen jeglichen Alters richtete, ging bis 16.30 Uhr und bot somit reichlich Zeit, etwas über EV3 zu lernen und Neues auszuprobieren. Natürlich kamen auch Diskussionen zwischen den Teilnehmern und Teilnehmerinnen nicht zu kurz.

Dieses Mal war sogar genug Zeit für eigene Roboter-Kreationen, bei denen insbesondere die jüngeren ihrer Kreativität freien lauf lassen konnten. :)

Der Kurs

Die Gruppe bestand, exklusive mir, aus 15 Personen, was eine sehr ordentlich Größe war. Das Feld war durchmischt, sowohl das Alter betreffend, als auch eventuell vorhandene Vorkenntnisse mit dem LEGO Mindstorms EV3. Erfreulicherweise konnte sich die VHS Menden-Hemer-Balve zusätzliche LEGO Mindstorms EV3 ausleihen. Zwei Stück von der VHS Dortmund und drei weitere von der VHS Soest. So hatten wir insgesamt neun LEGO Mindstorms EV3 zur Verfügung, wenn ich mich nicht verrechnet habe. So viele wie in noch keinem Kurs zuvor, den ich geleitet habe. An dieser Stelle noch einmal vielen Dank an die VHS Dortmund und die VHS Soest!

Inhaltliches

Inhaltlich ging es, wie der Titel des Kurses schon vermuten lässt, um eine Einführung in die Welt des LEGO Mindstorms EV3. Dazu zählt ein kurzer Überblick über das LEGO Mindstorms-Universum und grundlegende Eigenschaften der Hard- und Software. Dieser Teil ist Erfahrungsgemäß immer recht schnell vorbei, denn in den Kursen geht es ja darum, den LEGO Mindstorms EV3 aus einem praktischen Blickwinkel kennen zu lernen.

Abb. 1: Teilnehmer und Teilnehmerinnen des LEGO Mindstorms Kurses. Abb. 2: Teilnehmer und Teilnehmerinnen des LEGO Mindstorms Kurses.

Dem EV3 Leben einzuhauen war somit der größte inhaltliche Block dieses Tages. Es gab verschiedene Aufgaben, wie einen Slalom fahren, mittels Sensoren Gegenständen ausweichen, sowie allgemeines zur Programmierung und über die EV3-Entwicklungsumgebung von LEGO. Eine Teilnehmer-Gruppe hat sogar eine Linienverfolgung programmiert. Etwas, was ich so erst in einem fortgeschrittenen Kurs geplant habe. Was wieder einmal beweist, wie viel die Kinder und Jugendlichen auf die Beine stellen können, wenn es spielerisch vermittelt wird.

Hier noch zwei Fotos von eigenen EV3-Kreationen, die von den Kindern während des Kurses gebaut wurden. Immer wieder beeindruckend. Abbildung 5 zeigt auch gleichzeitig den Untergrund mit dem Linienmuster für das Programm zur Linienverfolgung.

Abb. 3: Eigene EV3-Kreation eines Teilnehmers. Abb. 4: Eigene EV3-Kreation eines Teilnehmers. Abb. 5: Eigene EV3-Kreation eines Teilnehmers.

Fazit

Mir hat es wiedereinmal sehr viel Spaß gemacht. Die Teilnehmer und Teilnehmerinnen waren super gelaunt und haben prima mitgemacht. Ganz vorne mit dabei waren wie immer die Kinder und Jugendlichen, von denen auch der ein oder andere Erwachsene noch etwas lernen konnte. ;)

Zwischendrin war sogar die Presse vor Ort. Der Artikel ist online verfügbar.

Manfred Steyer: Folien und Beispiele zu meiner Session über das Erweitern von Entity Framework auf der BASTA! Spring 2015

Nachfolgend findet man die Folien und Beispiele zu meiner Session über das Erweitern von Entity Framework, welche ich auf der BASTA! Spring 2015 gezeigt habe. Die Beispiele zeigen:

  • Die Nutzung von EntityFramework.DynamicFilters zum Implementieren von Soft-Delete
  • Eine Variante des Beispiels, das Rowan Miller auf der TechEd 2015 zum Thema Entity Framework und Soft-Delete gezeigt hat
    • Das Beispiel ist ein wenig leichter verdaulich, als jenes von Rowan, dafür aber auch weniger mächtig
    • Das Beispiel hängt an jede Abfrage einen Filter für das Deleted-Flag an und wandelt DELETE-Anweisungen in INSERT-Anweisungen um
  • Die prinzipielle Nutzung von DbCommandInterceptor
  • Die prinzipielle Nutzung von DbCommandTreeInterceptoren
  • Die Nutzung von EntityFramework.Cache
  • Die Nutzung von EntityFramework.Extended für Batch-Updates
  • Die Funktionsweise von EntityFramework.Extended anhand einer einfachen eigenen Implementierung der Erweiterungs-Methode Delete
  • Die Nutzung eines eigenen SqlMigrationGenerators zum Generieren von Historisierungs-Tabellen


Downloads


Albert Weinert: IdentityServer V3 und eigene Dependency Injection mit OWIN

Der Identity Server v3 ist ein OAuth2 und OpenID Connect Framework welches einem die Serverseitige Implementierung von OAuth2 und OpenID Connect abnimmt. Im Gegensatz zu vorheringen Versionen steht hier das konzept klar auf Erweiterbarkeit und weg vom Monolitischen Ansatz wo Server und Administration vereint sind.

Der IdServerV3 ist eine reine ASP.NET Web API Lösung, und benutzt intern Autofac um selbst ordentlich mit Dependency Injection und IoC arbeiten zu können. Dies stellt jedoch eine kleine Herausforderung dar dies in der bestehenden Anwendung die schon mit IoC arbeitet zu verwenden, da IdServerV3 es nicht erlaubt den bestehenden IoC Container einfach einzustöpseln. Da es ohne Aufwändige IoC Konfiguration laufen soll kann man diese Entscheidung auch nachvollziehen.

TL;DR

Wie schaffe ich es nun mit einem eigenen IoC zu arbeiten?

Füttern des IoC Containers von IdServerV3

Es gibt im IdServerV3 die IdentityServerServiceFactory, damit kann man die Services die man für den Identity Server selber implementieren will oder muss (weil man z.B. eine eigene Administration und Datenhaltung hat).

var factory = new IdentityServerServiceFactory  
{
    UserService = new Registration<IUserService,IdentityServerUserService>(),
    ClientStore = new Registration<IClientStore, IdentityServerClientStore>(),
    ScopeStore = new Registration<IScopeStore,IdentityServerScopeStore>()
};

Hiermit registriert man den UserService, ClientStore und ScopeStore, diese braucht der IdServerV3 auf jedenfall, für den Produktionsbetrieb noch ein paar weitere.

Jedoch wird bei der Service Erstellung nun der interne Autofac Container verwendet. Und nicht der IoC Container der Applikation. Damit die funktioniert kann mann über nun die eigenen Services auch dem internen Container bekannt machen. Und natürlich auch dessen abhängikeiten.

Dazu kann man.

factory.Register(new Registration<IFoo,Foo>())  

verwenden. Dies ist jedoch nicht zu empfehlen, da man so sehr viele eigene Services auch noch im IdServerV3 Container registrieren muss. Jedoch viel wichtiger, weil so das LifeCycle Managment des IoC Containers ausgehebelt wird und man nun effektiv 2 IoC in der Anwendung hat und jeder seinen eigenes LifeCycle Managment hat und eigene Instanzen erzeugt. Dies führt über kurz oder lang zu Problemen.

Lösungansatz

Ein mögliche Lösung ist nun eine Factory Methode bei der Registrierung anzugeben, dies wird dann vom IdServerV3 Containers bei der Erzeugung des Services aufgerufen.

Variante 1 (so nicht verwenden)

var factory = new IdentityServerServiceFactory  
{
    UserService = new Registration<IUserService>(dr => mycontainer.GetInstance<IUserService>()),
    ClientStore = new Registration<IClientStore>(dr =>  mycontainer.GetInstance<IClientStore>()),
    ScopeStore = new Registration<IScopeStore>(dr =>  mycontainer.GetInstance<IScopeStore>())
};    

Dies ist prinzipiell funktionsfähig, jedoch arbeitet man hier mit einer bestimmten Instanz des Container, und war immer mit derselben. Was wieder dem LifeCycle Managment wiederspricht da so nicht der Scoped-Container von WebAPI verwendet wird. Und somit im Zweifel nicht jeder Request seine eigenen Instanzen hat und diese auch nicht beim Ende des Request wieder Disposed werden. Also nicht nachmachen.

Variante 2

Es ist notwendig für die Request die zum IdentityServer gehen einen eigenen Scope des IoC Containers aufzumachen und wieder zuschließen um dann in der Registrierung Methode darauf zuzugreifen. Da jedoch IdServerV3 selbst einen IoC Container verwendet, sollte man dies in einer Form machen die damit nicht zusammstößt.

Eine einfache IdServer-OWIN Konfiguration

app.Map("/identity", idsrvApp =>  
{
    var factory = new IdentityServerServiceFactory
    {
        UserService = new Registration<IUserService,IdentityServerUserService>(),
        ClientStore = new Registration<IClientStore, IdentityServerClientStore>(),
        ScopeStore = new Registration<IScopeStore,IdentityServerScopeStore>()
    };
    idsrvApp.UseIdentityServer(new IdentityServerOptions
    {
        SiteName = "Embedded IdentityServer",
        SigningCertificate = LoadCertificate(container),
        Factory = factory,
    });
});    

Ziel ist es nun in der Registrierung-Methode mit dem Applikations spezifischen Scoped-Container zu bestücken.

Dazu müssen wir in ersteinmal pro Request einen eigenen Scoped-Container haben, dazu erstellen wir eine kleine OWIN Middleware. Damit dies jetzt nicht IoC-Container spezifisch ist, nehmen wir den IDependencyResolver der schon in der WebAPI Verwendung findet.

internal class DependencyResolverMiddleWare  
{
    readonly private Func<IDictionary<string, object>, Task> m_next;
    readonly IDependencyResolver m_resolver;

    public DependencyResolverMiddleWare(Func<IDictionary<string, object>, Task> next, IDependencyResolver resolver)
    {
        m_next = next;
        m_resolver = resolver;
    }

    public async Task Invoke(IDictionary<string, object> env)
    {
        var context = new OwinContext(env);
        using (var scope = m_resolver.BeginScope())
        {
            context.Request.Set("ioc.dependencyScope", scope);
            await m_next(env);
        }
    }
}

Im Endeffekt rufen wir beim Invoke den DependencyResolver.BeginScope um den Scoped Container zu erzeugen, speichern ihn zwischen, rufen den nächsten Schritt in der Pipeline auf (am besten IdentityServer) und disposen den Scope wenn der zurück kommt.

Dieser muss nur noch in der Pipeline vor dem IdentityServer registriert werden. Dann können wir auf den zwischengespeicherten Scope in der Registration-Methode darauf zugreifen.

app.Map("/identity", idsrvApp =>  
{
    // ...
    idsrvApp.Use<DependencyResolverMiddleWare>(container.GetInstance<System.Web.Http.Dependencies.IDependencyResolver>());
    idsrvApp.UseIdentityServer(/*..*/);
});

Jetzt muss man nur noch an den Request spezfischen Scope kommen. Dazu muss man an das OwinEnviroment kommen, das IDictionary wo alles drin steht was man braucht.

Diesen kann man sich nun über den IdentityServer eigenen IDependencyResolver holen, der wird praktischerweise der Registration-Methode übergeben.

var owin = (OwinEnvironmentService)resolver.GetService(typeof(OwinEnvironmentService));  
var value = owin.Environment["keytoget"];  

Daraus könnte man sich nun direkt den Scope-Container rauspulen, jedoch muss man sich dann die die Keys wühlen und da erstmal zum Request und weiter. Zum Glück gibt es Hilfsklassen die einem den typisierten Zugriff darauf erlauben.

var owin = resolver.Resolve<OwinEnvironmentService>();  
var context = new OwinContext(owin.Environment);  
var scope = context.Request.Get<System.Web.Http.Dependencies.IDependencyScope>("ioc.dependencyScope");  

und schon ist man im Besitz des Scoped-Containers der in der Middleware erzeugt worden ist.

Zwecks einfacher Verwendung kann man dies nun schön in einer Extensionmethod unterbringen.

public static T GetInstanceFromApplicationDependencyResolver<T>(this Thinktecture.IdentityServer.Core.Services.IDependencyResolver resolver)  
{
    var owin = resolver.Resolve<OwinEnvironmentService>();
    var context = new OwinContext(owin.Environment);
    var scope = context.Request.Get<System.Web.Http.Dependencies.IDependencyScope>("ioc.dependencyScope");
    return (T)scope.GetService(typeof(T));
}

so kann man dies dann einfach verwenden.

app.Map("/identity", idsrvApp =>  
{
    var factory = new IdentityServerServiceFactory
    {
        UserService = new Registration<IUserService>(dr => dr.GetInstanceFromApplicationDependencyResolver<IUserService>()),
        ClientStore = new Registration<IClientStore>(dr => dr.GetInstanceFromApplicationDependencyResolver<IClientStore>()),
        ScopeStore = new Registration<IScopeStore>(dr => dr.GetInstanceFromApplicationDependencyResolver<IScopeStore>())
    };
    idsrvApp.Use<DependencyResolverMiddleWare>(container.GetInstance<System.Web.Http.Dependencies.IDependencyResolver>());
    idsrvApp.UseIdentityServer(new IdentityServerOptions
    {
        SiteName = "Embedded IdentityServer",
        SigningCertificate = LoadCertificate(),
        Factory = factory
    });
});

Natürlich müssen die Services und auch der IDependenyResolver im Applikations Container vorhanden sein, aber dies versteht sich von selbst.

Variante 3

Was meinst Du?

codefest.at [MS]: Women Techmakers 2015 und Workshop für Kinder

Rechtzeitig zum Weltfrauentag findet das zweite Women Techmakers Event in Österreich statt. Ziel dieses Events ist es die Awareness in Genderfragen in den STEM Disziplinen (science, technology, math & engineering) und die Sichtbarkeit von Frauen in diesen Bereichen zu erhöhen. Das Event ist offen für alle.

image

Das Event findet am 7. März bei uns im Microsoft Office statt. Es erwarten euch spannende technische Vortrage, Workshops und Diskussionen. Natürlich könnt ihr dabei jede Menge interessante Leute kennenlernen.

Neu ist heuer auch, dass ein Workshop für Kinder angeboten wird, in dem man spielerisch Spieleprogrammierung mit dem am MIT entwickelten SCRATCH lernen kann.

Mehr Infos und Anmeldung findet ihr auf WomenTechmakers.at.

Sebastian Gross: Using Google Open Auth Login in Asp.Net MVC Applications

Introduction

Open Auth is everywhere, maybe you even read my article on how to retrieve calendar events from your google calendar using open auth. In this article i would like to show you a simple way to create an open auth login for your asp.net mvc website.

Basically you can just open up visual studio and create a new asp.net mvc project and select individual user as the authentication template. Visual studio will now create a new project template for you with working examples for Google, Facebook and Microsoft open auth login.
But as you’ll quickly notice this is a very complex example which is only good for authentication, so if you want to have different information about the user (i.e. his picture) or want to perform actions in his name (post to the wall in facebook) you’re out of luck.
This is where this article comes into play. We will create an authentification mechanism which will allow us to have additional rights next to simple authentication while keeping the codebase small and clean.

Token setup

Before you can start writing code you first need to create public and private keys to authenticate your application to google. I covered this topic at my last article, so if you dont have your tokens yet, just follow the link and read through the chapter “API Setup”. Afterwards continue here.

Communication overview

So lets have a look on the order of events which will take place in our application.

  • Our application gets called and checks if the authentication cookie is set. Since its the first call to our application the cookie is not present. The application redirects the user to the login page.
  • The login page offers the user to login using open auth with google as the provider. The user clicks on the link to login via google.
  • The click directs the user to the login url /auth/googlelogin
  • The API takes the user to the google consent screen (you neet to login to your google account first)
  • The user allows our application to access the requested information (basic user info) and is being redirected back to our application
  • Now we’re back in the auth/googlelogin method and can check wether the provided google informations are known to our database. If yes -> login, if no -> signup

Project setup

Open up Visual Studio and create a new Asp.Net MVC (5) project, be sure to select an empty project template without athentication to make sure we start with a clean codebase.

Create an empty MVC Project
New Project temaplate

Create a new (almost) empty MVC Project

Of course you need some kind of database to store your registered users. I won’t cover the topic of setting up a database in this article but i would recommend you to use EntityFramework in order to create a simple database very quickly without a lot of configuration.

Now we can begin to setup our authentication methods, but since we will be using the Google API for this we need to install the Google libraries first. Just start up the NuGet Package Manager Console and install the following packages:

Install-Package Google.Apis.Auth
Install-Package Google.Apis
Install-Package Google.Apis.Auth.Mvc
Install-Package Google.Apis.Plus.v1

NuGet will now download and add the libraries to our project. After NuGet is done you should have (among others) the following libraries under your project references:

Google.Apis
Google.Apis.Auth
Google.Apis.Auth.Mvc4
Google.Apis.Auth.PlatformServices
Google.Apis.Core
Google.Apis.PlatformServices
Google.Apis.Plus.v1

Just that you know, we don’t actually need the Plus.v1 package for successful authentication, but since i would like to know the users name, profile picture and other basic information i added this dependency too. Without this package we (as the application) would only get to know the google account id, which is the E-Mail Address by default. if this is enough for you just don’t add the last package to your project.

Authentication

First we need some Model to hold our user information which (if you use EntityFramework) also can be used as an Entity-Class to access the database. This could look something like this:

public class UserProfile
{
    [Required(ErrorMessage="Please tell us your name")]
    [DisplayName("Your name")]
    public string Name { get; set; }

    [Required(ErrorMessage = "Choose a displayname for you")]
    [DisplayName("Displayname")]
    public string DisplayName { get; set; }

    public string Picture { get; set; }

    [Required(ErrorMessage = "Please enter an E-mail address")]
    [DisplayName("E-Mail-Address")]
    [RegularExpression("([a-zA-Z0-9]+@[a-zA-Z0-9]+\.[a-zA-Z0-9]+)", 
        ErrorMessage = "Please provide a valid E-mail address")]
    public string Email { get; set; }

    [Key]
    [Required]
    public string UniqueId { get; set; }

    public IdentityProvider Provider { get; set; }
}

//maybe we will support more providers later ;)
public enum IdentityProvider
{
    Google = 0,
    Twitter = 1,
    Facebook = 2
}

Nothing special here, just some properties to hold the basic user information including some validation tags to make MVC do the dirty work.

Lets go ahead and create the AuthController with the GoogleLogin method:

public async Task<ActionResult> GoogleLogin(CancellationToken cancelToken)
{
    var result = await new AuthorizationCodeMvcApp(this, 
                    new GoogleAuth()).AuthorizeAsync(cancelToken);

    if (result.Credential == null)
        return new RedirectResult(result.RedirectUri);

    var plusService = new PlusService(new BaseClientService.Initializer
    {
        HttpClientInitializer = result.Credential,
        ApplicationName = "MyApp"
    });
	
    //get the user basic information
    Person me = plusService.People.Get("me").Execute();

    //check if the user is already in our database
    UserProfile account = _db.Users.FirstOrDefault(u => u.UniqueId.Equals(me.Id));
    if(account == null){
        //this is a new user -> register view
        UserProfile profile = new UserProfile(){
            Name = me.Name.GivenName + " " + me.Name.FamilyName,
            Email = me.Emails.ElementAt(0).Value,
            DisplayName = me.DisplayName,
            Picture = me.Image.Url,
            UniqueId = me.Id,
            Provider = IdentityProvider.Google
        };
        TempData["newProfile"] = profile; 
        return RedirectToAction("register", "account");
    }else{
        //this is a registered user -> login
    }
    return RedirectToAction("index", "home");
}

The important part is happening in the first lines of this Action-Method. We create a new AuthorizationCodeMvcApp and provide an new instance of GoogleAuth to it. The GoogleAuth Class extends the FlowMetadata Class provided by the Google API and overrides Flow property which provides the client secret and the needed app privileges to the API.

public class GoogleAuth : FlowMetadata
{
    private static readonly IAuthorizationCodeFlow flow =
        new GoogleAuthorizationCodeFlow(new GoogleAuthorizationCodeFlow.Initializer
        {
            ClientSecrets = new ClientSecrets
            {
                ClientId = "my-app-client-id.apps.googleusercontent.com",
                ClientSecret = "my-app-client-secret"
            },
            Scopes = new[] {
                PlusService.Scope.UserinfoEmail,
                PlusService.Scope.UserinfoProfile
            },
            DataStore = new FileDataStore("Google.Apis.Sample.MVC")
        });

    public override string GetUserId(Controller controller)
    {
        return "user1";
    }

    public override IAuthorizationCodeFlow Flow
    {
        get { return flow; }
    }
}

The Google API provides an own controller which is responsible for receiving the authentication response. In order to use it we need to provide our implementation of FlowMetadata (see above) to it:

public class AuthCallbackController :
        Google.Apis.Auth.OAuth2.Mvc.Controllers.AuthCallbackController
{
    protected override Google.Apis.Auth.OAuth2.Mvc.FlowMetadata FlowData
    {
        get { return new GoogleAuth(); }
    }
}

And thats basically it. Since the API is doing most of the heavy lifting of redirecting and receiving the callback we’re finished here. Just add a Db-Provider (i.e. EntityFramework) and some Views alongside with some Account-managing-Controller and you’re ready to go.

You can find a working web application using this example in my github repo.

codefest.at [MS]: Neue OneDrive API

Es geht dahin: Microsoft hat die neue OneDrive API veröffentlicht, mit welcher Developer OneDrive in eigene Apps integrieren können. Diese ist für alle größeren Plattformen wie Web, Windows, iOS und Android verfügbar. Mit der neuen RESTful API können so Daten aus und in den Microsoft Cloud Speicher eines Benutzers gelesen und geschrieben werden.

Hier geht es zur Ankündigung im blog.onedrive.com: The new OneDrive API

image

Der Download ist auf GitHub verfügbar: Introducing the new OneDrive API

Microsoft selbst setzt die neue OneDrive API auch für eigene Projekte ein. Developer können so die gleiche Bibliotheken wie Microsoft benutzen und profitieren von neuen Versionen.

Unter aka.ms/OneDriveAPI gibt es die Dokumentation und Code Samples, wie etwa das Beispiel Picker and saver SDKs, welches zeigt, wie man Dateien liest und schreibt.

Cool finde ich auch die interaktive API Console, wo man gleich ausprobieren kann…

image

Hinweis: OneDrive ist nicht ident mit OneDrive for Business – welches den persönlichen Speicher in Office 365 bereitstellt (und eigentlich eine SharePoint Site ist). Dafür gibt es auch schon bereits mit der Office 365 API eine Bibliothek, siehe hier.

Viel Spaß beim Ansehen der neuen OneDrive API!

Manfred Steyer: Folien und Quellcode zu meinem Vortrag über Microservices mit ASP.NET MVC 6 auf der BASTA! Spring 2015

Nachfolgend findet man meine Folien und Beispiele, die ich heute bei meinem Vortrag über Microservices mit ASP.NET MVC 6 und Azure Service Bus auf der BASTA! Spring 2015 verwendet habe:


Code-Inside Blog: FAKE: Running xUnit Tests with FAKE without knowing a tiny bit of F#

This is a follow-up to my first FAKE post “FAKE: Building C# projects without knowing a tiny bit of F#”.

xUnit Test Project

We start with a simple test project, which is basically a normal library project, and add xUnit via NuGet.

x

The actual test is just stupid, but should work for the demo:

public class FoobarTests
{
    [Fact]
    public void DoAStupidTest()
    {
        Assert.True(true);
    }
}

Get the xUnit Runners

Next we need the xUnit runner (to run the tests…), which can be installed via NuGet on the Solution Level.

x

If you do this via the UI you should see a package.config in your solution directory:

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="xunit.runners" version="1.9.2" />
</packages>

Adding the test to the build.fsx script

This time I will only show the important parts for the tests (skipping the targets from the first post).

// include Fake lib
...

// Properties
...
let artifactsTestsDir  = "./artifacts/tests/"

// Targets
Target "BuildTests" (fun _ ->
trace "Building Tests..."
!! "**/*Tests.csproj"
  |> MSBuildDebug artifactsTestsDir "Build"
  |> Log "TestBuild-Output: "
)

Target "RunTests" (fun _ ->
    trace "Running Tests..."
    !! (artifactsTestsDir + @"\*Tests.dll") 
      |> xUnit (fun p -> {p with OutputDir = artifactsTestsDir })
)
...
// Dependencies
"Clean"
  ==> "BuildApp"
  ==> "BuildTests"
  ==> "RunTests"
  ==> "Default"

// start build
RunTargetOrDefault "Default"

This time I added a new property, which points to the build output of the test project:

let artifactsTestsDir  = "./artifacts/tests/"

This path is now used in the build target. With this call I build all projects that ends with Tests.csproj.

Target "BuildTests" (fun _ ->
trace "Building Tests..."
!! "**/*Tests.csproj"
  |> MSBuildDebug artifactsTestsDir "Build"
  |> Log "TestBuild-Output: "
)

Now we need the runner. FAKE already have a xUnitHelper, so we don’t need to call the runner and check the response - so this is really, really easy:

Target "RunTests" (fun _ ->
    trace "Running Tests..."
    !! (artifactsTestsDir + @"\*Tests.dll") 
      |> xUnit (fun p -> {p with OutputDir = artifactsTestsDir })
)

Pointed to the test directory and FAKE will do all the hard work.

The last change is the Build-Dependency-Graph, which now contains the steps for building the test project and run the tests.

// Dependencies
"Clean"
  ==> "BuildApp"
  ==> "BuildTests"
  ==> "RunTests"
  ==> "Default"

In this demo FAKE will build the test project two times, but in real life I would split the source and the test projects in different directories to get a more granular control what I want to build.

Invoke the build.fsx

I don’t need to change anything inside the batch file and can just invoke the batch:

Package "FAKE" is already installed.
C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\.nuget\nuget.exe  "install" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\.nuget\packages.config" "-OutputDirectory" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\packages"
All packages listed in packages.config are already installed.
C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\.nuget\nuget.exe  "install" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\LetsUseFake.Tests\packages.config" "-OutputDirectory" "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\packages"
All packages listed in packages.config are already installed.
Building project with version: LocalBuild
Shortened DependencyGraph for Target Default:
<== Default
<== RunTests
<== BuildTests
<== BuildApp
   <== Clean

The resulting target order is:
 - Clean
 - BuildApp
 - BuildTests
 - RunTests
 - Default
Starting Target: Clean
Cleanup...
Deleting contents of .\artifacts\
Finished Target: Clean
Starting Target: BuildApp (==> Clean)
Building App...
... (MSBuild for the Console and Test Project)
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.exe
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.exe.config
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.pdb
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.Tests.dll
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\LetsUseFake.Tests.pdb
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\xunit.dll
AppBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\build\xunit.xml
Finished Target: BuildApp
Starting Target: BuildTests (==> BuildApp)
Building Tests...
... (MSBuild for the Test Project) ...
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.dll
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.pdb
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\xunit.dll
TestBuild-Output: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\xunit.xml
Finished Target: BuildTests
Starting Target: RunTests (==> BuildTests)
Running Tests...
C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\packages\xunit.runners.1.9.2\tools\xunit.console.clr4.exe "C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.dll"
xUnit.net console test runner (64-bit .NET 4.0.30319.0)
Copyright (C) 2013 Outercurve Foundation.

xunit.dll:     Version 1.9.2.1705
Test assembly: C:\Users\Robert\Documents\GitHub\Samples\2015\LetsUseFake-Test\LetsUseFake\artifacts\tests\LetsUseFake.Tests.dll

1 total, 0 failed, 0 skipped, took 0.512 seconds
Finished Target: RunTests
Starting Target: Default (==> RunTests)
Default Target invoked.
Finished Target: Default

---------------------------------------------------------------------
Build Time Report
---------------------------------------------------------------------
Target       Duration
------       --------
Clean        00:00:00.0219014
BuildApp     00:00:01.3671003
BuildTests   00:00:00.7714649
RunTests     00:00:01.7558856
Default      00:00:00.0007886
Total:       00:00:03.9697467
Status:      Ok
---------------------------------------------------------------------

The resulting build artifact:

x

You can find the complete sample & build script on GitHub

Manfred Steyer: Folien und Beispiele zu meinem Workshop über Entity Framework auf der BASTA! Spring 2015

Nachfolgend meine Beispiele und Folien von unserem Entity Framework Workshop, den wir gestern auf der BASTA! Spring 2015 gehalten haben:

codefest.at [MS]: Neue CTP Versionen von Visual Studio 2015 und Team Foundation Server 2015

Nicht nur das Microsoft Band SDK Preview ist neu, sondern auch die nächste CTP Version 6 von Visual Studio 2015 und CTP des TFS 2015 sind verfügbar, schreibt John Montgomery, Director of Program Management, Visual Studio Platform, im Visual Studio Blog.

CTP Versionen sind nicht für den Produktiveinsatz und nur zum Testen und für Feedback an das Produktteam da. Hier geht es zur Original-Ankündigung: Visual Studio 2015 CTP 6 and Team Foundation Server 2015 CTP Released.

Die Downloads sind auf http://www.visualstudio.com/downloads/visual-studio-2015-ctp-vs verfügbar.

image

Hier geht es zu den Visual Studio 2015 CTP 6 release notes, zu den Bugfixes Visual Studio 2015 CTP 6 KB article und zu den Team Foundation Server 2015 CTP release notes und Bugfixes Team Foundation Server 2015 CTP KB article.

Einige Neuerungen in VS 2015 CTP 6 betreffen Verbesserungen in ASP.NET, Xamarin, den Visual Studio Tools for Apache Cordova, CodeLens, NuGet, XAML UI Debugging, Visual Studio Emulator for Android und die Architecture Tools.

Viel Spaß mit den neuesten CTP Versionen und dem Erforschen der neuen verbesserten Features in Visual Studio 2015!

PS: Developer können Visual Studio Online kostenfrei nutzen, siehe auch What is Visual Studio Online?

Marco Scheel: Links for 2015-02-23 [del.icio.us]

codefest.at [MS]: Microsoft Band SDK Preview ist verfügbar

Microsoft Band Besitzer und Developer werden sich darüber freuen, dass nun das Microsoft Band SDK Preview verfügbar ist! Die Details hierzu findet ihr hier:

http://developer.microsoftband.com/

image

 

“The Microsoft Band SDK Preview gives developers access to the sensors available on the band, as well as the ability to create and send notifications to tiles. Enhance and extend the experience of your applications to your customers' wrists. More at http://developer.microsoftband.com/.” siehe https://www.nuget.org/packages/Microsoft.Band/1.3.10219-preview

Cool ist, dass das Microsoft Band SDK als NuGet Package für Visual Studio verfügbar ist: Einfach in der Package Manager Console installieren:

PM> Install-Package Microsoft.Band -Pre

Danke an Christian Nagel für den Tipp zum SDK via Twitter!

 

Updates:

Laut den ersten Meinungen in den Developer Foren und Social Media kann mit der SDK-Preview jedoch nur Textausgabe am Band erfolgen. Mal die Möglichkeiten erforschen…

Georg Binder hat einige weitere Neuerungen zusammengefasst: Neu ist das hübsche Microsoft Health Dashboard, https://dashboard.microsofthealth.com und das Tracking von Fahrradfahren (das jedoch zuerst als Tile hinzugefügt werden muss). Das Band muss aktualisiert werden, siehe Georgs´ Tipps hier:

image

Das Microsoft Band hat nun auch ein Keyboard bekommen, siehe Überblick von TheVerge:
Microsoft Band just got a major update

…es wird Zeit fürs Update. Zwinkerndes Smiley

Code-Inside Blog: FAKE: Building C# projects without knowing a tiny bit of F#

MSBuild is the default build engine in the .NET world, but if you do more with MSBuild you will find yourself in a XML-mess, so that’s the reason why I tried out FAKE. You can find a couple of MSBuild related posts here.

Enough from MSBuild, now meet FAKE:

  • A DSL for build tasks (e.g. build following projects, copy stuff, deploy stuff etc.)
  • Active community, OSS & written in F#
  • You don’t need to learn F# for using it (at least the basic tasks are easy)
  • You can get FAKE via NuGet
  • Before we begin you might want to check out the actual website of FAKE

Our goal: Building, running tests, package NuGet Packages etc.

Let’s start with the basics: Building

I created a new console application and downloaded the NuGet Command-line utility:

x

The build.fsx script

So, now we get in touch with a very simple build script. (Scroll down to read the description of each section)

// include Fake lib
#r "packages/FAKE/tools/FakeLib.dll"
open Fake

RestorePackages()

// Properties
let artifactsDir = @".\artifacts\"
let artifactsBuildDir = "./artifacts/build/"

// Targets
Target "Clean" (fun _ ->
    trace "Cleanup..."
    CleanDirs [artifactsDir]
)

Target "BuildApp" (fun _ ->
   trace "Building App..."
   !! "**/*.csproj"
     |> MSBuildRelease artifactsBuildDir "Build"
     |> Log "AppBuild-Output: "
)

Target "Default" (fun _ ->
    trace "Default Target invoked."
)

// Dependencies
"Clean"
  ==> "BuildApp"
  ==> "Default"

// start build
RunTargetOrDefault "Default"

The top line is a reference to the FAKE helper libraries (included via the #r keyword) and a ‘using’:

#r "packages/FAKE/tools/FakeLib.dll"
open Fake

The next important line is the RestorePackages()-line. With this line all NuGet packages will be restored from NuGet.org or your own NuGet-Repository. If you check-in your NuGet packages then you don’t need this.

Then I define some general properties, e.g. my build output folders:

let artifactsDir = @".\artifacts\"
let artifactsBuildDir = "./artifacts/build/"

Now the interesting part: Like in MSBuild you define a couple of “Targets”:

Target "Clean" (fun _ ->
    trace "Cleanup..."
    CleanDirs [artifactsDir]
)

Target "BuildApp" (fun _ ->
   trace "Building App..."
   !! "**/*.csproj"
     |> MSBuildRelease artifactsBuildDir "Build"
     |> Log "AppBuild-Output: "
)

Target "Default" (fun _ ->
    trace "Default Target invoked."
)

The first target cleans the artifactsDir via the FileHelper. The next one is responsible for calling MSBuild (which builds the actual project) (via MSBuildHelper). This is maybe the most awkward part of the build script for a C# dev, but this “pipelining” is part of F#’s nature. I can’t explain it right now, but it works (I didn’t lie when I said that I have not a tiny bit of knowledge about F#).

At the end of the file you define the dependency graph for each target:

"Clean"
  ==> "BuildApp"
  ==> "Default"

After that we invoke the ‘Default’ target with this line:

RunTargetOrDefault "Default"

Invoke the build.fsx

Now that we have our project in place and a valid FAKE script we need to invoke the script. The easiest option on Windows is a batch file like this:

@echo off
cls
".nuget\NuGet.exe" "Install" "FAKE" "-OutputDirectory" "packages" "-ExcludeVersion"
"packages\FAKE\tools\Fake.exe" build.fsx

First we need to load FAKE via NuGet and after that we invoke our build.fsx file with Fake.exe.

Now you or any build machine can invoke the batch file and start the build!

Our first FAKE script!

The output is very well formatted and should explain the mechanics behind it good enough:

Package "FAKE" is already installed.
Building project with version: LocalBuild
Shortened DependencyGraph for Target Default:
<== Default
<== BuildApp
<== Clean

The resulting target order is:
- Clean
- BuildApp
- Default
Starting Target: Clean
Cleanup...
Creating C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\
Finished Target: Clean
Starting Target: BuildApp (==> Clean)
Building App...
Building project: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\LetsUseFake\LetsUseFake.csproj
... (standard MSBuild output, nothing special...)

Time Elapsed 00:00:01.24
AppBuild-Output: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\build\LetsUseFake.exe
AppBuild-Output: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\build\LetsUseFake.exe.config
AppBuild-Output: C:\Users\Robert\Documents\Visual Studio 2013\Projects\LetsUseFake\artifacts\build\LetsUseFake.pdb
Finished Target: BuildApp
Starting Target: Default (==> BuildApp)
Default Target invoked.
Finished Target: Default

---------------------------------------------------------------------
Build Time Report
---------------------------------------------------------------------
Target     Duration
------     --------
Clean      00:00:00.0032838
BuildApp   00:00:01.5844651
Default    00:00:00.0007512
Total:     00:00:01.6153969
Status:    Ok
---------------------------------------------------------------------

The resulting build artifact:

x

You can find the complete sample on GitHub

Kazim Bahar: Mobile Computing vor 22 Jahren und heute

Neulich hatte ich wieder mal meine Retro-Rechnern entstaubt, u.a. meinen ersten mobilen Rechner, den Toshiba T6400DXC. Damals war das einer...

Golo Roden: Unscharf: Den Nagel im Heuhaufen suchen

Shell-Skripte zu schreiben ist eine der einfachsten Aufgaben unter Node.js und io.js, Module wie commander und buntstift übernehmen die schwierigen Aufgaben: das Zerlegen und Auswerten von Parametern und das Formatieren der Konsolenausgabe. Doch wie steht es um das Erkennen von unbekannten Kommandos?

Uli Armbruster: Aus der Praxis – Wie sich unser Unternehmen durch Social Media verändert hat

Social Media ist nur ein Trend

Ich bin vor einigen Monaten aus unserer Social Media Gruppe (meine früheren Berichte zu unserer Arbeit) ausgetreten. Nicht weil ich darin keinen Sinn mehr gesehen oder weil ich nichts mehr hätte beisteuern können. Vielmehr liegen meine Stärken mehr darin Ideen zu entwickeln und einzuführen, als diese bis zum Schluss zu begleiten. Schluss bedeutet hierbei bis die letzten Kollegen „überzeugt“ wurden. Die Autorinnen Rising Linda und Mary Lynn sprechen in ihrem tollen Buch Fearless Change von sogenannten “Innovators” und “Early Adopters”  (einen Einführungs-Podcast dazu gibt es hier). Mit Laggers werden übrigens Persönlichkeitstypen bezeichnet, die nicht zu überzeugen sind. Dazwischen reihen sich die Early Majority und Late Majority ein.

Nachdem vor kurzem die Gruppe überein kam sich aufzulösen, sprach mich eine Kollegin an. Sie ist der Meinung, dass viele Ideen respektive Ansätze dabei sind, bei denen es sich lohnt diese weiterzuführen. Zum Beispiel unsere Textwerkstätten. Sie wollte wissen, wie ich über die Entscheidung denke und ob ich einen Vorschlag hätte, um die Gruppe neu auszurichten. Vor allem da sich die bisherigen Ergebnisse sehen lassen konnten und sie die Art der interdisziplinären Kollaboration im Vergleich zur (homogenen) Abteilungsarbeit spannend fand.

Nun wird der ein oder andere Leser vermutlich denken: Das war doch klar. Social Media und Unternehmen passen nicht zusammen. Das ist ein vorübergehender Trend, den jeder früher oder später abhaken muss!

Halte an deinen Zielen fest, bleibe dabei aber flexibel

Mein Sicht darauf war dann doch eine andere, was ich meiner Kollegin wie folgt erklärt habe: Das Ende der Social Media Gruppe ist lediglich dem Namen und der Beschränkung auf eine festgelegte Personengruppe geschuldet. Die Idee dahinter hat längst bei uns Wurzeln geschlagen. Denn inzwischen machen wir unternehmensweite Open Spaces, bei denen die “Lehrer” und “Schüler” Rollen kontinuierlich wechseln und die Agenda von allen Mitarbeitern mitbestimmt wird. Am Vormittag erzählt noch der Kollege aus Berlin umfassend über ein neues Produkt und die Kollegin aus Nürnberg hört zu, am Nachmittag werden die Rollen getauscht und die Kollegin referiert über Werkstoffe und deren Einsatzszenarien.

Die Meetings unserer Marketing- & Einkaufs-Abteilung sind inzwischen für alle geöffnet. Durch gezielte Einladungen abteilungsfremder Kollegen soll das gefördert werden. Themen- und Projektvorschläge werden in den Wochen zuvor von allen Mitarbeitern im Wiki zusammengetragen. Jedem „Stakeholder“ ist freigestellt Input zu liefern.

Ein weiteres Beispiel ist unser Arbeitsplatztausch, bei dem jeder Mitarbeiter mindestens 1x jährlich in eine andere Abteilung wechselt, um über den eigenen Tellerrand hinaus zu schauen. Und natürlich schreibt der Kollege seinen Erfahrungsbericht in unseren Corporate Blog. Stephan ist übrigens kein Mitglied der Social Media Gruppe! Damit ist er einer von vielen, die bereits gebloggt haben.

Mir fallen auf Anhieb noch viele weitere Ausprägungen ein, doch unser Erfolg zeigt sich meiner Meinung nach am besten darin, dass ich kürzlich beim Vorbeigehen nicht umhin kam zu hören, wie der Einkaufsleiter in Nöttingen am Telefon einer Kollegin aus Frankfurt wie selbstverständlich mitteilte: “Das kannst du alles im Wiki nachlesen und dann ggf. ergänzen”. Dass der Einkaufsleiter noch ein paar Wochen zuvor seine Mitarbeiterin – selbige ist Teil der Social Media Gruppe und daher bestens geschult im Umgang mit dem Wiki – gefragt hat wie der Inhalt einzupflegen ist, brachte mich dann doch zum Schmunzeln. Mit einem Video zur Integration der Wiki-Inhalte in unser Warenwirtschaftssystem habe ich die Vernetzung bei uns bereits illustriert.

Neben einigen weiteren Beispielen wies ich meine Kollegin noch darauf hin, dass sie selbst erst kürzlich gegenüber dem Vorgesetzten den Wunsch geäußert hat in ihrer Abteilung regelmäßige Retrospektiven zur Verbesserung der Prozesse umzusetzen. Ebenfalls ein Ansatz, den wir bei der Social Media Gruppe einsetzten.

tree-200795_1280

Quelle: http://pixabay.com/de/baum-struktur-netzwerke-internet-200795/

Fazit:

Nur diejenigen, die Social Media nicht auf Werkzeuge wie Facebook und Twitter reduzieren, sondern die Ansätze und Gedanken dahinter verstehen, können das der Sache inhärente Potential nutzen. Die Schulungs-Agenda sollte eben nicht mehr nur vom Abteilungsleiter definiert oder Geschäftsprozesse durch die Geschäftsleitung festgelegt werden. Stattdessen muss sich eine Kultur etablieren, bei der die Fähigkeiten aller genutzt werden und das Wissen der Masse kontinuierlich geteilt wird. Dadurch entsteht eine Lernkultur, bei der Informationen nach Belieben beigesteuert und herausgezogen werden können. Social Media ist insofern auch keine neue Idee, jedoch sind inzwischen viele digitale – teils populäre, teils weniger bekannte – Werkzeuge auf dem Markt. Mit dem inzwischen signifikanten und noch weiter steigenden Anteil der sogenannten Wissensarbeit ist nicht mehr die Frage, ob man auf den Zug aufspringen sollte. Die Herausforderung liegt darin die passenden Werkzeuge zu evaluieren und eine entsprechende Unternehmenskultur zu etablieren. Denn wer nicht mit der Zeit geht, geht mit der Zeit.

Wie stehts bei euch um Change Management, Social Media und Innovationen? Welche Werkzeuge nutzt ihr? Seid ihr schon auf einem guten Weg oder springt ihr gar nicht auf den Zug auf?


Einsortiert unter:CIO Topics, German, Projects Tagged: Social Media

Marco Scheel: Links for 2015-02-22 [del.icio.us]

Code-Inside Blog: ESENT Database Viewer: ESENT Workbench

I already blogged about the ancient old ESENT Database, which is still supported and will also be available in Windows 10, so you are safe to use it. Also the ManagedESENT project is alive and somewhat in active development.

With the ManagedESENT project you can store your data inside a ESENT database very easy*, but what if you want to look inside the ESENT database?

* … well… the interface is still awkward for a C# dev, but it is possible to build a nice abstraction around it. Here can you see a sample from the project.

ESENT Database Viewer: ESENT Workbench

I found a very promising OSS project called ESENT Workbench. You can build the source yourself or just use the release.

x

x

Hope this helps and if you know any other useful tools around the ESENT database just write it in the comments.

Marco Scheel: Links for 2015-02-20 [del.icio.us]

Sven Hubert: Microsoft meets embedded world

Bei den Themen embedded Software und Software im industriellen Umfeld denken die wenigsten Menschen sofort an Microsoft. Diejenigen die es tun, reagieren meist mit Ablehnung oder zumindest wenig begeistert – und das völlig zu unrecht. Gehören Sie in eine der beiden genannten Gruppen? Falls ja besuchen Sie uns auf der embedded World in Nürnberg Halle 4 / 4-240 und lassen Sie sich vom Gegenteil überzeugen.

 

Mit dem Team Foundation Server bietet Microsoft ein ALM Werkzeug, welches nicht nur im Bereich der Applikations-Entwicklung eingesetzt werden kann. Lesen Sie hierzu im Vorfeld unsere Fallstudien zum Einsatz des TFS bei den Firmen CLAAS und SIEMENS. Welche Innovationskraft im Einsatz von Microsoft Technologien im industriellen Umfeld steckt, wird im MC6-Bedienkonzept der Industrieroboter vom Spritzgussmaschinenanbieter KraussMaffei sichtbar (Case Study KraussMaffei).

Microsoft meets embedded world is a post from: AIT Blog

codefest.at [MS]: Rasch über ASP.NET vNext informieren

Für .NET und ASP.NET Developer werden die Neuerungen in ASP.NET vNext (bzw. ASP.NET 5) sehr spannend.

Natürlich gibt es hierzu viele Fragen… Was ist Neu und was ändert sich? Welche Runtimes gibt es? Wird es ASP.NET Webforms auch in Zukunft geben? Wie sieht es mit der angekündigten Interoperabilität aus? Was bedeutet HTTP2? Wird ASP.NET vNext tatsächlich schneller? Und vieles mehr…

Diese grundsätzlichen Fragen über ASP.NET vNext beantwortet das freie Mini-eBook von Tools-Hersteller Telerik kurz und bündig, downzuladen von dieser Webseite:

http://www.telerik.com/campaigns/aspnet/vnext

image

Es ist nur eine Angabe des Namens, einer E-Mail Adresse und des Landes erforderlich, dann startet der Download des knackigen 1.4MB eBooks mit 25 Seiten. Rasch informieren!

Viel Spaß damit!

codefest.at [MS]: Kostenloses Azure Essentials eBook

Das 246-starke eBook (eng.) deckt in 9 Kapiteln sowohl Themen für Entwickler als auch für IT-Microsoft Azure Essentials: Fundamentals of AzureProfessionals ab. Behandelt werden: Azure Übersicht, Azure Websites & Cloud Services, Azure Virtual Machines, Azure Storage, Azure Virtual Networks, Databases, Azure Active Directory, Management Tools und Business Cases.

Erschienen am: 12. Feb. 2015

Microsoft Azure Essentials: Fundamentals of Azure

Marco Scheel: Links for 2015-02-18 [del.icio.us]

codefest.at [MS]: Eine Beispiel-Webapplikation für Microsoft Azure in 150 Min. kompakt erklärt

.. Interesse ?

Unser Partner ANECON Software Design und Beratung GmbH hat sich einige Gedanken gemacht wie unterschiedliche Aspekte bei der Entwicklung einer Cloudapplikation anschaulich an einem Beispiel erklärt werden können. In drei Vortragsteilen die die Bereiche Anforderungen (User Stories), Umsetzung/Test und Betrieb/Performance abdecken schlüpfen die Vortragenden ANECON Experten in die Rollen des Entwicklers, Testers oder Product Owners um Praxisnah die Umsetzung eines solchen Projektes zu demonstrieren.

Wir würden uns freuen wenn Sie uns bei der Entstehung der Applikation, am 3.3.2015 (Vormittags) begleiten: Anmeldung

Christian Binder [MS]: Neue Features in C# 6.0

Mein TechTalk  mit Patric zun den neuen C# 6.0 Features :

image

und hier der Blogpost dazu.

Chris Smile

Christian Binder [MS]: TechTalk - Word to TFS

Mein TechTalk mit Thomas Rümmler zur Word to TFS Integration.

image

Chris

Code-Inside Blog: Developer Conference in Berlin: Spartakiade

So this is now more or less a “pure” blog in English, but this post might be more interesting for German-Speaking developers, so I will switch to German, but don’t be shy: If you are interested in one of the conference workshops just get in touch with the conference organizers.

x

Spartakiade 2015, Berlin / März

Die Community-Konferenz Spartakiade vom 21.–22. März 2015 in Berlin bietet Workshops zum Mitmachen an. Bei der Spartakiade kennt man keinen Zeitdruck und lässt Teilnehmer sich ausführlich und intensiv mit einem Thema beschäftigen. Die Dauer der Workshops geht weit über die Vortragsdauer der üblichen 60–90 Minuten auf “klassischen” Konferenzen hinaus, die meisten Workshops sind ganztägig. Und weil das wie beim Sport herausfordernd werden kann, heißt die Konferenz “Spartakiade” – namentlich auch bekannt als Sportveranstaltung.

Workshops sind für jeden Schwierigkeitsgrad aus der Softwareentwicklung dabei – etwas für Leichtathleten, Kraftsportler oder Mehrkämpfer und die ganze Mannschaft. Inhaltlich geht es um Agile Games, Event Storming, Git, Node.js / AngularJS, Raspberry Pie, Funktionale Programmierung, Microsoft Lync und vieles mehr.

Die Anmeldung ist ab sofort möglich unter: spartakiade.org

Ich selbst bin leider nicht dabei, aber ich hatte die Gelegenheit letztes Jahr ein paar Stunden da zu verbringen und ich habe vollstes Vertrauen in die Workshop Leiter. Wer Zeit hat: Hingehen!

Johannes Renatus: JavaScript Unit Tests mit Jasmine und Visual Studio (Resharper oder Cutzpah)

Bisher habe ich Unit Tests nur für .Net (C#) geschrieben, inzwischen nimmt aber auch der Clientseitige Code in Webanwendungen durch Frameworks wie AngularJS immer bessere Strukturen an, die sich ebenfalls sehr gut testen lassen. Außerdem gibt es sehr gute Plugins für Visual Studio (VS) die einem das Ausführen von JavaScript Unit Tests direkt im VS […]

Uli Armbruster: Nachgefragt – Clean Code Interview mit Ralf und Stefan

In einem Online Interview habe ich Ralf Westphal und Stefan Lieser, die Gründer der Clean Code Developer School, zum Thema Clean Code befragt. Herausgekommen ist eine Aufnahme, die es jetzt auf YouTube gibt. Die Fragen wurden nicht vorab abgesprochen, um eine Gesprächsatmosphäre zu schaffen, wie es sie bei einer Kaffeepause gibt.

Es war ein toller Gedankenaustausch. Danke nochmal ihr zwei!

Zum Video

Zum Video

Fragen

  • Wenn ihr euch für eine Konferenz entscheiden müsstet, welche wäre das?
  • Community vs. Freizeit: Wie ist das vereinbar
  • Wann ist Clean Code noch sinnvoll und wann verschlimmbessere ich nur noch?
  • Macht Clean Code Sinn, wenn die Kollegen nicht mitziehen?
  • Wird das Schreiben von gutem Code mit der Zeit einfacher?
  • Ist guter Code relativ?
  • Was erwartet ein Arbeitgeber, wenn er Clean Code in der Stellenausschreibung aufführt?
  • Was kann ich von einem Bewerber erwarten, wenn er Clean Code in der Stellenausschreibung aufführt?
  • Verschiedene Ansätze für bessere Architektur, z.B. Flow Design
  • Brauche ich für Flow Design einen IoC Container?

Für die Zukunft sind weitere Interviews geplant:

  • Mit Daniel Marbach zu Machine.Specifications
  • Mit Tilman Börner zur dotnet pro
  • Mit Steffen Forkmann zur paket

Falls ihr noch Ideen habt, dann schreibt sie in die Kommentare.


Einsortiert unter:Development, German Tagged: Clean Code, Interview, Video

codefest.at [MS]: Coding for Office 365

Letzte Woche machte die Microsoft Office 365 Summit Roadshow Stopp in Amsterdam. Der Summit und Mitglieder der Microsoft Office-Produktgruppe informierte an zwei Tagen in über 60 Sessions IT-Pros und Developer über den aktuellen Stand der Entwicklung in Office 365, siehe http://summit.office.com/events/office-365-summit-amsterdam.

image

Der Office 365 Summit

Die Veranstaltung fand nahe des Amsterdam City Centers in der “Passenger Terminal Station” und im Mövenpick Hotel mit fast 1.300 Teilnehmern statt, hier ein paar visuelle Eindrücke vom Event.

amsterdam_summit amsterdam_summit_registration
WP_20150212_025 WP_20150212_024

Office 365 als Software-as-a-Service

Die aktuellen Zahlen von Office 365 sind immer wieder beeindruckend: Derzeit laufen die Office 365 Services auf mehr als 1 Million (!) Servern in weltweit mehr als 100 Microsoft Datacentern. Der Aufwand für den Betrieb und den Software-Release Cycle sind ebenfalls eindrucksvoll. Das Bild rechts zeigt einen Server-Container mit tausenden Servern wo gerade eine Klimaanlageneinheit montiert wird. In Datacentern dieser Generation sind solche Container sind in wenigen Stunden montiert und rasch einsatzbereit.

datacenters datacenters2

Unter anderem waren einige interessante Informationen aus der Keynote zu erfahren. Microsoft hat gelernt dass alle Dienste voll automatisiert ablaufen müssen. Um die 99.9% Verfügbarkeit der Services zu garantieren, beträgt die mögliche Wartungszeit nur etwa 40 Minuten pro Monat – ein ziemlich kleines Wartungsfenster.

Ein interessanter Aspekt ist, dass ein durchschnittlicher Office 365 Server (etwa Exchange od. SharePoint) nur zwei Wochen lang “lebt” und danach neu instanziert wird. Das bedeutet, offensichtlich wird im Regelfall kein Patching betrieben, sondern regelmäßiges neues Erstellen von Servern aus Images. Somit gibt es sehr kurze Release-Zyklen von teilweise nur zwei Wochen für eine neue Office 365 Version. Ein weiterer Vorteil ist, dass so alle Server weltweit mehr oder minder am gleichen Stand sind.

Für Software Entwickler

Für Developer bietet Office 365 als SaaS eine Vielzahl an Möglichkeiten die Dienste zu nutzen und selbst Applikationen mit Integration zu Office 365 zu schreiben. Wir haben hier im Blog bereits über einige Möglichkeiten von SharePoint und Office Apps (siehe u.a. hier) und die neue Office 365 APIs (siehe hier) beschrieben.

Eine gute Gelegenheit hier den aktuellen Status zusammenzufassen:

  • Die Office 365 APIs sind seit letztem Dezember final verfügbar. Hier geht es zum Download:
    Microsoft Office 365 API Tools for Visual Studio 2013
    image
    Im Vergleich zu den Preview Versionen wird nun kein Beispiel Code für den Zugriff auf Mail, Calendar und Contacts mehr generiert. Hier geht es zur Dokumentation im MSDN.
  • Die Office Developer Tools for Visual Studio enthalten SDKs mit Bibliotheken für .NET und JavaScript, die einen Wrapper für Office 365 REST Services bereitstellen. So ist ein einfacher Weg möglich, um auf Office 365 Daten zuzugreifen. Die SDKs sind für ASP.NET MVC, ASP.NET Web Forms, WPF, Win Forms, Universal App, Cordova und Xamarin Projekte in Visual Studio verfügbar.
  • Eine wirklich tolle Quelle für Beispielprojekte für den Zugriff auf Office 365 ist auf GitHub zu finden, nämlich unter OfficeDev: 
    https://github.com/officedev/
    Hier sind viele, sehr aktuelle Samples für den Zugriff auf die Dienste frei verfügbar.
    image
    …und vieles mehr!
  • Mein Tipp lautet vor allem die Beispiele von “Office365 Developer Patterns and Practices” anzusehen. Hier sind viele interessante Beispielprojekte enthalten:
    https://github.com/OfficeDev/PnP
    image

Sicherheit in der Cloud

Datensicherheit gehört natürlich auch zum Betrieb von Office 365 und Azure – gerade auch für Developer.

Wie Gerwald auch hier angekündigt hat möchte ich ebenso auf ein tolles Event hinweisen:
Ende Februar findet bei Microsoft Österreich die Veranstaltung Event: So sicher ist die Cloud! statt.

image

Wer kann sollte sich die Zeit nehmen und daran teilnehmen!

Nächste Schritte

Für alle an Office 365 Interessierten empfehle ich die Teilnahme am Yammer Network mit aktuellen Neuigkeiten über Office 365 und Development unter https://www.yammer.com/itpronetwork.

Unter http://roadmap.office.com/en-us stellt Microsoft die Office 365 Roadmap öffentlich bereit.

Weitere Office 365 Neuigkeiten werden wir wohl bei den nächsten beiden großen Microsoft Konferenzen Build und Igniteerfahren!

Viel Spaß beim Experimentieren und beim Apps bauen mit den umfangreichen Office 365 Beispielen auf GitHub!

Manfred Steyer: Slides and Source-Code of my AngularJS/OAuth2-Talk at ng-NL in Amsterdam

Below you find the links to my slides and source code I've used at my talk about Authentication with AngularJS and OAuth2 at ng-NL in Amsterdam in February, 13th 2015.

Sven Hubert: Introduction to Database Lifecycle Management and why it is important for ALM

Today we are proud to have an interview between Stephanie Herr from Redgate and Stefan Mieth from AIT to talk about Database Lifecycle Management (DLM) and Application Lifecycle Management (ALM). While Microsoft gives us the SQL Server Data Tools (SSDT) as a good tooling for developing databases and the ability to store them into Team Foundation Server Version Control, it is only a entry point into the whole DLM process. Even though we already have successfully finished several database projects using this toolset and because we are always looking for better and more efficient tools, this is sometimes just not enough…

 

image

&

image

 

Stephanie is a DLM Expert, and will tell us what DLM is and how it integrates into our application development and Application Lifecycle Management.

 

Stephanie, nice to see you! Could you short introduce yourself, tell us a little about what makes you tick and what you’re focused on?


StephanieHerr

Stefanie Herr, Redgate

Thanks Stefan. I wouldn’t call myself an expert, but I’m trying to be. I still have a lot to learn…

I was a software/database developer years ago before joining Redgate. I worked on large waterfall projects that were 10 years long, and I also worked on agile projects, which I love. When I started at Redgate 6 years ago, I joined as the Project Manager for SQL Source Control. Since then, my focus has been on all Redgate’s SQL Tools and how they fit together into this process called Database Lifecycle Management. I’m particularly looking at our integrations with Microsoft, such as TFS for source controlling your database, and Team Build for bringing your database into a continuous integration process. Lately we’re also looking at Release Management for automating database deployments, while still giving teams the opportunity to review SQL scripts so that DBAs can be confident that deployments to production are safe and secure.

What makes me tick? I loved doing database development and I feel so lucky to be working on software that helps other database developers and DBAs. I also love working with great people on agile teams that can respond to users quickly.

Sounds like a good fit for everyone! So, today’s topic is DLM – Database Lifecycle Management is very important for all who try to develop their own application with a Database at the back, but I don´t think everybody is familiar with DLM. Can you give us a short description of what DLM is?

Stephanie

Database Lifecycle Management is a set of processes and tools that include the database in Application Lifecycle Management. That sounds a little too simplified… It’s all about making changes to your database and delivering those database changes to your users using a reliable, repeatable process that is integrated with the rest of your software development.

It’s important that the database is not a bottleneck when it comes to releasing your applications, especially in the world of agile development and frequent releases. We want to use tools for our database development like version control, continuous integration, and automated testing. Application developers have been taking advantage of these for years and it’s time we took advantage of them for the database. Some teams we’ve seen are even taking this to the next step and doing automated deployments or easing the deployment process by having a “one-click” process that’s repeatable and doesn’t rely on manually following a huge document (and accidentally missing a step.)

We want to make deployments simple and less scary. We want to test deployments across multiple environments that mimic production as closely as possible, so that you’re more confident that a release will go well. If possible, we want to let DBAs and Ops Teams go home at normal hours and not worry about a huge scary release that must be deployed during late maintenance windows!

Sorry, that was a bit of a longer description. There’s just so much to say about DLM…  I could go on!

Maybe just a little more. It sounds like DLM is actually very similar to ALM. However, at a more detailed level, thinking of ALM as an arch spanning from the very first vision right up until the retirement of your product, including requirements gathering, planning, development and so on… where do you think DLM should be placed in the big world of Software Development? On which interfaces can it be integrated into our existing ALM processes?

Stephanie

DLM is focused on the database and bringing it into your ALM processes. I think if your application relies on a backend database, then DLM needs to go hand in hand with ALM. Therefore, it integrates into every interface where changes to the code base are either decided or implemented (from requirements gathering through to monitoring). Our DLM tools integrate with a lot of tools that exist for ALM. For database source control, we integrate with Subversion, Team Foundation Server, Git, Mercurial, and more. For database continuous integration, we integrate with Team City, Microsoft Team Build, and more. For releases, we integrate into Octopus Deploy, Microsoft Release Management, and other release management tools. Our thinking is that you already have tools for your application. We want to leverage these and bring your database into these tools and processes to make your deployments easier.

Database deployments are hard and we think it’s not often talked about when people talk about ALM, but it needs to be. Your application isn’t going to work very well if the database doesn’t exist or if it’s not at the right version that your application needs. The database is hard because of the data that needs to persist and also because of security concerns around this data.

You cannot lose data during a deployment. You have to worry about current connections and data consistency. You also have to worry about the security of that data. In a lot of areas, developers may not be able to have a copy of production data because of privacy issues. This makes it slightly harder because you’re testing scripts against something that is similar to production, but not production, so anything could happen when it comes time for the production release.

It’s really great if you can have a staging environment that matches production exactly, so that upgrades can be run and verified there before applying them to production. You also need to make sure that no changes were made to production between when you tested the deployment on staging and when you’re ready to run it on production. We describe a change to a database from an expected state as “drift”. There are many reasons this can happen and some are very valid, such as a hotfix to production. You need to know about this drift so you can incorporate it back into your development environment, making sure it doesn’t get overwritten the next time you do a deployment.

By the way, we have a brand new tool called SQL Lighthouse that provides a great dashboard of your database environments, and can alert you about changes and drift. This tool is currently a free beta and we’re looking for people to try it out and give us feedback before the full release. We have a lot of great ideas on our backlog for this tool that I’m really excited about. It would be great to hear from your readers and get their thoughts on the beta and what else they would like to see it do.

So anyway, there’s a lot to think about when it comes to the database. You need to think about server configurations, schema, and reference data. Reference data drives the application, so it needs to be versioned alongside the application and database schema and should be released in the same process. You also need a plan for what happens if a deployment doesn’t go as expected. This could be restoring a backup, having a rollback script, reverting a snapshot, or even rolling forward a “fix,” especially if you have a great process in place that makes releasing the fix easy.

 

Wow – that´s pretty extensive. What’s the simplest thing readers could do immediately to improve their ALM / DLM processes?

Stephanie

The first step in DLM is getting your database in source control. There’s most likely a source control system that your application developers are using. Find out where the related application code is stored and put your database code there. (Yes, database is code.) You also want to source control any configurations and reference data that should be tracked and deployed alongside the schema as well.

Ok, but my application developers are using Microsoft’s Team Foundation Server, and my Database developer uses SQL Server Management Studio. How can these environments fit together?

Stephanie

They actually fit together really nicely. Redgate’s SQL Source Control is a plug in to SSMS that integrates with existing source control systems like TFS. It allows you to continue to work on your database in SSMS, and to commit those changes to TFS. When you commit, you can associate the changes to a TFS work item ID, which could represent a user story or a bug. This is great because then you can see why the change was made and any other changes that were associated with the work item in one place.

Once your database is in source control, then you can use other TFS features like TFS Team Build and Redgate SQL CI to automate your builds and even do continuous integration for both your application and your database. The next step is putting database unit tests into this process to give you fast feedback about the state of your database and also provide solid regression testing as you’re making changes to the database.

Finally, TFS Team Build can kick off a release in Microsoft’s Release Management. Using a tool like Redgate SQL Release, this can deploy the database to other environments (like test or QA) to run additional tests. This could also include populating the database and running load and/or performance tests against the database automatically. How cool is that?

 

Impressive! We have all the tools integrated, and bringing the team one step closer together – that’s awesome! I’m just thinking of the possible performance boost for our projects, and it’s amazing. One last question for the endless debate: Can database development be agile? (hint: the answer has 3 letters Winking smile )

Stephanie

Absolutely. Wait, that isn’t 3 letters… 

To me, it seems like Database Development has to be agile to support an agile development process. You don’t want the database to be the bottleneck. You want it to be integrated into your development processes. You want it to be tested automatically to give you confidence in the changes and check for regressions. You want it to be as easy as possible to release the changes to production. You want your developers and DBAs to be spending time on things that are hard and truly valuable, not the things than can be reliably automated.

That said, it’s definitely tricky. Especially if multiple applications use the same database. Refactoring for one application can be a challenge because you want to make sure that the other applications still work, but loosely coupled applications and libraries are already facing similar challenges, so we should be able to learn from them. There may also be reports or data warehouses that need to be considered, which is fairly unique to databases.

So yeah, it is tricky, but definitely possible and something to work towards.

So, if you develop your application using an agile approach, you should consider developing your database using agile techniques as well. I think that’s a good conclusion to end our today’s talk. Thank you for your time, and looking forward to our next conversation!

Stephanie

Thank you so much! I really enjoyed our talk and hope your readers do too. I’m happy to talk more on twitter @SQLStephanie. Or, if you want to learn more about DLM, visit us at http://www.red-gate.com/products/dlm.

Introduction to Database Lifecycle Management and why it is important for ALM is a post from: AIT Blog

codefest.at [MS]: Event: So sicher ist die Cloud!

Am 26. Februar findet von 09:00 Uhr bis 13:30 Uhr bei Microsoft Österreich eine Veranstaltung rund um das Thema Datenschutz und Datensicherheit in der Microsoft Cloud statt. Die Veranstaltung richtet sich dabei an IT Entscheidungsträger, Sicherheits- und Datenschutzbeauftragte und Juristen von Unternehmen und soll helfen, ein gemeinsames Bild zur Entwicklung einer Cloud Strategie zu bekommen und sich über die Rahmenbedingungen zu informieren.
Wenn Sie als Entwickler unternehmensintern einen Diskussionsbedarf zu diesem Thema sehen dann weisen Sie bitte Ihre Kollegen auf diese Veranstaltung hin.

image

Cloud Computing ist in aller Munde, eröffnet neue Möglichkeiten, hilft Unternehmen neue Strategien und Entwicklungsmöglichkeiten zu finden. Gleichzeitig schürt es Ängste und diese müssen sachlich adressiert werden.

Die Dynamik der Cloud-Angebote verlangt ein Umdenken. Dazu gehört auch, dass Verantwortungsbereiche neu abgesteckt und die transnationalen Regeln in Bezug auf Datensicherheit (Zuverlässigkeit), Datenschutz (Zugangskontrolle) und Transparenz (durch EU-konforme Standardvertragsklauseln) strikt eingehalten werden; und die Einsicht, dass Datenschutz bereits innerhalb des Unternehmens beginnt.

Microsoft hat eine transparente Kommunikation, was Regelwerk und rechtliche Rahmenbedingungen betrifft.  In diesem Expertenbriefing erhalten Sie die Möglichkeit rechtliche Aspekte, behördliche Vorgaben, technische Details und Best Practices kennen zu lernen und sich mit Juristen und Experten zum Thema auszutauschen.

Die Agenda:

09:00 – 09:30 Keynote, Harald Leitenmüller

09:30 – 10:15 Patriot Act, Datenschutz und Compliance – alles neu?, Dr. Winklbauer

10:15 – 11:00 Datenschutz, Privatsphäre und Compliance bei Microsoft Online-Diensten für Unternehmen, Martin Zimmermann/Alfred Ecker/ Dr.Winklbauer

11:00 – 11:30 Pause

11:30 – 12:30 Datensicherheit bei Microsoft Azure und Office 365, Rainer Stropek MVP/Martina Grom MVP/ Harald Leitenmüller

12:30 – 13:30 Paneldiskussion (Q&A), alle Sprecher

Kommen Sie vorbei und nutzen Sie diese Gelegenheit, sich über den heutigen Stand der Sicherheit in Microsoft Cloud Diensten zu informieren. Hier geht es zur Anmeldung!

Lars Keller: DNUG Braunschweig Treffen - Einstieg in die Hybrid App Entwicklung

Die DNUG Braunschweig trifft sich am 11.12.2015 um 19:00 im Restaurant Zucker (Tagungsraum). Dieses Mal kommt uns Gregor Biswanger besuchen:

Die Entwicklung von Apps ist nicht einfach und jede "Systemwelt" hat ihre eigenen Tools und Anforderungen. Ob mit Java und Eclipse für Android, mit Objective-C und Xcode für iOS, oder mit den Microsoft-Tools für die Windows-Welt. Bei diesem Vortrag lernen Sie die vielfältigen Möglichkeiten der App-Entwicklung für alle gängigen Plattformen mit nur einer Programmiersprache kennen: HTML5 und JavaScript. Sie steigen mit den Grundlagen des kostenlosen Intel XDK und Apache Cordova ein und werden dann mit den wichtigsten Frameworks und Vorgehensweisen vertraut gemacht. Mit diesen Infos steigen Sie rasch zum versierten Cross-Plattform Entwickler auf.

Wie immer ist die Veranstaltung kostenlos!
Weitere Informationen zur DNUG Braunschweig können hier gefunden werden: http://www.dotnet-braunschweig.de

Jürgen Gutsch: SPDY wird Geschichte sein…

… die Zukunft heißt nun HTTP/2.0 :)

http://www.golem.de/news/google-chrome-will-spdy-schnell-durch-http-2-ersetzen-1502-112261.html

Warum mich das freut?

Letztes Jahr hatte hatte ich zusammen mit Golo Roden ein fünfteiliges Battle “NodeJS gegen .NET” in der dotnetpro (06/2014) veröffentlicht. Das Battle hat mir sehr großen Spaß gemacht, auch wenn sich .NET im letzten Teil eindeutig geschlagen geben musste.

Einer dieser Gründe für die Niederlage war eben jenes SPDY-Protokoll, das Google initiiert und implementiert hat und das auch von einigen weiteren Plattformen eingesetzt wird. Als ich die letzte Aufgabe gesehen habe, bat ich darum, statt SPDY eben HTTP/2.0 einsetzen zu dürfen. Leider wurde auf SPDY bestanden, da es wohl als Quasy-Standard für die Nachfolge von HTTP/1.1 angesehen wurde ;)

Microsoft hingegen bestand schon damals auf ein HTTP/2.0 als Nachfolge von HTTP/1.1, allerdings mit SPDY als Grundlage.

Um diesen Teil der Aufgabe zu meistern, hätte ich theoretisch eine experimentelle HTTP/2.0 Implementation für Katana einsetzen können: https://github.com/MSOpenTech/http2-katana

Schade nur dass es bis dato keinen Browser gab, der HTTP/2.0 unterstützt und die Lösung zur Aufgabe nur schwer hätte getestet werden können.

Aktuell unterstützen Firefox ab Version 34, sowie IE11 unter Windows 10 wohl HTTP/2.0 über TLS, sowie der aktuelle Chrome und (wie es wohl scheint) alle zukünftigen Versionen. http://en.wikipedia.org/wiki/HTTP/2#Browser_support

Golo Roden: Fehlerhaft: Private GitHub-Repositories mit npm installieren

Die Paketverwaltung npm kann Module nicht nur aus der öffentlichen Registry herunterladen und installieren, sondern auch von GitHub. Das funktioniert aufgrund eines Fehlers in npm unter Node.js 0.12 und io.js allerdings nur bedingt. Wie lässt sich das Problem lösen?

Code-Inside Blog: Human readable and editable config files with YAML

YAML ( Y AML A in’t M arkup L anguage, or in the beginning Y et A nother M arkup L anguage) is a pretty common config language in the Ruby world. Because of it’s clear nature it is a perfect fit for human readable configuration files. For example take a look at the Jekyll Configuration:

source:      .
destination: ./_site
plugins:     ./_plugins
layouts:     ./_layouts
data_source: ./_data
safe:         false
include:      [".htaccess"]
exclude:      []
keep_files:   [".git", ".svn"]
encoding:     "utf-8"
...

Not bad, right?

Why using YAML and not XML or JSON?

As you can see above (hopefully…), it’s pretty small in contrast to heavy markup of XML ( < HeavyStuff > … < / HeavyStuff > ) and more readable than JSON ( { { { … } } } - you know what I mean.), so for a config, which should be readable for humans, it’s really useful.

YamlDotNet & Sample Code

The easiest way to use and parse YAML in the .NET world is to use the YamlDotNet NuGet Package. It is OSS and can be found on GitHub

In my sample scenario I will serialize and deserialize the following config structure:

public class DemoConfig
{
    public int Foo { get; set; }
    public string SimpleItem { get; set; }
    public List<string> SimpleList { get; set; }
    public List<DemoConfigSettingElement> ComplexList { get; set; }
}

public class DemoConfigSettingElement
{
    public string Name { get; set; }
    public List<string> Attributes { get; set; }
    public string Test { get; set; }
}

As you can see, we have simple and complex types and lists - this should cover most cases. My sample program is a simple console app, serializing the object, writing it to the Console output and to a file and later reading this file. Pretty simple:

class Program
{
    static void Main(string[] args)
    {
        DemoConfig sample = new DemoConfig();

        sample.SimpleItem = "Hello World!";

        sample.Foo = 1337;

        sample.SimpleList = new List<string>();
        sample.SimpleList.Add("Foobar 1");
        sample.SimpleList.Add("Foobar 2");
        sample.SimpleList.Add("Foobar 3");
        sample.SimpleList.Add("Foobar 4");

        sample.ComplexList = new List<DemoConfigSettingElement>();

        DemoConfigSettingElement element1 = new DemoConfigSettingElement();
        element1.Name = "Element 1";
        element1.Attributes = new List<string>();
        element1.Attributes.Add("Foobarbuzz 1");
        element1.Attributes.Add("Foobarbuzz 2");
        element1.Attributes.Add("Foobarbuzz 3");
        element1.Attributes.Add("Foobarbuzz 4");
        element1.Attributes.Add("Foobarbuzz 5");
        sample.ComplexList.Add(element1);


        DemoConfigSettingElement element2 = new DemoConfigSettingElement();
        element2.Name = "Element 2";
        element2.Attributes = new List<string>();
        element2.Attributes.Add("Foobarbuzzi 1");
        element2.Attributes.Add("Foobarbuzzi 2");
        element2.Attributes.Add("Foobarbuzzi 3");
        element2.Attributes.Add("Foobarbuzzi 4");
        element2.Attributes.Add("Foobarbuzzi 5");
        element2.Test = "Only defined in element2";
        sample.ComplexList.Add(element2);

        YamlDotNet.Serialization.Serializer serializer = new Serializer();
        StringWriter strWriter = new StringWriter();

        serializer.Serialize(strWriter, sample);
        serializer.Serialize(Console.Out, sample);

        using (TextWriter writer = File.CreateText("test.yml"))
        {
            writer.Write(strWriter.ToString());
        }

        using (TextReader reader = File.OpenText(@"test.yml"))
        {

            Deserializer deserializer = new Deserializer();
            var configFromFile = deserializer.Deserialize<DemoConfig>(reader);
        }


        Console.Read();

    }
}

Result: The test.yml file:

Foo: 1337
SimpleItem: Hello World!
SimpleList:
- Foobar 1
- Foobar 2
- Foobar 3
- Foobar 4
ComplexList:
- Name: Element 1
  Attributes:
  - Foobarbuzz 1
  - Foobarbuzz 2
  - Foobarbuzz 3
  - Foobarbuzz 4
  - Foobarbuzz 5
- Name: Element 2
  Attributes:
  - Foobarbuzzi 1
  - Foobarbuzzi 2
  - Foobarbuzzi 3
  - Foobarbuzzi 4
  - Foobarbuzzi 5
  Test: Only defined in element2

When should you not use YAML?

In my opionion YAML is really great if the content needs to be human readable or editable. For machine to machine communication, interface definitions or more “complex” definitions XML, JSON or any other format might be better. The strength of YAML is based on the easy to read and edit fact, thats all.

Thanks to Antoine Aubry for the awesome work!

The complete demo code can also be found on GitHub

Hope this helps!

friends header

bloggers headline

links header

 
Don't contact us via this (fleischfalle@alphasierrapapa.com) email address.