Fabian Deitelhoff: Let Me Introduce: The StudioStyler

Twainsoft Studio StylerThere are many styles for Visual Studio. Especially for this thing called syntax highlighting. In my early years as a software developer I never cared about the way my editor looks like. I was very happy with the standard style. But my mind changed rapidly.

I wanted some other syntax highlighting settings and I love the Visual Studio dark theme. As editor style I use the Son of Obsidian settings and I’m very satisfied with them. But there’s this site called http://studiostyl.es/. You can download dozens of new styles. And every day there are a few more. There was just one tiny problem from my perspective. I just don’t want to visit this site every time I want to try another style :).

And because I’m a developer, I changed this. First for me, now for all others too!

The Visual Studio Package

To download every style directly within Visual Studio, I created the Twainsoft StudioStyler. This extension provides a new Tool Window, which gives you access to all Visual Studio styles that are online on http://studiostyl.es/.

So you just need to select one style, click the small green tick in the toolbar and immediately watch the changes in the editor settings like the color and the syntax highlighting appear. That saved me some time in various scenarios where I have to switch the editor settings. Figure 1 shows the Studio Styles Tool Window with some Visual Studio styles.

Fig. 1: The Tool Window with some studio styles. Fig. 2: The preview for the styles image. Fig. 3: The minimalistic options.

In figure 2 you can see the preview for the selected StudioStyle image. This is the bottom part of the screenshot. You can open it with a double click of your left mouse button and close it with the close button on the right side :). If this preview area is visible or not is saved in the options of the extension but cannot changed through the options dialog.

Figure 3 contains a screenshot of the minimalistic options page of the Twainsoft StudioStyler. This options will be updated in future versions of the extension. Another small impassibility concerns the styles per page. Figure 1 shows all styles at once. The reason is a missing default setting for the maximum styles per page. Just change it to 40 for example and restart Visual Studio. Latter is necessary, because the settings aren’t loaded directly. This is another feature I’ll add in later versions.

Fig. 4: The history of all activated studio styles. Fig. 5: The styles cache gets updated. Fig. 6: All available images are downloaded and merge into the cache.

Another feature is shown in figure 4. Every time you activate a style, it gets saved in the history. If the style is already present in the history, the activation count just gets increased by one. So you can switch fast between previous used styles.

Figure 5 shows the cache refreshing procedure. The problem is, that the http://studiostyl.es/ API allows me to just download the first x items of every style. It is not a good idea to download just the first x items, because there’s no pagination implemented. For example if I need the next ten items, starting at x, the API sends me the styles x + 10. So I must download much more data than needed. That’s the reason for the cache. All styles are saved within a XML file located at C:\Users\User\AppData\Roaming\Twainsoft\StudioStyler. The extension checks the last refresh date and if it is older than 10 days, you get a message to update the cache. In future version I’ll add options for this, like the amount of days when a cache is marked as invalid.

Figure 6 contains a screenshot of another feature or workaround. Until now it is very slow to download the images. So that procedure is started asynchronously after the styles are downloaded. Just let this process ends. If it is interrupted, it will start the next time Visual Studio starts.

Last but not least, you can find the code at GitHub. This extension is open source using the MIT license! I can’t post code here, as I did for my Chrome extension, because it is just to extensive :). If you have questions, just drop me a line.


The installation is very simple. You can download the extension via the Visual Studio Gallery or from this blog post. The extension works with Visual Studio Professional 2012 and 2013. But remember: Only the Visual Studio Gallery will contain the updated version! This blog post don’t gets updated every time I change the extension.


This is my second Visual Studio extension. The first was the Settings-Switcher, which will get an update someday :). Again I realized how hard it is to write a Visual Studio extension. The documentation changed dramatically to a better status. But the styling of the WPF controls is hard work. I hadn’t found good resources which colors I should or could use. I hope the extension will look nice in other Visual Studio themes.

If you have questions, problems or just want to provide some feedback, leave a comment, write me an e-mail or post some stuff at the GitHub repository. I hope you’ll have fun with this extension and find it useful :).

Falco Ostermann: Using custom JavaScript with Minimal Download Strategy (MDS) enabled

Mit der Einführung von SharePoint 2013 wurde auch erstmals das neue Feature Minimal Download Strategy (MDS) eingeführt. Damit wurden die Ladezeiten signifikant reduziert, da nur noch der notwendige Inhalt nachgeladen wird. Ein großer Mehrwert für Anwender, aber ein großes Problem für Entwickler. Vermutlich haben viele schon versucht eigene JavaScript Logik auf altbekannte Art und Weiße bereitzustellen und feststellen dürfen, dass diese nur sporadisch oder teilweise gar nicht auf Seiten mit aktiviertem MDS ausgeführt wird.

Ich selber bin auch über dieses Problem gestoßen und habe folgenden Lösungsansatz identifiziert ;-)

Implementing custom JavaScript with MDS enabled

Zu Beginn habe ich mit Visual Studio 2013 ein neues SharePoint 2013 Projekt erstellt und dieses wie folgt strukturiert:

Eine von den zwei JavaScript Dateien wird im Layouts Ordner abgelegt und steht somit über den entsprechenden Pfad für die komplette SharePoint-Farm zur Verfügung (Farm Solutions). Eine weitere wird innerhalb der Websitesammlung in der Style Library verwaltet, was den Lösungsansatz für SharePoint-Apps darstellt.

Die JavaScript-Dateien sollen lediglich beim Seitenaufruf eine Konsolenausgabe anzeigen, damit diese tatsächlich ausgeführt wurden. Die Ausgabe wurde in beiden JavaScript-Dateien unterschiedlich realisiert, allerdings mit dem gleichen Ergebnis.

JavaScript Datei 1

JavaScript Datei 2

Schließlich müssen die zwei JavaScript Dateien noch in der MasterPage referenziert werden, damit diese auch tatsächlich ausgeführt werden können.

Nach erfolgreichem Deployment der Lösung und aktivieren des Features erhalte ich beim Aufrufen einer Seite mit aktiviertem MDS folgende Konsolenausgabe:


Die neu eingeführte Minimal Download Strategy (MDS) steigert die Performance des SharePoint-Bedienkonzepts was dem Benutzer zu Gute kommt. Für die Entwickler stellte das Feature Anfangs einige Probleme dar. Allerdings funktionieren die hier aufgezeigten Lösungen auch bei deaktiviertem MDS, wodurch lediglich eine kleine Umstellung der Art der Entwicklung in Kauf genommen werden muss. Mich stellte das Feature Anfangs auch vor Herausforderungen, aber aktuell habe ich mich an die neue Schreibweise gewöhnt und kann damit kompatibles JavaScript für unsere Kunden bereitstellen. Wie ergeht es Euch bzw. was haltet Ihr von der Schreibweise?

Sven Hubert: How to change work item state using Visual Studio Online REST API

As many developers, I was also very happy to get to know, that Microsoft published a new REST API for Visual Studio Online. A feature of my main interest was the possibility to update a work item. On this site you can find a reference with some examples, how to use the REST API for updating a work item field.

According to the description, you just need to change a work item field, you’d like to update and pass it in JSON string with your HTTP-Request. Unfortunately, the world is not as simple as one would expect, and updating a work item state may get a little bit tougher in some cases. I have investigated the issue and collected all my knowledge in this blog entry. I know, this is a common problem and bunch of people out there are struggling with it at the moment. I hope, this blog entry can be helpful for them in some way.

1. Some important points

1.1 PATCH-Request

In order to update a work item you need to send a PATCH-Request. I do it following way, since the HttpClient doesn’t have PatchAsync() method, similar to GetAsync() or PostAsync().

   1: var content = new StringContent(jsonString);

   2: content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

   3: var request = new HttpRequestMessage(new HttpMethod("PATCH"), requestUri) { Content = content };

   4: HttpResponseMessage response = client.SendAsync(request).Result

1.2 Obtaining error information from response

Lots of developers complain about insufficient information, they get back as a response, after having sent a HTTP request (infamous BAD REQUEST 400). I can bet, they use following or some similar code, that you can find in the VSO REST API reference:

   1: using (HttpResponseMessage response = client.GetAsync(apiUrl + _apiVersion).Result)

   2: {

   3:     response.EnsureSuccessStatusCode();


   5:     responseBody = await response.Content.ReadAsStringAsync();

   6: }

I found out, when you reorder the instructions inside the curly brackets, you can still read the response content, before an exception in method response.EnsureSuccessStatusCode() will be thrown. As a response you get then a JSON string with some error information, that could help you with your problem.

1.3 Changing work item state

In VSO you can create a project according to three process templates: Scrum, Agile and CMMI. A Process Template customization is still not available for VSO. For each particular process template you can download process template configuration files from your Visual Studio (Team/Team Project Collection Settings/Process Template Manager…). You must be a member of the Project Colelction Administrators group in order to be able to do that. (see this)

When you have downloaded the process template, you can find there configuration files for all work item types provided by given process template. If you would like to update a Requirement (CMMI), you look up for “MSF for CMMI Process Improvement 2013.3\WorkItem Tracking\TypeDefinitions\Requirement.xml” and open it. The configuration file is an XML-File.

When you want to update a work item state, you are about to perform a transition. You can find transition definitions in the work item configuration file under “WITD/WORKITEMTYPE/WORKFLOW/TRANSITIONS“. A transition is defined by attributes “from” and “to“, which describe the actual state and the new state, you would like to assign to the work item. When you update a work item state, you need to pass in your JSON following fields:

  1. New state (System.State)
  2. Reason (System.Reason) You can find allowed reasons in the transition definition under “TRANSITION/REASONS“. I always take the DEFAULTREASON for that.
  3. For some transition there are some required fields defined, you need to pass with your request. You find them under “TRANSITION/FIELDS
  4. Under “WITD/WORKITEMTYPE/WORKFLOW/STATES” you can find state definitions. Check the definition for your new state. In this definition, under “FIELDS” you can find a list of required and empty fields. You can distinguish them on their child node, which will be <REQUIRED /> or <EMPTY />.

In you work item update JSON, you need to pass updates for all this fields. When a field is supposed to be empty, you just pass null as its value. For required field and fields from 3. you need to assign some proper values. From my experience I can say, that these are always fields, that match following pattern: “xxxDate“, “xxxBy” and “xxxTo“. For the first one you need to assign a string with a date with following formatting:


For the other kinds (“xxxBy” and “xxxTo“) you need to assign a display name of a user. For my individual case it will be “Jakub Sabacinski“. You must find out yourself, which user display name you will use. It should be a project member of course.You should keep in mind, that the set with required fields and and the set with fields from 3. can contain the same elements. You must be careful not to pass a field twice with your request.

2. Example

I would like to update state of a Requirement from my project to “Active“. I obtained work item id and revision number using a REST API query. I know the actual work item state as well, which is “Resolved” Now I search for the transition from “Resolved” to “Active” in the configuration file for a Requirement. I take the default reason, which is “Validation Test Failed“. I also see, that the fields  “Microsoft.VSTS.Common.ActivatedBy” and “Microsoft.VSTS.Common.ActivatedDate” are required for this transition, so I assign them the user name and the actual date.

Transition definition:

   1: <TRANSITION from="Resolved" to="Active">

   2:   <REASONS>

   3:     <DEFAULTREASON value="Validation Test Failed" />

   4:   </REASONS>

   5:   <FIELDS>

   6:     <FIELD refname="Microsoft.VSTS.Common.ActivatedBy">

   7:       <COPY from="currentuser" />

   8:       <VALIDUSER />

   9:     </FIELD>

  10:     <FIELD refname="Microsoft.VSTS.Common.ActivatedDate">

  11:       <SERVERDEFAULT from="clock" />

  12:     </FIELD>

  13:   </FIELDS>


After that, I read the definition for the state “Active”. I find out, that required field for this state are: “Microsoft.VSTS.Common.ActivatedDate“,  “Microsoft.VSTS.Common.ActivatedBy” and “System.AssignedTo“. The two first of them I have already assigned. For the field “System.AssignedTo” I do nothing, because I know from my first REST query, that this field has already a value. For each empty field (“Microsoft.VSTS.Common.ResolvedDate”, “Microsoft.VSTS.Common.ResolvedBy”, “Microsoft.VSTS.Common.ResolvedReason”, “Microsoft.VSTS.Common.ClosedDate” and  “Microsoft.VSTS.Common.ClosedBy”) I assigned null as value.

State definition:

   1: <STATE value="Active">

   2:   <FIELDS>

   3:     <FIELD refname="Microsoft.VSTS.Common.ResolvedDate">

   4:       <EMPTY />

   5:     </FIELD>

   6:     <FIELD refname="Microsoft.VSTS.Common.ResolvedBy">

   7:       <EMPTY />

   8:     </FIELD>

   9:     <FIELD refname="Microsoft.VSTS.Common.ResolvedReason">

  10:       <EMPTY />

  11:     </FIELD>

  12:     <FIELD refname="Microsoft.VSTS.Common.ClosedDate">

  13:       <EMPTY />

  14:     </FIELD>

  15:     <FIELD refname="Microsoft.VSTS.Common.ClosedBy">

  16:       <EMPTY />

  17:     </FIELD>

  18:     <FIELD refname="Microsoft.VSTS.Common.ActivatedDate">

  19:       <REQUIRED />

  20:     </FIELD>

  21:     <FIELD refname="Microsoft.VSTS.Common.ActivatedBy">

  22:       <REQUIRED />

  23:     </FIELD>

  24:     <FIELD refname="System.AssignedTo">

  25:       <REQUIRED />

  26:     </FIELD>

  27:   </FIELDS>

  28: </STATE>


So, at the end, my JSON, which I’m going to send as a content for a PATCH-Request, looks like this:

   1: {

   2:     "id": xx,

   3:     "rev": yy,

   4:     "fields": [{

   5:         "field": {

   6:             "refName": "System.State"

   7:         },


   9:         "value": "Active"

  10:     },

  11:     {

  12:         "field": {

  13:             "refName": "System.Reason"

  14:         },


  16:         "value": "Validation Test Failed"

  17:     },

  18:     {

  19:         "field": {

  20:             "refName": "Microsoft.VSTS.Common.ActivatedBy"

  21:         },


  23:         "value": "Jakub Sabacinski"

  24:     },


  26:     {

  27:         "field": {

  28:             "refName": "Microsoft.VSTS.Common.ActivatedDate"

  29:         },


  31:         "value": "2014-08-25T19:14:04.594Z"

  32:     },

  33:     {

  34:         "field": {

  35:             "refName": "Microsoft.VSTS.Common.ResolvedDate"

  36:         },


  38:         "value": null

  39:     },

  40:     {

  41:         "field": {

  42:             "refName": "Microsoft.VSTS.Common.ResolvedBy"

  43:         },


  45:         "value": null

  46:     },

  47:     {

  48:         "field": {

  49:             "refName": "Microsoft.VSTS.Common.ResolvedReason"

  50:         },


  52:         "value": null

  53:     },

  54:     {

  55:         "field": {

  56:             "refName": "Microsoft.VSTS.Common.ClosedDate"

  57:         },


  59:         "value": null

  60:     },

  61:     {

  62:         "field": {

  63:             "refName": "Microsoft.VSTS.Common.ClosedBy"

  64:         },

  65:         "value": null

  66:     }]

  67: }

3. Conclusion

As you could see, changing work item state is very cumbersome and requires from a developer a chain of trials and errors, to find a solution for this problem. The VSO REST API unfortunately isn’t very helpful in this case. All fields you need to assign a value to, should be expected to be assigned with proper value by the server. Since the VSO REST API is still in preview, we can hope, that Microsoft will eventually implement this that way. This would save all of us some work. I have submitted a user voice for this issue, so if some one is also missing this functionality, he is kindly asked to vote for it here.

I hope, I could help people struggling with this issue and make the world a little bit better. All kind of feedback would be also appreciated, so don’t hesitate to write a comment below.

How to change work item state using Visual Studio Online REST API is a post from: AIT Blog

ppedv Team Blog: Windows 8 direkt im Desktop starten

Nach dem anmelden startet Windows 8 standardmäßig auf der Metro-Oberfläche. In Windows 8.1 lässt sich einfach über die Taskleiste konfigurieren, ob der Benutzer nach der Anmeldung auf dem Windows-Desktop oder auf der Startseite landen möchte. Dies lässt sich unter Windows 8.0 über eine Gruppenrichtlinie erzwingen:

  1. Gehen Sie im Gruppenrichtlinien-Editor auf Benutzerkonfiguration –> Administrative Vorlagen –> System –> Anmelden (Hintergrund oben).

  2. Gehen Sie nun in der rechten Spalte auf die Richtlinie Diese Programme bei der Benutzeranmeldung ausführen.

  3. Im Optionsfeld Aktiviert (Vordergrund rechts) können Sie auf die Schaltfläche Anzeigen klicken.

  4. Tragen Sie nun bei Inhalt anzeigen im Feld Wert den Text »explorer.exe« ein. (Vordergrund links) Anschließend können alle offenen Fenster über die OK-Schaltfläche geschlossen werden.



Bei erneuter Anmeldung erscheint als erstes wieder die Startseite der Metro-Oberfläche. Nach kurzer Zeit schaltet Windows 8.0 aber zum Desktop um.


Sollte eine Gruppenrichtlinie nicht sofort wirksam werden, öffnen Sie eine Eingabeaufforderung als Administratorund führen Gpupdate /force aus.

Holger Sirtl: Serie: Eigene Anwendungen auf Microsoft Azure - Teil 4: Websites

Microsoft Azure bietet zur Ausführung eigener Anwendungen in der Public Cloud vier Optionen: Virtual Machines, Cloud Services, Websites und Mobile Services. Diese Blog-Serie gibt Hinweise zur Entscheidung für die zu einem konkreten Vorhaben beste Alternative, Die Serie ist unterteilt in 7 Teile:

Dieser Teil geht auf Cloud Services ein.

Konzept der Websites

Microsoft Azure Websites stellen eine kostengünstige, aber trotzdem gut skalierbare Hosting-Variante für Websites bereit. Im Grunde sind Websites das Pendant einer virtuellen Serverumgebung eines Hosting-Anbieters. Über das Microsoft Azure Portal können sehr schnell und einfach Umgebungen eingerichtet, mit zahlreichen Web Frameworks (ASP.NET, Java, PHP, Node.js, ...) und Anwendungen (Joomla, Wordpress, Drupal, ...) vorkonfiguriert und von verschiedenen Entwicklungsplattformen aus mit Webanwendungen bestückt werden. Hierbei werden als Deployment-Optionen unter anderem GIT, FTP, WebDeploy und TFS Deploy unterstützt. Das Portal bietet hierzu verschiedene Deployment-Skripte an, die in eigene Entwicklungsumgebungen importiert werden können. Damit können Websites neben Windows auch in Nicht-Microsoft-Umgebungen wie Linux oder MacOS entwickelt und dann auf Microsoft Azure betrieben werden. Auch ist ein automatisiertes Deployment direkt aus Quellcode-Verwaltungen (unter anderem Git, TF Service, Dropbox, Skydrive, …) heraus möglich. Sobald ein Entwickler neuen Code einstellt, erfolgt automatisch ein neues Deployment (welches über das Portal auch rückgängig gemacht werden kann), so dass eine Website stets auf dem aktuellsten Quellcode-Stand ist.


Abb 1: schematischer Aufbau einer Website
Windows Azure Poster)

Zur Ausführung der Websites stehen mehrere Betriebsarten zur Verfügung: im "Shared"-Modell werden eine oder mehrere Instanzen der Anwendung in einer Multi-Mandanten-Umgebung betrieben, im kostenlosen „Free“-Modell ist die Zahl der Instanzen auf eine einzige beschränkt, im "Basic"-Modell erfolgt der Betrieb in exklusiv für die Anwendung bereitgestellten virtuellen Maschinen. Das „Standard“-Modell bietet darüber hinaus noch Backup und Restore, Auto-Scaling, Webjobs, Scheduler Unterstützung und das stufenweise Publishing über eine oder mehrere Staging-Umgebung.

Zwischen den Betriebsarten kann flexibel gewechselt werden. Damit ist sowohl Scale-out (Hinzuschalten zusätzlicher Instanzen gleicher Größe) als auch Scale-up (Vergrößerung der bestehenden Instanzen im „Basic“- oder „Standard“-Modell) zur Anpassung der Umgebung an sich ändernde Last möglich. Dies kann im „Standard“-Modell mit der AutoScale-Funktion auch (in Abhängigkeit von der CPU-Last) automatisiert werden. Konfiguration und Verwaltung der zur Ausführung von Websites genutzten virtuellen Maschinen wird vollständig durch Microsoft Azure übernommen.

Für die Persistierung von Daten stehen als Datenbanken MySql und Microsoft Azure SQL Database zur Auswahl. Aus Websites heraus können natürlich auch die weiteren Dienste der Microsoft Azure Plattform genutzt werden. So kann eine Website Authentifizierung von Benutzern über das Azure Active Directory durchführen oder einen in einer Virtual Machine betriebenen SQL Server aufrufen.

Entwicklung von Websites

Die Entwicklung einer Website unterscheidet sich nicht von der Entwicklung einer klassischen Web-Anwendung, die lokal in einem Internet Information Server oder bei einem Hoster betrieben werden soll. Entwickler, die sich in den unterstützten Technologien (ASP.NET, PHP, Java, …) auskennen, können unmittelbar für Azure Websites entwickeln.

Im Falle von ASP.NET können Web-Anwendungen direkt aus Visual Studio via Publish-Befehl in eine Website installiert werden. Alternativ können auch diverse Quellcode-Verwaltungssysteme (TFS, Git, GitHub, etc.) so konfiguriert werden, dass sie nach Übertragung von Änderungen aus der Entwicklungsumgebung automatisch ein Deployment auf die konfigurierte Website anstoßen. Der Aufwand für den Entwickler ist somit minimal. Innerhalb von Minuten kann eine Web-Anwendung über eine Website in der Cloud bereitgestellt werden. Entsprechende Automatismen existieren in Eclipse für Java, PHP etc.

Die Umgebung einer Website, d.h. das zugrundeliegende Betriebssystem, die Skalierungseinstellungen, Backups, Failover werden automatisiert von Azure verwaltet. Der Entwickler kann sich vollständig auf die Anwendungslogik konzentrieren und muss sich nicht mit dem Infrastruktur-Setup auseinandersetzen. Auf der anderen Seite sind die Einflussmöglichkeiten auf die Umgebung (z.B. Öffnen von Ports, Konfiguration via Remote Desktop, …) auch stark begrenzt. Hier muss der Anwender also abwägen zwischen schneller, flexibler Bereitstellung und individuellen Einflussmöglichkeiten auf die Umgebung.


Websites stellen die einfachste (aber dennoch sehr leistungsfähige) Ausführungsoption für eigene Web-Anwendungen dar. Die Entwicklung für Websites unterscheidet sich nicht von der Entwicklung einer nicht auf Azure betriebenen Web-Anwendung. Der Einlernaufwand für die Entwickler ist minimal, d.h.

  • wann immer möglich, d.h. wenn es keinen entscheidenden Grund dagegen gibt, sollten Websites als Ausführungsoption gewählt werden.

Cloud Services oder Virtual Machines sollten nur dann verwendet werden, wenn z.B. einer der folgenden Anforderungen gegeben ist

  • Es wird direkter Zugriff auf Services-Instanzen via Remote Desktop benötigt
  • Linux als Umgebung wird benötigt (wird derzeit nur von Virtual Machines unterstützt)
  • Spezielle Umgebungs- und Netzwerk-Konfigurationen werden benötigt (spezielle Ports, Virtual Network etc.)

Weitere Informationen

Informationen zu Websites

Informationen zur allgemeinen Entscheidung für ein Ausführungsmodell

Johnny Graber: Praktische Helfer rund um AngularJS

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



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

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



Mehrere Browser zusammen verwenden

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

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



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

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




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



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



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



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



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

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

Einsortiert unter:.Net, dnugBern, webDotNet Tagged: .Net, Tools, Web

Alexander Schmidt: Eine Solution bauen

Der Titel klingt zugegebenermaßen trivial. Ich habe allerdings immer wieder feststellen müssen, dass vielen auch langjährigen VS-Programmierern gar nicht klar ist, wie eine Solution skalierbar und im Hinblick auf Multi-Tier gebaut werden sollte. Hier ein Vorschlag. Screencast Einleitung Sieht man sich den einen oder anderen Screencast im Netz an, kann schnell der Eindruck entstehen, eine […]

codefest.at [MS]: Es wird doch alles immer wieder (komplexer) einfacher

Was passiert jetzt mit ASP.NET vNext? Alles Neu?

Technologien mit vielen Optionen machen das Programmieren nicht einfach. Entscheidungen stehen an. Entscheidungen die sich oft auf viele Jahre auswirken. Applikationen müssen gewartet werden. Steht diese Technologie auch in ein paar Jahren noch zur Verfügung oder wird das wieder abgelöst?


Wie einfach war noch .NET 1.0. Windows Forms und Web Forms, und das mit etwa 3000 Klassen. Die Anzahl der Klassen wurde im Lauf der Zeit immer mehr. 4000 Klassen mit .NET 1.1, mit den Generics bei .NET 2.0 waren es dann schon 8000. Jetzt unbedingt die richtige Collection Klasse nehmen, nicht mehr eine der alten Collections die statt T auf Objekten basierten.

Mit .NET 3.0 gab’s dann entweder Windows Presentation Foundation (WPF) oder Windows Forms zur Auswahl bei der Entwicklung von Desktop Applikationen. Windows Communication Foundation (WCF) hat die Kommunikation mit ASP.NET Web Services und .NET Remoting abgelöst. Für Kommunikation war der große Vorteil dass nur mehr eine Programmierschnittstelle gelernt werden mußte. Die hat in allen Szenarien funktioniert. Wobei, ob WCF das wirklich einfacher gemacht hat? Neu mit .NET 3.0 war auch Windows Workflow Foundation (WF): eine Workflow Engine out of the box.

Einfacher wurde dann wieder alles mit .NET 3.5, LINQ und Lambda Expressions. Für den Datenbankzugriff gabs ab .NET 3.5.1 die Auswahl und Entscheidungsnotwendigkeit zwischen LINQ to SQL und dem Entity Framework.

Mit .NET 3.5 gab es auch ein neues Add-In Modell: System.AddIn. Da besteht keine Notwendigkeit mehr ein eigenes Add-In Modell aufzubauen. Die Architektur ist vorgegeben und jetzt einfach reinhängen… Hmmm… einfach ist System.AddIn ja doch nicht. Mit .NET 4.0 und dem Managed Extensibility Framework (MEF) wurde ein Add-In Modell dann doch noch einfach. Ist bekannt dass es da mittlerweile zwei Versionen gibt? System.ComponentModel.Composition und System.Composition. Eine Variante für das große Framework, und die kleinere für Portable Class Libraries (PCL). Nebenbei ist auch die Workflow Foundation neu entstanden. Achtung welche Klassen jetzt verwendet werden, da könnte man in Konflikt geraten. System.Workflow und System.Activities. Ich hätte ja auf einigen Klassen das Obsolete Attribute daraufgesetzt. Da gab es dann scheinbar doch zu viele Gegenstimmen.

Entity Framework hat sich weiterentwickelt. Database First oder Model First oder Code First. Wobei Code First ja nicht heißen muss zuerst Code und dann die Datenbank. Es kann auch umgekehrt sein und trotzdem Code First heißen. Wie auch Windows Store Apps nicht nur vom Windows Store installiert werden können.

Statt Web Forms steht auch ASP.NET MVC zur Wahl. Für die Entwicklung am Desktop war auch Silverlight mal eine Option. Oder doch gleich auf Windows Store Apps setzen? Unsere User sind noch nicht so weit? Dann doch WPF oder überhaupt zu HTML und JavaScript wechseln?

WCF ist doch zu komplex geworden. Mit ASP.NET Web API ist REST-basierte Kommunikation viel einfacher.

Mein Job ist es sich mit neuen Technologien zu beschäftigen. Aber ein Entwickler der in Projekten arbeitet hat keine Chance da am Laufenden zu bleiben um nicht falsche Entscheidungen zu treffen. Und dabei gibt es auch in nicht so offensichtlichen Bereichen Änderungen. Ein Beispiel? Seit Windows Vista gibt es neues Event Logging System. Das ist auch im .NET Framework abgebildet. Da haben wir doch eine EventLog Klasse im Namespace System.Diagnostics mit der man in den Event Log schreiben kann, und EventProvider im Namespace System.Diagnostics.Eventing. Laut Dokumentation erfüllen beide Klassen den gleichen Zweck. Ist schon bekannt dass es seit .NET 4.5 ein neues Tracing mit dem Namespace System.Diagnostics.Tracing gibt, oder ist diese Information an der Unzahl an neuen Features übersehen worden? Das ist die dritte Version nach der Trace Klasse ab .NET 1.0 und TraceSource ab .NET 2.0. Und jetzt habe ich noch überhaupt nicht die NuGet Packages die auch zum .NET Framework gehören erwähnt.

.NET 1.0 wurde im Jahr 2000 vorgestellt und 2002 released. Seitdem ist viel Zeit vergangen und sowohl Erweiterungen als auch Änderungen bringen mehr Komplexität. Es ist Zeit einen Neustart zu machen.

Der Neustart passiert jetzt mit Visual Studio „14“. Visual Studio “14”, das ist nicht „Visual Studio 2014“. Visual Studio 2013 hat die Versionsnummer „12“, „13“ muss (wie auch bei Office) ausgelassen werden, und Version „14“ könnte zu einem Visual Studio 2015 werden; oder es bleibt bei Visual Studio 14 wenn wieder auf Versionsnummern statt Jahreszahlen umgestellt wird.

ASP.NET vNext (inkludiert ASP.NET MVC 6) vereinheitlicht Web Frameworks mit MVC, Web API und Web Pages. Bisher hatten – aus Historiengründen – der Controller von MVC und Web API unterschiedliche Basisklassen. Das wird jetzt vereinheitlicht. Kompatibilität zu Active Server Pages (ASP) – was im Jahr 2000 notwendig war – entfernt. Das bringt eine Menge Performance und reduziert benötigte Runtime-Resources. Das dafür verwendete .NET Framework braucht 11 MB statt den 200 MB des kompletten Frameworks. ASP.NET Web Forms kann da getrost weggelassen werden. Natürlich macht es da Sinn gleichzeitig Änderungen einzuführen, wie z.B. JSON statt XML Konfiguration.

Der Neustart hört mit ASP.NET nicht auf. Entity Framework 7 wird ganz neu geschrieben.  Auch hier gibt es Varianten die man in neuen Applikationen schon heute besser nicht mehr nutzt. Entity Framework wird in der neuen Version nicht nur ein Framework für relationale Datenquellen. Einen Azure Table Storage Provider wird es hier auch geben.

Natürlich wird der Neustart einfacher wenn schon jetzt auf die richtigen Architekturen und Modelle gesetzt wird. Und mit vNext wird mit Reduzierung dann alles wirklich einfacher.

Dabei müssen wir aber noch hoffen dass die Dokumentation gelöst wird. Suche ich nach Samples zu Klassen, welche werde ich dann finden? Alt oder neu? Bing integriert im Visual Studio wird hoffentlich die richtige Version der Samples zum geöffneten Projekt finden.

Viel Spaß in der Zukunft!

Christian Nagel

Christian Nagel ist Microsoft Regional Director und MVP für Visual C#, Buchautor, Trainer und Consultant.
Twitter:  @christiannagel
CN innovation

Image © Eabffx | Dreamstime.com - Endless Labyrinth Photo

Das ist ein Gastbeitrag. Die Meinung des Autors muss sich nicht mit jener von Microsoft decken. Durch den Artikel ergeben sich keinerlei Handlungsempfehlungen. Microsoft übernimmt keine Gewähr für die Richtigkeit oder Vollständigkeit der Angaben.

ppedv Team Blog: Windows 7/8 - Fenstervorschau anpassen

Die Vorschau der geöffneten Fenster lässt sich von ihrem Verhalten her anpassen, wenn sich der Mauszeiger auf einem Programmsymbol befindet. Sowohl die kurze Verzögerung der Anzeige als auch die Größe der eingeblendeten Fenster können angepasst werden.


Hierzu rufen Sie den Registrierungs-Editor auf, drücken Sie auf die Windows-Taste + R und geben den Befehl regedit ein.


Öffnen Sie hierfür links den Ordner:

HKEY_CURRENT_USER\Control Panel\Mouse -> MouseHoverTime



Ändern Sie die Angabe im Feld Wert (0 statt der Voreinstellung 400 ms)

Ändern Sie auf Wunsch ggf. auch noch die Größe der Fenster.

Öffnen Sie dazu links den Ordner:


Klicken Sie mit der rechten Maustaste in den rechten Bereich des Fensters -> Neu ->
DWORD-Wert (32-Bit) -> Name: MinThumbSizePx

Doppelklicken Sie auf den neuen Eintrag -> Wert z.B. 400 Basis: Dezimal -> OK


Schließen Sie die Registrierdatenbank, starten Sie den Computer neu, danach sind die Einstellungen gültig und funktionieren.


Im Vergleich zu den Fenstern im Screenshot oben ist deutlich zu sehen, dass die sog. Sprungfenster deutlich größer dargestellt werden.

ppedv Team Blog: Windows 8 - Schaltfläche Desktop anzeigen in der Taskleiste

Jahrelang hat uns Benutzer eine kleine Schaltfläche auf der Taskleiste begleitet, mit der wir per Klick den Desktop angezeigt bekamen, d.h. alle Programme wurden minimiert. Wer diese Funktionalität vermisst, liest hier wie man sie zurückbekommt.

Rechtsklick auf den Desktop -> Neu -> Verknüpfung


In das geöffnete Feld für den Speicherort folgenden Inhalt eingeben:
explorer shell:::{3080F90D-D7AD-11D9-BD98-0000947B0257}


Klicken Sie auf Weiter

Jetzt einen Namen eingeben, z.B. Desktop anzeigen. Klicken Sie dann auf Fertig stellen.


Rechtsklick, Eigenschaften aufrufen -> Schaltfläche Anderes Symbol -> Durchsuchen -> Ordner System32 -> imageres.dll auswählen. Hier ein Icon nach Wahl auswählen, OK.

clip_image008 clip_image010

Danach Rechtsklick auf die Verknüpfung -> An Taskleiste anheften


Abschließend gegebenenfalls die Position mit gedrückter linker Maustaste verändern.

Tipp: die angehefteten Programme in der Taskleiste lassen sich per Tastenkombination
Windows + Shift + 1-10 bequem starten.


Hierbei muss man wissen, dass die Position der Icons von links aus entscheidend ist. Die Start-Schaltfläche zählt nicht, also wird ab der zweiten Position gezählt.

In meiner Konfiguration wird Desktop anzeigen mit Windows + Shift + 1 ausgeführt.


Karsten Kempe: Sprecher am Herbstcampus 2014

HerbstcampusAnfang September ist es wieder soweit. Der Herbstcampus öffnet zum 7. Mal seine Pforten. Vom 01.09. bis 04.09. wird es zahlreiche Vorträge zu den Technologie-Schwerpunkten .NET und Java geben. Ich werde am Donnerstag 04.09. Einblick in die Promi-Beziehung von TFS und Git geben und zeigen wie Entwickler von der TFS-Git-Integration profitieren können.

TFS liebt GIT

TFS im Zusammenspiel mit GIT

Promi-Hochzeiten hat und wird es immer geben. Meist sind die beiden Partner erfolgreich und sexy. Als sich TFS und Git zueinander bekannten, war die Skepsis groß. Er (der TFS) ist laut Gartner die führende ALM-Plattform, gilt aber als schwer und behäbig. Sie (Git) ist eine der angesagtesten Versionskontrollen unserer Zeit, leicht und sexy! Würde diese Beziehung gut gehen? Diese Liebe hält nun schon seit mehr als einem Jahr und ist enger als je zuvor. Grund genug also, um sich die Partnerschaft einmal näher anzusehen. Wer profitiert von wem? Und warum sind sie als Paar so außerordentlich erfolgreich?

In diesem Vortrag erhalten Sie einen Eindruck über das Zusammenspiel von Git und TFS und sehen wie man als Entwickler von den Stärken der Beiden profitieren kann.

Herbstcampus Konferenz

Der Herbstcampus beschäftigt sich mit Themen rund um die Software-Entwicklung. Im Vordergrund stehen dabei die Methoden, Techniken und Technologien, die eine effiziente Software-Entwicklung ermöglichen. Technologieschwerpunkte sind dabei .Net und Java.

Technologieübergreifend reichen die Themen beispielsweise von Anforderungen, Test und Qualität über Architekturen, Design-Patterns und Programmierparadigmen bis hin zu Nebenläufigkeit, Performanz, Persistenz und Sicherheit. Zum Teil werden diesen Themen eigene Vortragsreihen gewidmet.

Holger Sirtl: Serie: Eigene Anwendungen auf Microsoft Azure - Teil 3: Cloud Services

Microsoft Azure bietet zur Ausführung eigener Anwendungen in der Public Cloud vier Optionen: Virtual Machines, Cloud Services, Websites und Mobile Services. Diese Blog-Serie gibt Hinweise zur Entscheidung für die zu einem konkreten Vorhaben beste Alternative, Die Serie ist unterteilt in 7 Teile:

Dieser Teil geht auf Cloud Services ein.

Konzept der Cloud Services

Auf den ersten Blick sind Cloud Services die komplexeste Ausführungsoption. Um zu verstehen, was Cloud Services ausmacht – denn tatsächlich sind sie wohl auch die leistungsfähigste Option –, lohnt ein Blick auf die Historie von Azure. Cloud Services waren die erste und seinerzeit einzige Ausführungsoption für eigene Anwendungen. Idee war und ist es, dass bestimmte Paradigmen für skalierbare Cloud-basierte Anwendungen durch die Azure Plattform vorgegeben sind:

  • ein Cloud Service ist ein technischer Container für eine oder mehrere VM-Instanzengruppen, genannt Rollen
  • es gibt zwei Arten von Rollen: Web Rollen (für Web-Frondend-Funktionalität) und Worker Rollen (für Hintergrundprozesse)
  • eine Rolle enthält eine oder mehrere identisch konfigurierte (gleicher Inhalt, gleiche Größe etc.) VM-Instanzen
  • die verwendeten VM-Instanzen sind nicht persistent, ein zustandsloses Design der Anwendung wird vorausgesetzt
  • sämtliche Konfigurationspakete und -einstellungen müssen in einem speziellen Anwendungspaket enthalten sein

Zugriff auf den Cloud Service ist ausschließlich über einen vorgeschalteten Azure Loadbalancer möglich. Der Loadbalancer verteilt eingehende Requests gleichmäßig auf die zum Empfang konfigurierten Rolleninstanzen. Web Rollen sind per Voreinstellung für den Empfang auf Port 80 (http) konfiguriert. Web Rollen können für Hintergrundverarbeitung Aufträge (z.B. via Azure Queues) an Worker Rollen verteilen. Abb 1 zeigt den schematischen Aufbau einer Cloud-Service-basierten Anwendung.


Abb 1: schematischer Aufbau eines Cloud Service
Windows Azure Poster)

Diese Vorgaben ermöglichen eine flexible Skalierbarkeit und erlauben der Azure Plattform, bei Bedarf neue Instanzen zu provisionieren oder ausgefallene Instanzen automatisch zu ersetzen. Entsprechend liegt bei Cloud Services der Fokus auf hoch-verfügbaren, hoch-skalierenden Multi-Tier-Web-Anwendungen, die maximal von der flexiblen Ressourcenbereitstellung der Public Cloud profitieren können. Die einzelnen Rollen können unabhängig voneinander skaliert werden. Microsoft Azure übernimmt dabei das Management der zur Ausführung der Rollen benötigten virtuellen Maschinen. Dies schließt Upgrades der Gast-Betriebssysteme, Patching und Failover (ausgefallene Komponenten werden automatisch ersetzt) ein. Anders als bei Websites haben Entwickler vollen administrativen Zugang auf die virtuellen Maschinen, um beispielsweise zusätzliche Software in die einzelnen Instanzen zu installieren. Hierzu werden auch Remote Desktop Verbindungen zur Administration unterstützt. Rollen können unabhängig voneinander skaliert werden (Hinzuschalten bzw. Entfernen von Instanzen); mit der Autoscaling-Funktion kann dieser Vorgang auch (in Abhängigkeit von verschiedenen Lastparametern) automatisiert werden.

Entwicklung von Cloud Services

Die Entwicklung von Cloud Services kann über Visual Studio oder auch Eclipse erfolgen. Die Anwendungen können zunächst in einem Azure Emulator lokal ausgeführt und - nach erfolgreichem Test - direkt aus der Entwicklungsumgebung heraus in die Cloud deployt werden. Cloud Services bieten demnach Entwicklung und Betrieb von Anwendungen im Sinne des PaaS-Modells (PaaS = Platform-as-a-Service). Cloud Services bieten dabei mehr Kontrolle über das Deployment und die Verteilung von Anwendungskomponenten als Websites.

Microsoft Azure basierte Cloud Services werden in der Cloud letztlich in auf Windows Server basierenden virtuellen Maschinen (VMs) ausgeführt. Es hängt vom Aufbau des Cloud Service, der gewählten Instanzgrößen und VM Versionen ab, wie diese VMs von Microsoft Azure konfiguriert werden. Der Entwickler kann den Aufbau über eine Cloud-Service-Definition (csdef) und eine Cloud-Service-Konfiguration (cscfg) bestimmen. Im Deploymentpaket, welches von Visual Studio, Eclipse oder Kommandozeilentools erstellt werden kann, befinden sich dann alle zur Ausführung der Anwendung benötigten Komponenten (Anwendungscode, Libraries, Frameworks, Serversysteme etc.). Der Rest wird von Microsoft Azure übernommen. Wird die Zahl der Instanzen (durch Änderung der Konfiguration oder durch Nutzung der AutoScale-Funktion) zur Laufzeit geändert, werden entsprechend Instanzen automatisch heruntergefahren bzw. zusätzliche Instanzen provisioniert und der vorgeschaltete Loadbalancer passend umkonfiguriert. Der administrative Aufwand für den Nutzer beschränkt sich somit auf ein Minimum. Die Kosten für den Betrieb werden pro Stunde angesetzt. Werden neue virtuelle Maschinen erzeugt (z.B. bei einem größeren Patch oder bei Hardware-Ausfall), so wird ihr Zustand auf den Deployment-Zeitpunkt zurückgesetzt, d.h. die virtuelle Maschine wird aus einem Basis-Image und dem Deployment-Paket erzeugt. Anders als bei Virtual Machines sind die virtuellen Maschinen von Cloud Services nicht persistent. In Cloud Services ausgeführte Anwendungen sollten ihren Zustand also außerhalb der virtuellen Maschinen (z.B. in Microsoft Azure Storage oder SQL Database) speichern und die Laufwerke innerhalb der virtuellen Maschinen nur für Caching-Zwecke nutzen.


Die Microsoft Azure Dokumentation enthält einen tabellarischen Überblick über die Möglichkeiten der einzelnen Ausführungsoptionen. Als Fazit kann für Cloud Services gezogen werden: Cloud Services sollten dann verwendet werden, wenn folgende Voraussetzungen gegeben sind:

  • Die Vorteile einer automatisch verwalteten Umgebung im Sinne eines PaaS-Ansatzes sollen genutzt werden sollen.
  • Gleichzeitig wird die Flexibilität eines direkten Zugriffs auf die virtualisierte Umgebung (d.h. administrativer Zugriff auf einzelne Instanzen) benötigt.
  • Skalierung ggf. auch nur in einzelnen Rollen erfolgen soll.

Virtuelle Maschinen sollten Cloud Services vorgezogen werden, wenn

  • Linux als Gast-OS benötigt wird (nur Virtuelle Maschinen unterstützen Linux)
  • persistente VM-Instanzen benötigt werden (weil z.B. eine Datenspeicherung im Dateisystem erfolgt)
  • eine Paketierung der Anwendung (weil z.B. bestimmte Frameworks und Konfigurationseinstellungen benötigt werden) zu aufwändig wäre

Websites bzw. Mobile Services sollten Cloud Services vorgezogen werden, wenn

  • die von Websites vorgegebene Umgebung (z.B. ASP.NET) bereits die Anforderungen erfüllt
  • die Web-Anwendung nicht weiter in Rollen unterteilt werden muss und die Skalierung immer die Gesamt-Anwendung betrifft

Letztlich gilt aber auch für Cloud Services die Kombinierbarkeit mit weiteren Ausführungsoptionen, d.h. es ist durchaus möglich, von einer Cloud-Service-Web-Role zur Datenspeicherung auf einen in einer Virtual Machine betriebenen SQL Server zuzugreifen.

Weitere Informationen

Informationen zu Cloud Services

Informationen zur allgemeinen Entscheidung für ein Ausführungsmodell

Johannes Renatus: FileUpload mit AngularJS und ASP.NET MVC mit HttpPostedFileBase

Leider gibt es in AngularJS keine nativ integrierte Direktive für den Upload von Dateien. Es existieren aber diverse Möglichkeiten auch mit AngularJS Dateien hochzuladen. Zum einen gibt es zahlreiche fertige Upload Direktiven von Community Mitgliedern https://github.com/danialfarid/angular-file-upload https://github.com/twilson63/ngUpload https://github.com/nervgh/angular-file-upload/ uvm. Wenn man nur einen simplen Upload von Dateien umsetzen möchte, kann man das ganze auch recht […]

codefest.at [MS]: 2D Unity Game Tutorial mit Sample Code

Vor dem Sommer haben wir einen Hackathon für Frauen zum Thema “Apps & Games” veranstaltet, in dem wir auch das erste Mal das Thema Gaming angesprochen haben. An diesem Hackathon hat Bernadette Thalhammer von der Sproing Interactive Media GmbH für die Teilnehmerinnen einen Game Development Workshop abgehalten. Eindrücke des Hackathons gibt es natürlich auch online.

Der Sample Code des Unity Projektes aus diesem Workshop ist nun auf GitHub verfügbar. Wenn ihr das Tutorial ausprobieren wollt, so könnt ihr direkt anhand dieser Anleitungendas Spiel nachbauen, das ein Slide Shooter Game darstellt. Falls ihr Unity3D noch  nicht installiert habt, so findet ihr sie hier als Download. Eine Einführung in die 2D Spiele Entwicklung mit Unity findet ihr natürlich auch auf der MVA. Auch ein ganzer JumpStart Kursist hier demnächst geplant.

Um das Hackathon Projekt als Windows Phone oder Windows Store App zu bauen, müsst ihr dieses Projekt von GitHub in der Unity3D IDE öffnen. Dort geht ihr auf File/Build Settings… und wählt eure Platform aus, zb Universal Project, um gleich als Windows Store und Windows Phone App zu deployen.


Wenn ihr nach eurer Auswahl auf Build klickt, so könnt ihr ein Verzeichnis wählen/erstellen, in dem eure Visual Studio Solution erstellt wird.


Danach ist alles wie gehabt. Ihr öffnet die Solution in Visual Studio und seht dort eure Windows Phone bzw Universal App Projekte, von denen ihr dann die Store Packages zum Upload in den Store erstellen könnt.

Viel Spaß beim Spielen! :)

Paul Mizel: async await und parallel - eine einfache Messung

Es ist nicht immer sinnvoll async und await zu verwenden, auch in einem Parallel-Szenario, für wenige Operationen hat es sogar Nachteile.

Nachmessen hilft.

class Program{

static void Main(string[] args)


int runs = 10000;

using (Monitor.Create("Task: "))


for (int i = 0; i < runs; i++)


Task task = new Task(ProcessDataAsync);





using (Monitor.Create("Normal: "))


for (int i = 0; i < runs; i++)





using (Monitor.Create("Parallel Task: "))


Parallel.For(0, runs, i =>


Task task = new Task(ProcessDataAsync);





using (Monitor.Create("Parallel Normal: "))


Parallel.For(0, runs, i =>





Console.ReadKey();    }

static async void ProcessDataAsync()


Task<int> task = Task.FromResult(5);


int x = await task;


static void ProcessData()





public class Monitor : IDisposable


System.Diagnostics.Stopwatch sw;

string prefix;

public Monitor(string prefix)


this.prefix = prefix;

sw = System.Diagnostics.Stopwatch.StartNew();


public static Monitor Create(string prefix)

{ return new Monitor(prefix); }

public void Dispose()

{ Console.WriteLine(prefix + sw.ElapsedMilliseconds + " ms"); }


Martin Hey: noHistory in der Activity und der Seiteneffekt

Normalerweise kann man im savedInstanceState Statusinformationen ablegen, die dann beim Resume der Activity dafür sorgen, dass die Benutzeroberfläche wieder so hergestellt werden kann, wie sie war bevor die App in den Ruhemodus versetzt wurde.

Heute hatte ich das Phänomen, dass im onSaveInstanceState meine Daten in das Bundle geschrieben wurden, beim Fortsetzen der App im onCreate aber immer NULL als savedInstanceState bereitstand, was dafür sorgte, dass sich die Benutzeroberfläche immer zurücksetzte auf den Initialzustand.

Nach einiger Suche kam ich dann auf des Problems Lösung: Ich hatte in der Manifest-Datei der Activity das Flag noHistory="true" gesetzt. Laut Dokumentation hat dies folgenden Effekt:
Whether or not the activity should be removed from the activity stack and finished [...] when the user navigates away from it and it's no longer visible on screen.


A value of "true" means that the activity will not leave a historical trace. It will not remain in the activity stack for the task, so the user will not be able to return to it.
Mein Verständnis dieses Flags war, dass dadurch die Activity nicht auf dem Backstack landet. Das funktioniert auch. Allerdings meint "the user will not be able to return to it" auch, dass sämtliche Informationen im Bundle verworfen werden und jedes Resume wie ein Neustart der Activity ist.

Holger Sirtl: Neuerungen in Microsoft Azure: DocumentDB (Preview), Azure Search (Preview), HBase für HDInsight (GA)

Microsoft hat heute einige Neuerungen für die Microsoft Azure Plattform veröffentlicht:

  • Preview des Document-Database-as-a-Service Dienstes DocumentDB
  • Preview des Suchdienstes Azure Search
  • Allgemeine Verfügbarkeit (GA) von Apache HBase für HDInsight

DocumentDB (Preview)

NoSQL Technologien haben sich zur Datenspeicherung in der Cloud fest etabliert. Sie versprechen hohe Skalierbarkeit und flexible Datenspeicherung. Vielen der verfügbaren NoSQL-Angebote fehlen jedoch leistungsfähige Abfragemechanismen und transaktionales Verhalten. Diese Lücke schließt DocumentDB. DocumentDB ist ein Document-Database-as-a-Service Dienst der die Vorteile einer NoSQL Documentendatenbank mit den erweiterten Abfragemechanismen und Transaktionssemantik einer relationalen Datenbank vereint.

Azure DocumentDB unterstützt JSON Dokumente, die nach ihren Propertys durchsucht werden können. Dazu werden Programmierbibliotheken für verschiedene Sprachen und Plattformen – darunter .NET, Node.js, JavaScript und Python – bereitgestellt. Stored Procedures können in JavaScript erstellt werden.

Weitere Informationen zu DocumentDB: Getting started with DocumentDB.

Azure Search (Preview)

Eine Suchfunktion wird praktisch in jeder Webseite benötigt. Der Aufbau einer Such-Infrastruktur kann jedoch sehr aufwändig sein. Es reicht nicht einen öffentlichen Such-Dienst zu nutzen, der in der Regel nur eine gewichtete Volltextsuche bieten kann. Azure Search ist ein vollautomatisch verwalteter Search-as-a-Service Dienst, mit dem Suche in eigene Weseiten integriert werden kann. Dabei können eigene Ranking Profile verwendet werden um Suchergebnisse in Richtung der Geschäftsziele hin zu beeinflussen (z.B. Höherbewertung von Produkten, die eine höhere Marge aufweisen). Azure Search ist hoch-skalierbar und kann auf Lastspitzen reagieren.

Weitere Informationen zu Azure Search: Configure Search in the Azure Preview Portal.

HBase für HDInsight (GA)

In Zusammenarbeit mit Hortonworks wurde mit deren Hilfe bereits die Hadoop-Plattform in Form des HDInsight-Service auf Azure verfügbar gemacht. In diesem Kontext wurde jetzt HBase als Managed Cluster innerhalb von HDInsight verfügbar gemacht. HBase Cluster speichern ihre Daten dabei in Blob Storage.

Weitere Informationen zu HBase für HDInsight: Get started using HBase with Hadoop in HDInsight.

Weitere Informationen

Holger Sirtl: Serie: Eigene Anwendungen auf Microsoft Azure - Teil 2: Virtual Machines

Microsoft Azure bietet zur Ausführung eigener Anwendungen in der Public Cloud vier Optionen: Virtual Machines, Cloud Services, Websites und Mobile Services. Diese Blog-Serie gibt Hinweise zur Entscheidung für die zu einem konkreten Vorhaben beste Alternative, Die Serie ist unterteilt in 7 Teile:

Dieser Teil geht auf Virtual Machines ein. Virtual Machines sind die Ausführungsoption, die wohl die meisten Personen vor Augen haben, die über die Ausführung Ihrer Anwendung in der Cloud nachdenken. Sie stellen das Infrastructure-as-a-Service-Angebot (IaaS) auf Microsoft Azure dar.

Virtual Machines erlauben den Betrieb selbst erstellter oder von Microsoft bereitgestellter virtueller Maschinen auf Microsoft Azure. Diese werden minutengenau abgerechnet. Zur Bereitstellung einer Virtual Machine ist letztlich nur die Festlegung eines VM-Image (hier werden Standard-Hyper-V-Images eingesetzt), auf deren Basis der Bootvorgang ablaufen soll, sowie ein paar wenige Konfigurationsparameter erforderlich:

  • VM-Größe
  • Administrator-Kennung
  • DNS-Name
  • Azure Subscription
  • Die Region des Rechenzentrums, in dem die VM ausgeführt werden soll

Auf die dann in Azure ausgeführten Virtual Machines haben Nutzer vollen Adminstrator-Zugang. Sie können sich z.B. per Remote Desktop auf eine VM einwählen und die Maschine ihren Wünschen entsprechend konfigurieren. Die in den virtuellen Maschinen eingesetzten Festplattenlaufwerke werden im Blob Storage persistiert. Virtual Machines eignen sich deshalb ideal für eine schnelle Migration einer bestehenden On-premise-Anwendung in die Cloud. Prinzipiell können die VMs der lokalen Umgebung in die Cloud übertragen oder quasi 1:1 in der Cloud nachgebaut werden.

Durch die Persistierung der VM-Disks im Blob Storage bleiben – im Gegensatz zu den nicht-persistenten Images der Cloud Services – alle Inhalte erhalten, sollte eine virtuelle Maschine einem Re-Image unterzogen werden (z.B. bei Hardware-Ausfall). Für die Inhalte gelten die gleichen Regeln für Failover (3-fach-Speicherung aller Inhalte, optionale Geo-Replikation in ein entferntes Rechenzentrum) wie für alle anderen Inhalte des Blob Storage. Da von Microsoft Azure Standard-VHDs genutzt werden, können sowohl bestehende VMs aus einer lokalen Hyper-V-Umgebung in die Cloud migriert und als Virtual Machine ausgeführt, als auch der umgekehrte Weg beschritten werden: VHDs können aus Microsoft Azure heruntergeladen und in einer entsprechenden Hyper-V-Umgebung lokal ausgeführt werden.

Als Gast-Betriebssysteme für Virtual Machines werden sowohl verschiedene Windows Server Varianten als auch ausgewählte Linux-Distributionen unterstützt. Ebenfalls unterstützt werden einige Serveranwendungen wie SQL Server, SharePoint Server, BizTalk Server und Active Directory. Durch Kooperation mit Oracle werden auch Anwendungen aus dem Oracle-Technologieportfolio (WebLogic, Java, Oracle DB, …) unterstützt. Es ist möglich, neue Images in einer lokalen Hyper-V-Umgebung zu erzeugen, nach Windwos Azure zu laden und von den Images neue Virtual Machines zu booten. Daneben können auch bereits vorgefertigte mit entsprechender Serversoftware bestückte Images aus einer Gallery (siehe Abb 1) ausgewählt und gestartet werden.


Abb 1: Virtual Machine Gallery

Damit ist es möglich, wichtige Teile der Serverumgebungen eines eigenen Rechenzentrums ohne Änderung nach Microsoft Azure zu migrieren. Die minutengenaue Abrechnung macht dieses Ausführungsmodell auch für die Bereitstellung von Test- oder Demo-Umgebungen interessant, wo Infrastruktur nur temporär benötigt wird.
Wie die anderen Ausführungsmodelle können auch Virtual Machines in Kombination mit anderen Azure Services genutzt werden. So kann eine in einer VM ausgeführte Anwendung beispielsweise problemlos Microsoft Azure Storage oder SQL Database nutzen. Besonders interessant ist die Kombination mit dem Virtual Network: Durch die Möglichkeit ein lokale und Cloud-basierte VMs umspannendes virtuelles Netzwerk mit gemeinsamen Ipv4-Adressraum und entsprechenden Routing Tabellen einzurichten, können virtuelle Maschinen flexibel zwischen der Cloud und einem lokalen Rechenzentrum hin- und hergeschoben werden ohne dass dies aus Netzwerksicht Auswirkungen auf die anderen VMs hat.

Die hohe Flexibilität der Virtual Machines kommt allerdings zu dem Preis, dass ein signifikanter Teil der Infrastruktur im Verantwortungsbereich des Nutzers verbleibt, d.h. er muss sich um das Setup und die Wartung der VM-Images kümmern (Patches und Upgrades einspielen).

Gründe für die Wahl von Virtual Machines als Ausführungsumgebung können deshalb sein:

  • Linux wird als Gast-OS für die eigene Anwendung benötigt
  • Es werden administrativer Zugriff und entsprechende Konfigurationsmöglichkeiten benötigt

Gründe für die Wahl einer der anderen Ausführungsoptionen (Cloud Services, Websites oder Mobile Services)  können entsprechend sein:

  • Das Management der Infrastruktur soll vollständig von Azure übernommen werden.
  • Maßnahmen für Failover und High-Availability sollen von Azure automatisiert durchgeführt werden.


Die Microsoft Azure Dokumentation enthält einen tabellarischen Überblick über die Möglichkeiten der einzelnen Ausführungsoptionen. Als Fazit kann gezogen werden:

  • Virtual Machines sollten nur dann verwendet werden, wenn es entscheidende Gründe hierfür gibt (es wird ein Feature benötigt, das nur Virtual Machines bieten, z.B. Linux als Gast-OS)
  • Wann immer möglich, sollten die anderen Ausführungsoptionen validiert und ggf. verwendet werden. Sie bieten deutliche (Kosten-)Vorteile im automatisierten Management der Umgebung.

Weitere Informationen

Informationen zu Virtual Machines

Informationen zur allgemeinen Entscheidung für ein Ausführungsmodell

Jürgen Gutsch: Playing around with SignalR 2.1.1 - Teil 2: Die Clientseite

Im ersten Teil habe ich die Serverseite beschrieben. Diesmal geht es um die wesentlich interessantere Clientseite.

Vorbereitung – Das Formular

Als erste habe ich zwei einfache Formulare definiert. Das erste ist ein einfaches An- und Abmeldeformular, das lediglich einen Benutzername erwartet. Neben einer Textbox, beinhaltet das Formular je einen Button zum Anmelden und eines zum Abmelden vom Chat. Wie man sieht nutze ich die vorhanden CSS-Klassen aus Twitter Bootstrap und muss mich nicht groß um das Layout kümmern:

<form class="form-horizontal">
    <fieldset id="loginwindow">

        <div class="form-group">
            <label for="name"
                   class="col-sm-2 control-label">
                User name:
            <div class="col-sm-10">
                <input type="text"
                       placeholder="User name">
        <div class="form-group">
            <div class="col-sm-offset-2 col-sm-10">
                <button type="button"
                        class="btn btn-default pull-right"
                <button type="button"
                        class="btn btn-primary pull-right">

Das zweite Formular ist das eigentliche Chatfenster. Den Chat gebe ich der Einfachheit halber in einer Textarea aus. Darunter befinden sich eine Textbox zur Eingabe der Chat-Nachrichten und daneben ein Button zum Versenden der Nachricht. Die beiden Formulare sitzen direkt untereinander Optisch durch das Fieldset getrennt:

<form class="form-horizontal">
    <fieldset id="chatwindow"

        <div class="form-group">
            <div class="col-sm-offset-2 col-sm-10">
                </textarea class="form-control"
                          style="height: 300px;"

        <div class="form-group">
            <label for="name"
                   class="col-sm-2 control-label">
                Your message:
            <div class="col-sm-10">
                <input type="text"
                       placeholder="Your message">
        <div class="form-group">
            <div class="col-sm-offset-2 col-sm-10">
                <button type="button"
                        class="btn btn-primary pull-right">

Auf zum Coden – Das JavaScript

Das war es auch schon auf der HTML-Seite. Schauen wir uns nun mal das JavaScript an. Das erste was getan werden sollte ist, den benötigten Hub zu holen:

var chatter = $.connection.chatter;

Die “connection” wird über die Bibliothel jQuery.signalR bereitgestellt und stellt den Zugriff auf den jeweiligen Hub bereit. Wir erinnern uns an das Attribut über unserem Hub aus dem ersten Teil. Über diesen Namen greifen wir nun darauf zu. Weiter unten sehen wir mehr davon.

Vorerst benötigen wir drei Methoden die unsere Formulare steuern.

Die erste Methode “addMessage” erstellt die komplette Chat-Nachricht, inklusive des Clientseitigen Zeitstempels (Was bringt dem User die Serverzeit? Die Nachrichten werden in diesem Beispiel eh nicht auf dem Server gespeichert, sondern nur durchgeleitet ;) ) Ist die Nachricht komplett, wird sie an den Inhalt der Textarea angehängt:

var addMessage = function (message) {
    var currentdate = new Date();
    var messate = currentdate.getHours() + ":" + currentdate.getMinutes()
    messate += ' ' + message + '\n';

var enableChat = function () {
    $('#chatwindow').prop("disabled", false);
    $('#name').prop("disabled", true);
    $('#signin').prop("disabled", true);
    $('#signout').prop("disabled", false);

var disableChat = function () {
    $('#chatwindow').prop("disabled", true);
    $('#name').prop("disabled", false);
    $('#signin').prop("disabled", false);
    $('#signout').prop("disabled", true);

Die beiden Methoden “enableChat” und “disableChat” werden aufgerufen, wenn die Anmeldung oder die Abmeldung erfolgreich war und steuern welcher Teil der UI aktiv oder inaktiv ist.

Als nächsten Schritt habe ich, wie auch im Sample, eine “init” Methode geschrieben, mit der die Buttons der Formulare mit Aktionen versehen werden. Hier passiert auch der Aufruf der Serverseitigen Methoden:

var init = function () {

    $('#signin').click(function () {
        var name = $('#name').val();
        if (name.length < 4) {
            alert('username is not valid!');

            .signIn($.connection.hub.id, name);

    $('#signout').click(function () {
        var name = $('#name').val();

            .signOut($.connection.hub.id, name);

    $('#messagesend').click(function () {
        var message = $('#message').val();
        if (message.length < 1) {
            alert('message is not valid!');

            .post($.connection.hub.id, message);

Die Validierung die wir hier sehen, ist nicht wirklich gut, reicht aber für dieses Beispiel voll aus ;)

Über “chatter.server” haben wir nun Zugriff auf die serverseitigen Methoden. In jedem Fall übergeben wir hier die ConnectionId, die sich unter $.connection.hub.id versteckt. Wie auch für die Anmeldung, wird auch bei der Abmeldung der Name übergeben, damit wir eine schöne Begrüßung oder einen Abschiedsnachricht erzeugen können.

Schaut euch im ersten Teil die zugehörigen Server-Methoden an um den Datenfluss nachvollziehen zu können.

“chatter.server.post” schickt nun die eigentliche Chat-Nachricht an den Server, der sie daraufhin an alle Clients sendet.

Wie aber empfängt der Client nun die Nachrichten? Wir Erinnern uns an den serverseitigen Aufruf aus dem ersten Teil:

Clients.All.postMessage(user + "> " + message);

Wir müssen auf der Clientseite – unter anderem – die Methode “postMessage” erstellen und dem clientseitigen “chatter”-Objekt bekannt geben:

$.extend(chatter.client, {
    userAdded: function () {
    postMessage: function (message) {
    userRemoved: function () {

Wir erzeugen einen “client”-Namespace und fügen die benötigten Methoden ein, die dann wiederum auf die vorhandenen Methoden zugreifen.

That’s it :)

Ich kann nun den Chat laufen lassen und mit zwei verschiedenen Browser testen:

Manfred Steyer: Soft-Delete mit Entity Framework 6.1

Seit Entity Framework 6.1 können Entwickler mit CommandTreeInterceptoren SQL-Anweisungen abfangen und abändern. Im Gegensatz zu den CommandInterceptoren, die bereits mit 6.0 zur Verfügung standen, stellen CommandTreeInterceptoren die SQL-Anweisung nicht in Form eines Strings sondern in Form eines Syntax-Baumes dar. Dies vereinfacht das Abändern der Anweisung. Auf diese Weise lassen sich globale Filter definieren. Ein solcher globaler Filter könnte zum Beispiel festlegen, dass nur Datensätze mit einem bestimmten Status oder nur Datensätze eines bestimmten Mandanten geladen werden. Dazu müsste der Interceptor jeder Abfrage um eine entsprechende Einschränkung erweitern.

Auf der Teched 2014 hat Entity-Framework-Programm-Manager Rowan Miller ein Beispiel präsentiert, in dem er einen CommandTreeInterceptor zur Implementierung von Soft-Deletes nutzt. Hierunter versteht man Fälle, in denen Anwendungen obsolete Datensätze nicht tatsächlich löschen, sondern nur als gelöscht markieren. Den Quellcode dieses Beispiels findet man unter [1]. Da es sich bei Soft-Deletes um eine häufig anzutreffendes Muster im Bereich der Datenbankprogrammierung handelt und Entity Framework hierfür keine Boardmittel bietet, demonstriert dieser Beitrag den Einsatz von CommandTreeInterceptoren anhand von Auszügen dieses Beispiels.

Um den Einsatz von Soft Delete für ausgewählte Entitäten zu aktivieren, sieht das besprochene Beispiel ein Attribut SoftDeleteAttribute vor (siehe nachfolgendes Listing). Damit werden die jeweiligen Entitäten annotiert. Über die Eigenschaft ColumnName gibt der Entwickler den Namen der Spalte, welche Auskunft darüber gibt, ob der Datensatz als gelöscht gilt, an. Standardmäßig wird hierfür der Name IsDeleted angenommen.

Die statische Hilfsmethode GetColumnName nimmt einen EdmType, welcher im Entity Data Model eine Entität repräsentiert, entgegen und liefert den zuvor erwähnten Spaltennamen für diese Entität retour. Sie geht davon aus, dass diese Information unter dem Schlüssel customannotation:SoftDeleteColumnName in den im Model für diesen Typ hinterlegten Metadaten zu finden ist. Damit dies auch der Fall ist, konfiguriert der Entwickler für den verwendeten DbContext innerhalb der Methode OnModelCreating die Konvention AttributeToTableAnnotationConvention:

var conv = 
   new AttributeToTableAnnotationConvention(
        (type, attributes) => attributes.Single().ColumnName);


Mit dieser Konvention legt der Entwickler fest, dass Entity Framework die Eigenschaft ColumnName des Attributes SoftDeleteAttribute in die Metadaten der Entität aufnehmen soll. Als Schlüssel gibt er hierfür SoftDeleteColumnName an; der zuvor betrachtete Präfix customannotation wird von dieser Konvention standardmäßig vergeben.

public class SoftDeleteAttribute: Attribute
    public SoftDeleteAttribute()
        ColumnName = "IsDeleted";

    public string ColumnName { get; set; }

    public static string GetColumnName(EdmType type)
        var prop = type
                    .Where(p => 

        string columnName = (prop != null) ? (string) prop.Value : null;

        return columnName;

Richtig spannend wird das betrachtete Beispiel, wenn der CommandTreeInterceptor ins Spiel kommt. Diesen findet man im nachfolgenden Listing. Er bietet eine Methode TreeCreated an. Diese führt Entity Framework aus, nachdem es den Syntax-Baum für eine SQL-Anweisung erstellt hat. Die betrachtete Implementierung prüft zunächst, ob TreeCreated für das Store Model ausgeführt wird und somit einen Syntax Baum, aus dem später direkt SQL abgeleitet wird, beinhaltet. Ist dem nicht so, wird die Methode abgebrochen.

Anschließend greift sie auf die Eigenschaft Result des von Entity Framework übergebenen Kontextes zu. Diese Eigenschaft beinhaltet den Syntax-Baum und ist vom abstrakten Typ DbCommandTree. Die hier tatsächlich verwendete Subklasse gibt Auskunft über die Art der zugrunde liegenden SQL-Anweisung. Handelt es sich um ein SELECT kommt die konkrete Subklasse DbQueryCommandTree zum Einsatz. Für den Aufruf einer Stored Procedure oder Stored Function verwendet Entity Framework hingegen das Derivat DbFunctionCommandTree und für DML-Anweisungen (INSERT, UPDATE, DELETE) die abstrakte Klasse DbModificationCommandTree, von der die konkreten Klassen DbInsertCommandTree, DbUpdateCommandTree und DbDeleteCommandTree ableiten. Die Namen sind dabei Programm.

Da das hier behandelte Beispiel jedes SELECT erweitern muss, sodass nur Datensätze, die nicht als gelöscht markiert wurden, geladen werden, prüft es, ob es sich beim Baum um einen DbQueryCommandTree handelt. Ist dem so, wendet es auf den Baum einen SoftDeleteQueryVisitor an, indem sie ihn an dessen Methode Accept übergibt. Dies geht konform mit dem für solche Aufgaben häufig eingesetzten Entwurfs-Muster Visitor (Besucher). Implementierungen dieses Musters durchlaufen die Knoten eines Baums und übergeben diese an eine Komponente, welche als Visitor bezeichnet wird. Der Visitor besucht demnach die einzelnen Knoten. Dieser Visitor kann nun entscheiden, ob er die Daten des erhaltenen Knotens auswertet bzw. den Knoten abändert. Im betrachteten Fall kümmert sich der verwendete Visitor, welcher weiter unten genauer beschrieben wird, um das Hinzufügen der besprochenen Einschränkung.

Das Ergebnis von Accept verpackt die betrachtete Implementierung in einem neuen DbQueryCommandTree. Diesen hinterlegt es in der Eigenschaft Result des Kontextes, was zur Folge hat, dass Entity Framework damit und nicht mit dem ursprünglichen Baum vorliebnimmt.

Die unter [1] zu findende Implementierung prüft auch, ob der an TreeCreated übergebene Syntax-Baum einem DELETE entspricht. In diesem Fall formt es dieses zu einem UPDATE, welches den Datensatz als gelöscht markiert, um.

class CustomCommandTreeInterceptor : IDbCommandTreeInterceptor
    public void TreeCreated(
            DbCommandTreeInterceptionContext interceptionContext)
        if (interceptionContext.OriginalResult.DataSpace 
                                          != DataSpace.SSpace) return;

        var tree = interceptionContext.Result as DbQueryCommandTree;

        if (tree != null)
            var newQuery = tree.Query.Accept(new SoftDeleteQueryVisitor());

            interceptionContext.Result = new DbQueryCommandTree(

        var deleteCommand = interceptionContext.OriginalResult 
                                                    as DbDeleteCommandTree;
        if (deleteCommand != null)
            var column = SoftDeleteAttribute.GetColumnName(
            if (column != null)

                var setClause =

                var update = new DbUpdateCommandTree(
                    new List { setClause }.AsReadOnly(),

                interceptionContext.Result = update;


Die Umsetzung des SoftDeleteQueryVisitors findet sich im nachfolgenden Listing. Sie leitet von der Klasse DefaultExpressionVisitor, welche Entity Framework als Basis-Klasse für Visitor-Implementierungen anbietet, ab und überschreibt die Methode Visit. Da es von Visit zahlreiche Überladungen gibt, ist zu betonen, dass es sich hier um jene Überladung von Visit, welche eine DbScanExpression entgegennimmt, handelt. Diese Methode ruft Entity Framework immer dann auf, wenn der jeweils besuchte Knoten das Abfragen von Daten einer Entität repräsentiert.

Die Methode Visit ermittelt mit der zuvor besprochenen Methode GetColumnName die für die betroffene Entität hinterlegte Spalte. Ist dieser Wert null, geht Visit davon aus, dass für die betrachtete Entität keine Soft-Deletes zum Einsatz kommen sollen und delegiert lediglich an die geerbte Basis-Implementierung. Ansonsten erweitert Visit die DbScanExpression um einen Filter, aus dem hervor geht, dass nur Datensätze bei denen die festgelegte Spalte den Wert true hat, zu laden und liefert sie retour.

public class SoftDeleteQueryVisitor : DefaultExpressionVisitor
    public override DbExpression Visit(DbScanExpression expression)
        var columnName = 

        if (columnName != null)
            var binding = DbExpressionBuilder.Bind(expression);

            return DbExpressionBuilder.Filter(
                                binding.VariableType, binding.VariableName),
            return base.Visit(expression);

Die hinter diesem Beispiel stehende Idee wurde mittlerweile auch von der Community aufgegriffen. Unter [2] findet man beispielsweise ein Projekt, welches das Definieren von globalen Filtern für Entity Framework erlaubt. Es verbirgt die Komplexität der benötigten Interceptoren und Visitatoren vor dem Entwickler, indem er die Möglichkeit bekommt, Filter mit ein paar Zeilen Code zu hinterlegen.

[1] https://github.com/rowanmiller/Demo-TechEd2014

[2] https://github.com/jbogard/EntityFramework.Filters

Fabian Deitelhoff: AntMe! v2: die Ameisen krabbeln wieder

AntMe! Version 2 steht vor der Tür!AntMe! ist ein sehr cooles Stück Software. Es macht einen riesigen Spaß, seine Ameisen zu Programmieren und mit verschiedenen Strategien zu versuchen eine bestimmte Aufgabe auf die beste Art und Weise zu lösen. Entweder vor den bösen Wanzen flüchten oder sie direkt bekämpfen. Und Ressourcen, wie beispielsweise Zucker, wollen auch noch gesammelt werden.

Nach einigen Jahren steht nun AntMe! Version 2 vor der Tür. Allerdings nicht mehr als Nebenbei-Projekt, das immerhin schon seit 2006 besteht, sondern das Team möchte höher hinaus. Dass kann ich sehr gut nachvollziehen, denn das Spiel hat enormes Potenzial.

Die Kampagne

Damit die Version 2 entstehen und das Projekt so wachsen kann wie geplant, ist natürlich Geld notwendig. Zu diesem Zweck gibt es eine Indiegogo-Kampagne, die mit der Crowd zusammen versucht, Geld einzusammeln. Darum geht es auch in diesem Blogpost. Ich möchte auf das wirklich sehr coole Projekt AntMe! und auf die begleitende Kampagne aufmerksam machen. Etwas zu AntMe! und zur Kampagne kann euch am besten Tom Wendel in dem Video auf Indiegogo erklären.

Ich denke, dass macht neugierig :). Unterstützt habe ich das Projekt, weil ich mich freuen würde, wenn die zweite Version noch besser wird als die erste und natürlich auch, weil ich der Meinung bin, dass das Business-Modell eine gute Idee ist und eine Chance verdient hat.

Zum anderen bin ich auch der Meinung, dass Kinder damit hervorragend lernen können, was es heißt zu programmieren und wie sie sich selbst so einem Themenfeld nähern können. Bei meinen VHS-Kursen zum Thema LEGO Mindstorms EV3 merke ich immer wieder, wie schnell Kinder dabei sind, wenn es Spaß macht und wenn es ein Ziel vor Augen gibt. Und eben ein anderes Ziel, als “Hello World” auf dem Bildschirm auszugeben.


Da bleibt mir gar nicht viel zu sagen. Cooles Projekt, cooles Team und sehr gute Kampagne. Ich freue mich, meinen Beitrag in Form von ein paar Euros beisteuern zu können, auf dass die nächste Version von AntMe! enstehen kann.

Wenn auch ihr das Projekt unterstützen möchtet, stattet doch einfach der Indiegogo-Kampagne einen Besuch ab.

Jürgen Gutsch: NHibernate 4.0 ist fertig

Es tut sich wieder etwas bei NHibernate :)

Wie Ayende Rahien eben veröffentlicht hat, ist NHibernate 4.0 released und steht auf SourceForge oder per NuGet zum Download bereit.

Die aktuellen Release Notes, sowie die Sourcen findet ihr auf GitHib: https://github.com/nhibernate/nhibernate-core

Somit haben wir noch etwas dass ich mir in der nächsten Zeit genauer anschauen werde :)

ppedv Team Blog: Entity Framework-Datenmodell per Code erstellen

Was kam zuerst? Die relationale Datenbank, das objektorientierte Klassenmodell oder der ORM Mapper?

Die ältere Fraktion, zu der ich zumindest in Zeiteinheiten gehöre, findet sich in RDMBS, Normalisierung und Indizes wieder. Newcomer sehen alles dynamisch, freuen sich über JSON und stecken alles in NoSQL.

Die folgende Schritt-für-Schritt-Anleitung zeigt den sogenannten Code First-Ansatz. Damit legt man die Verantwortung für das Datenbank-Modell in die Hände von Programmierern. Mit Entity Framework und Migrations erstellt sich dann die Datenbank quasi automatisch.

Eigentlich ist es völlig egal, welcher Projekttyp oder Sprache in Visual Studio 2013 gewählt wird. Hier setzen wir ein Webforms VB.NET Projekt ein.

Wer Code First betreibt, sollte sich zuerst mit den Konventionen vertraut machen. Identity-Felder werden mit ID benannt. Am besten nutzen wir den Typ Integer. Foreign Keys erhalten den Tabellennamen und den Zusatz ID als Feldnamen. Mit Attributen nimmt man auf die späteren Feld-Definitionen im SQL Server Einfluss.

Am besten legt man die Klassen in das Model Verzeichnis. Die 1:1 Relation wird über die Eigenschaft in Zeile 22 erstellt. Für 1:n benötigen wir eine List of Property.

   1:  Imports System.ComponentModel.DataAnnotations
   3:  Public Class room
   4:      <Key>
   5:      Public Property roomId As Integer
   6:      <MaxLength(50)>
   7:      Public Property roomname As String
   8:      Public Property datum As DateTime
   9:      Public Property isclosed As Boolean
  10:  End Class
  13:  Public Class chatmessage
  14:      <Key>
  15:      Public Property Id As Integer
  16:      <MaxLength(128)>
  17:      Public Property userId As String
  18:      Public Property roomId As Integer
  19:      Public Property Message As String
  20:      Public Property datum As DateTime
  22:      Public Overridable Property room As room
  23:  End Class


Zusätzlich benötigen wir mit EF 6 eine vom DBContext abgeleitete Klasse, die wiederum auf die Klassen room und Chatmessage verweist.

   1:  Imports System.Data.Entity
   3:  Public Class modellContext
   4:      Inherits DbContext
   6:      Public Sub New()
   7:          MyBase.New("name=modellContext")
   8:      End Sub
  10:      Public Property chatmessage As System.Data.Entity.DbSet(Of chatmessage)
  11:      Public Property room As System.Data.Entity.DbSet(Of room)
  13:  End Class

Als nächstes führen wir in der Visual Studio Nuget Paket Manager Console enable-Migrations mit dem Context aus.


Eine weitere Convention behandelt die Namensgebung des Connection String. Wir müssen diesen in der Web.config ident zur Klasse benennen.

   1:   <connectionStrings>
   2:       <add name="modellContext" 
   3:           connectionString="Data Source=(LocalDb)\v11.0;
   4:  AttachDbFilename=|DataDirectory|\modell1.mdf;Initial Catalog=modell1;
   5:  Integrated Security=True"
   6:        providerName="System.Data.SqlClient" />
   7:    </connectionStrings>


Jede Modellklasse fügen wir per add-Migration-Befehl dem Modell hinzu. Die Änderungen in der Datenbank lösen wir per update-Database aus.


Ist die Datenbank nicht vorhanden, legen wir sie an.


In LINQ Statements selektieren wir deshalb über Relationen hinweg aus den Daten.

   1:  Dim db As New modellContext
   2:  Dim r = db.chatmessage.Where(Function(c) c.room.roomname = "raum1")

Änderungen in der Klasse verteilen wir per add-migration und update Database in der Datenbank. So verlieren wir die Daten nicht. Dazu werden automatisch Migrationsklassen erzeugt, die eine Up und Down-Methode enthalten.


Damit gleichen wir auf jedem beliebigen Server jederzeit den Status des SQL Servers ab.

Auf diese Art können Sie Optimierungen der Datenbank ignorieren. Ob Sie einen Datenbank-Admin, der die entsprechende SQL Performance-Optimierung beherrscht, beauftragen oder einen EF-Spezialisten, hängt von vielen Faktoren ab. In jedem Fall bieten wir die passenden Schulungen dafür:



Holger Sirtl: Serie: Eigene Anwendungen auf Microsoft Azure - Teil 1: Überblick

Die meisten Personen, die sich für das Thema Cloud Computing interessieren, haben zunächst ein Szenario im Blick: die Ausführung einer eigenen Anwendung in der Cloud. Ob nun eine bestehende oder eine neu zu entwickelnde Anwendung: in beiden Fällen kommt man recht schnell an den Punkt an dem auffällt, dass es hierzu in Microsoft Azure – anders als bei einem klassischen Hoster oder vielen anderen Cloud-Anbietern – mehrere Optionen gibt. Microsoft Azure bietet nicht nur das Hosting klassischer virtueller Maschinen im Sinne eines Infrastructure-as-a-Service-Ansatzes, sondern auch speziellere Hosting Varianten, die optimiert sind auf die schnelle Bereitstellung von Web-Anwendungen oder die flexible Skalierung mehrschichtiger Anwendungen. Diese Blog-Serie beschäftigt sich nun mit der Auswahl der für ein bestimmtes Szenario bestgeeigneten Ausführungsmodells. Sie ist unterteilt in

  • Teil 1: Überblick über die Ausführungsoptionen
  • Teil 2: Virtual Machines
  • Teil 3: Cloud Services
  • Teil 4: Websites
  • Teil 5: Mobile Services
  • Teil 6: Auswahl des besten Ausführungsmodells
  • Teil 7: Wechsel des Ausführungsmodells

Folgende Optionen stehen für die Ausführung eigener Anwendungen auf Microsoft Azure zur Verfügung:

Dies klingt zunächst verwirrend, letztlich lässt sich die Frage nach der besten Alternative aber recht schnell beantworten. Hinzu kommt die Möglichkeit, diese Optionen miteinander zu kombinieren. D.h. es ist durchaus möglich, dass Teile einer Anwendung als Website betrieben werden und andere Teile (z.B. die Datenbank) nutzen, die in einer Virtual Machine ausgeführt werden. Darüber hinaus ist ein Wechsel zwischen den Optionen möglich, d.h. man verbaut sich nichts, wenn man mit einer Option (z.B. Websites) beginnt und später auf eine andere Option (z.B. Cloud Services) wechselt.

Die vier Alternativen unterscheiden sich primär dadurch, wie viele Aspekte der Umgebung durch das Ausführungsmodell vorgegeben und damit von Azure automatisiert verwaltet werden (Einspielen von Patches, Updates, Failover-Management etc.) und welche Aspekte durch den Nutzer bestimmt werden können. Je mehr Aspekte bestimmt werden können, desto weniger Aspekte werden von Azure verwaltet. Umgekehrt gilt entsprechend: je mehr von Azure automatisiert verwaltet wird, desto weniger Einfluss auf die Umgebung ist durch den Nutzer möglich. Höchste Automatisierung (dafür geringste Möglichkeiten, die Umgebung zu kontrollieren) bieten Mobile Services. Bei Virtual Machines ist auf der anderen Seite die Möglichkeit, Einfluss auf die Umgebung zu nehmen, am größten, dafür ist der Automatisierungsgrad am kleinsten. Die beiden anderen Alternativen, Cloud Services und Websites, liegen dazwischen. Folgende Tabelle gibt einen Überblick auf die Alternativen und deren Automatisierungsgrad bzw. die Möglichkeiten, Einfluss auf die Umgebung zu nehmen.

  Virtual Machines Cloud
Websites Mobile
Automatisierungsgrad ●● ●●● ●●●●
Einflussmöglichkeiten ●●●● ●●● ●●

Die Tabelle gibt schon den wichtigsten Hinweis: wann immer möglich, sollten Anwendungen als Mobile Service bzw. Websites ausgeführt werden. Dort ist der Automatisierungsgrad und damit die Einsparungen im Vergleich zu einem Eigenbetrieb oder dem Betrieb in einer virtuellen Maschine am höchsten. Nur wenn die Anforderungen bestimmte Konfigurationen der Umgebung erfordern, d.h. die Umgebung stark angepasst werden muss, sollten Virtual Machines zum Einsatz kommen.

Für einige Szenarien können recht einfach erste Empfehlungen für die Ausführungsoption genannt werden:

Szenario Naheliegende
Hosting einer ASP.NET- oder PHP-basierten Webseite Websites Websites bieten den höchsten Grad an Automatisierung, und die bereitgestellte Umgebung eignet sich sehr gut zur Ausführung von skalierbaren Web-Anwendungen.
Betrieb einer bestehenden Linux-basierten LOB-App Virtual Machines Virtual Machines bieten als einzige Ausführungsoption den Betrieb einer Linux-basierten Umgebung. Diese kann dann individuell konfiguriert werden. Der Nutzer kann sich hierzu als Admin anmelden.
Bereitstellung eines REST-Backends für mobile Anwendungen Mobile Services Mit Mobile Services lassen sich in kürzester Zeit Backends für mobile Anwendungen bereitstellen. Die Dienste können dabei leicht mit Funktionen zur Benutzerauthentifizierung, Push Notifications, Datenspeicherung versehen werden.
Cloud-Anwendung, die auf Ressourcen im lokalen Unternehmensnetzwerk zugreifen soll Cloud Services oder
Virtual Machines
Cloud Services und Virtual Machines bieten die Möglichkeit, über ein virtuelles Netzwerk Verbindungen zu einem lokalen Rechenzentrum herzustellen.

Diese Tabelle gibt nur einen ersten Hinweis auf eine geeignete Alternative. Vor einer konkreten Umsetzung sollte diese noch genauer betrachtet werden. In den weiteren Teilen dieser Blog-Serie sollen die einzelnen Alternativen deshalb genauer vorgestellt werden.

Weitere Informationen

codefest.at [MS]: Kommende JumpStarts auf der Microsoft Virtual Academy: Universal Apps, Game Development mit Unity

In den nächsten Wochen sind einige interessante JumpStarts auf der Microsoft Virtual Academy zu den Themen Universal Apps und Game Development geplant. Wer die JumpStart Serien der MVA nicht kennt: das sind Kurse, in denen in mehreren Modulen ein Thema sehr ausführlich behandelt wird.

Ich habe bereits ein vergangenes JumpStart zu App-Entwicklung für Windows Phone 8.1 besucht und muss sagen, dass diese Serien wirklich sehr gut sind. Was mir besonders gut am JumpStart gefallen hat, war die Tatsache, dass es nebenher auch einen LiveChat gab, bei dem technische Experten, technische Fragen beantwortet haben.

Zu Universal Apps sind in nächster Zeit folgende zwei JumpStarts geplant:

Zu Game Development folgender JumpStart

Ihr könnt euch natürlich auch generell auf der MVA nach anderen Kursen umschauen. Da gibt es jede Menge interessanten Content.

Dirk Primbs [MS]: Me, me, pick me! – A little guide through the web development maze.

My Master degree slowly comes to its end (2 more modules, then my diss.) and in it’s final tech module I’m literally “Programming the Internet” which is also how the course is called.

All this module is about is software engineering for the web using JavaScript, HTML5 and a number of server side frameworks to complete the picture. In parallel I spent the last 8 months catching up on the open source software world. Coming from the client side Microsoft stack with the one and only all-purpose-development-tool (of course that is Visual Studio) and the one and only all-purpose-development-framework (.NET and some flavor of WinJS), this feels like a kid in the candy store.

Suddenly there is a cornucopia of IDEs, editors and libraries at my disposal and the challenge in the beginning was to simply cut through the maze and to get a grip on the many libraries and understand what they offer…

CoolName.js – solutions and functionalities waiting for problems

Clearly, the cool name seem to be half of the job to establish a new library these days and so I was initially drawn between libraries that practially solved the same problems over and over but complemented or competed each other. I’m still confused sometimes but bit by bit I started to find some orientation, so let me share the feeling with you and provide a little info on some of the libs I looked at. Also let me know in the comments if you think there are tools or libraries that I miss out on. Instead of digging into everything, I’ll follow your suggestions and bet my destiny on crowd wisdom :-)

  • Angular.js - Templates, two-way databinding, MVC in a compact fast library. Angular is pretty cool and powerful (and rooted in the Google tech universe which made it one of my first deeper looks)
  • JQuery – This is the all-purpose powerful JavaScript-DOM handling framework pretty much every web developer needs to know. While there have been numerous attempts to solve similar problems it is clearly JQuery who made the race.
  • Ember.js - This is a templating and extension engine that comes with an enourmous amount of functionality. It is built for large, rich and long living applications such as large admin dashboards etc. Ember is moving quite fast which sometimes renders samples found online quite useless for learning. On of it’s strengths is that it gives your code structure and removes quite a bit of boilerplate code, so once familiar with the API it boosts your productivity.
  • JavaScriptMVC - Not all JavaScript frameworks play nice with each other which becomes especially frustrating if that happens with JQuery. In JavaScriptMVC’s case this is no problem as it is built on top of JQuery and aims to extend its scope with buid system, plugin management, testing and more.
  • Underscore .js - This is a collection of 80-something utility functions in one nifty library without extending the core javascript objects or without forcing any specific development style.
  • Backbone.js - This is one of the first MVC frameworks built for JavaScript. It is relatively light weight and tries to stay out of your way for the most. There is quite a fan base out there with an active community supporting the framework. My impression was that the framework requires more implementation work than other frameworks which may be advantage to some and frustrating to others…
  • Mustache - Templates, templates, templates :-) Pretty much the essential MVC framework to some.
  • Polymer – Ok, this  has not been the first project to bring web components to modern browsers but it surely is one of the cooler ones. Also it is moving fast and is getting more productive every build. Features databinding, components for common functionalities and is ready for material design. Responsive and multi-device support is built in as well.

A special mention here deserves the DART language project. It comes with a full stack of web development functionalities and Angular as well as Polymer can be used from that language. It replaces JavaScript as web development language and offers type safety, compiled code and full object orientation which should make it easy for every .NET, Java or web developer to learn. Additionally it comes with it’s own IDE which places it right in the middle between the just finished section and the now following list of Web IDEs:

One tool to rule them all? Not quite.

I mentioned in the beginning that I came from a world where there was pretty much one editor used for everything. While Visual Studio still is a very powerful tool I found it refreshing to make my way to a number of alternatives and by now I feel quite comfortable with some of them. Here is what I tried:

  • Eclipse – hm… let’s just say Eclipse and me will never be  in love with each other. Too bulky, too slow, too patchy. But I tried and it is installed on my machine. Just barely ever started anymore :-) Little sidenote: Have a look at Android Studio if it is Android Dev that you’re after. I liked it better for App development.
  • WebStorm - JetBrains builds a whole family of IDEs and WebStorm really feels quite nice coming from Visual Studio. Decent code completion, extensions, templates… I liked the IDE. That was my first stop.
  • MonoDevelop - Not really for web development, but keep in mind that I started my journey as a .NET Developer. Hence I had a look at mono and tested what it had to offer. Especially since some attempt to write device apps with it too I gave it a look. Feels nice for a VS developer, but since it is not really webby I drifted away quite quickly.
  • Sublime Text – Then I had a look at the favourite coding tools around me and apparently Sublime has a lot of fans. Thus I downloaded and installed it. Boy, I felt like a hacker right away. Sublime surely manages the art to feel productive while still being “just” an editor. On the other hand I had a bit of a hard time to get a decent installation set up that provided me with all the features that I expected in my productivity environment. Conclusion: Still not my tool but substantially more fun to work with than the other tools just mentioned…
  • Atom - After Sublime I toyed around with anumber of similar looking editors. Atom quickly caught my eye. This is a JavaScript-developed IDE developed by Github. All in all it looks quite similar to Sublime and was fast & fun. What turned me off was the rather limited autocompletion. Also the builds I played with were rather instable.
  • Brackets - Ok, this is my current favourite development tool. It is lightweight, written in JavaScript and is for me simply the most productive web development tool I layed my hands on so far. Features such as in-place editing of external stylesheets, live preview in Browser etc. are just topping it for me but what I really love is the flexibility and overall extensibility. Created by Adobe it also supports many interesting features and workflows like integrating Photoshop for instance…
  • Intel XDK – This toolset equips you with all necessary to build cross-platform HTML5 apps. It includes Brackets, Cordova (cross platform middle ware) and support for libraries such as backbone (see above :-) ) out of the box.
  • IDLE - well, this one is admittedly a but odd in that list as it is not a real web dev IDE. Instead it is the Python IDE coming with the typical python installation and was the only IDE I found providing decent code completion. Meanwhile I extended Brackets and Atom to run Python too but the completion always let me revert back to IDLE. Do you have an alternative suggestion for me?

So… do I have favourites in that list? Yep. Currently I really like the ideas in Dart, Polymer and Angular and the DOM sugar provided by JQuery. My favourite IDE by far is Brackets. You should definitely give it a try too! :-)

Picture source: Flickr

The post Me, me, pick me! – A little guide through the web development maze. appeared first on Dirk Primbs Online.

Jürgen Gutsch: Playing around with SignalR 2.1.1 - Teil 1: Die Serverseite

Ich weiß, das Thema SignalR ist schon etwas älter. Umso wichtiger ist es aus meiner Sicht SignalR endlich mal anzuschauen. Seit meiner Selbständigkeit und auch danach, sind einige sehr interessante Themen liegen geblieben, die ich mir aus Zeitgründen nicht anschauen konnte. Eines dieser Themen ist eben auch SignalR, welches (stand heute) in der Version 2.1.1 unter der Apache 2.0 License für Mono und .NET zur Verfügung steht.

Die offizielle Website ist http://signalr.net/, die Dokumentation auf GitHub zu finden. Viele weitere sehr detaillierte Tutorials, Videos und Samples sind allerdings auf http://www.asp.net/signalr zu finden.

Um was geht’s?

SignalR ist im Prinzip ein Client- UND Serverseitiger Wrapper um das WebSocket-Protokoll mit eingebautem Fallback für Clients die WebSockets nicht unterstützen.

Das WebSocket-Protokoll ist ein auf TCP basierendes Netzwerkprotokoll, das entworfen wurde, um eine bidirektionale Verbindung zwischen einer Webanwendung und einem WebSocket-Server bzw. einem Webserver, der auch WebSockets unterstützt, herzustellen.-Protokoll

WebSockets werden heute von nahezu allen modernen Browsern und Web Servern unterstützt


Ich habe mich entschlossen ein MVC 5 Projekt als Spielwiese zu nutzen und einen kleinen Chat zu realisieren

Das Setup ist kein Hexenwerk. Die nötigen Bibliotheken sind schnell per NuGet eingebunden. Da ich keine Lust hatte erst Dokus zu lesen, habe ich mich entschlossen gleich das Paket mit den SignalR Samples zu installieren:

Install-Package Microsoft.AspNet.SignaR.Sample

Darauf hin habe ich alle nötigen Komponenten im Projekt eingebunden. Eine Readme Datei weist mich darauf hin, dass ich eine Startup Klasse in meinem Projekt hinzufügen muss um SignalR zu initialisieren.

Die Startup-Klasse klingt ganz nach Owin. Was sich dann auch so herausstellt. SignalR wird als Owin-Komponente bereitgestellt. Das ist Klasse. So fängt das an Spaß zu machen :)

Ein letzter Schritt ist nötig, damit SignalR läuft. Wir müssen ein Script-Verweis auf eine Route machen, die von der SignalR Owin Komponente behandelt wird, um die sog. Hubs auf der Clientseite bereitzustellen. Das tue ich in der “scripts”-Sektion direkt auf der Seite auf der mein Chat laufen soll:

@section scripts
    <script src="../signalr/hubs"></script>

Das Bundle “~/bundles/chatter” bindet die chatter.js ein, mit der ich auf der Clientseite mit SignalR arbeite. Mehr dazu später.


In der BundleConfig.cs muss die JavaScript Bibliothek “jquery.signalR” noch eingebaut werden. Das habe ich direkt im Bundle vom jQuery getan:

bundles.Add(new ScriptBundle("~/bundles/jquery").Include(


Das Sample

Das Beispiel das per NuGet installiert wurde zeigt einen Stock Ticker, ist schön klein und übersichtlich gehalten und läuft auf Anhieb. Die beste Grundlage um mir das eine oder andere abzuschauen.

Aufgerufen wird es über “~/SignalR.Sample/StockTicker.html”

Schaut es euch am besten selber an :)

Auf geht’s

Ich entscheide mich als, den Chat in der gleiche Struktur umzusetzen wie im StockTicker Sample.

Ich fange dafür am besten mit dem sog. “Hub” an. Der Hub definiert die Schnittstelle wie sie vom Client aus aufgerufen werden kann, zudem kann er über den IHubConnectionContext direkt mit den Clients kommunizieren.

public class ChatHub : Hub
    private readonly Chatter _chatter;

    public ChatHub() :

    public ChatHub(Chatter chatter)
        _chatter = chatter;

    public void SignIn(string connectionId, string name)
        _chatter.SignIn(connectionId, name);

    public void Post(string connectionId, string post)
        _chatter.Post(connectionId, post);

    public void SignOut(string connectionId, string name)
        _chatter.SignOut(connectionId, name);

Das Attribut “HubName” definiert den Hub wie er vom Client aus gesehen wird. Wichtiger ist die Basisklasse “Hub” von der hier geerbt wird. Die eigentliche Arbeit ist dann in der Klasse Chatter die als Singleton implementiert ist. Interessant ist, dass ich die Methodennamen nicht extra auszeichnen muss. Auf der Clientseite kommen Sie dennoch sauber mit Camel-Casing an (also signIn, post, signOut)

Die ConnectionId muss mir der Client explizit mitgeben. Das geht leider nicht aus dem Sample hervor, aber eine kleine Google-Recherche half sofort. Anders als bei einem StockTicker, habe ich es beim Chat mir Usern zu tun die ich erkennen muss. So muss der User der sich einloggt, explizit begrüßt werden, während die anderen Teilnehmer einen Hinweis über einen neuen Teilnehmer bekommen.

Die Klasse “Chatter” ist mit Hilfe vom Typ System.Lazy<> als Singleton angelegt. Singletons habe ich auf diese Art noch nicht umgesetzt, funktioniert aber, sieht gut aus und kann man öfter mal so machen:

private readonly static Lazy<Chatter> _instance = new Lazy<Chatter>(
    () => new Chatter(GlobalHost.ConnectionManager.GetHubContext<ChatHub>().Clients));
public static Chatter Instance
    get { return _instance.Value; }

Der Chatter bekommt einen IHubConnectionContext<dynamic> injiziert, was die Client API abbildet, denn schließlich soll ich ja auch Methoden auf dem Client aufrufen können. Diesen Context speichere ich in einer Eigenschaft mit dem Namen “Clients”:

private IHubConnectionContext<dynamic> Clients { get; set; }

private Chatter(IHubConnectionContext<dynamic> clients)
    Clients = clients;
    Users = new Dictionary<string, string>();

Wie das aussieht und wie ich die Teilnehmer beim Login anhand der ConnectioID unterschiedlich behandle, ist hier zu sehen:

public void SignIn(string connectionId, string name)
    Users.Add(connectionId, name);
    Clients.Client(connectionId).postMessage("> ## Hello " + name + " ##");
    Clients.AllExcept(connectionId).postMessage("> ## new user '" + name + "' added ##");

Hier ist der Grund für die ConnectionId zu sehen: Nachdem der User hinzugefügt wurde, teile ich diesem User explizit mit, dass er hinzugefügt wurde. Anschießend schreibe ich eine Chat-Nachricht direkt an den neuen User raus und am Ende teile ich allen anderen Teilnehmern mit, dass es einen neuen Teilnehmer gibt.

Eine normale Chatnachricht geht wie folgt an alle Clients raus:

public void Post(string connectionId, string message)
    string user;
    if (Users.TryGetValue(connectionId, out user))
        Clients.All.postMessage(user + "> " + message);

Existiert der User im Pool, geht die Chatnachricht einfach an alle raus.

Bei Ausloggen gehe ich wieder explizit auf die User ein und behandle den entsprechenden User separat:

public void SignOut(string connectionId, string name)
    Clients.Client(connectionId).postMessage("> ## Goodby " + name + " ##");
    Clients.AllExcept(connectionId).postMessage("> ## user '" + name + "' removed ##");

Ralf Westphal: Konstruktivistische Softwareentwicklung für mehr Wandelbarkeit

Code sei ein Mittel, um die Realität abzubilden. Zumindest scheint mir das ein wesentlicher Antrieb hinter der Objektorientierung zu sein. Mit Objekten sollte es endlich möglich sein, Dinge und Verhältnisse der Welt möglichst 1:1 in Code zu fassen. Das ist eine platonische Sichtweise der Welt. Sie geht davon aus, dass es etwas unabhängig von Code gibt, das irgendwie ist. Und dieses So-sein kann

Jürgen Gutsch: CodeLens Indicators for Git in VS 2013 Ultimate Update 3

Nachdem ich gestern endlich mal das Update 3 für Visual Studio 2013 installiert habe, ist mir heute endlich auch aufgefallen, dass die CodeLense Indicators erweitert wurden:

Neu sind an zweiter und dritter Stelle der letzte Änderer und der Zeitpunkt der letzten Änderung, sowie die Anzahl der Änderungen. Diese Angaben stammen in meinem Fall aus Git.

Klickt man auf die zweite oder dritte Stelle so sieht man die die Änderungen mit wunderhübschen, denglischen Commit Messages, Datum, User und kann auch direkt die entsprechende Version in den Editor holen

Ein Maus-Over auf der einzelnen Zeile gibt dabei weitere Informationen preis.

Ein bisschen Recherche hat mich zu einem ausführlichen Blogartikel von Jean-Marc Prieur gebracht: Code Lens for Git in Visual Studio 2013 Ultimate Update 3

Jetzt muss die Git Integration im VS nur noch für große Projekte performanter werden, dann würde ich die nicht immer gleich ausschalten ;)

Kay Giza [MS]: Einladung: Technical Summit 2014 in Berlin im November

Es ist mir eine freude auf das Microsoft Technical Summit 2014, in Berlin im November 2014 aufmerksam zu machen! Denn: Microsoft lädt zum Gipfeltreffen der technischen Experten nach Berlin ein. Top Speaker des Technical Summit 2014 ist sicherlich der neue Microsoft Chief Executive Officer (CEO) Satya Nadella. Microsoft lädt IT-Professionals und Entwickler vom 11. bis 13. November in Berlin zum „Technical Summit 2014“. Die ersten beiden Tage stehen im Zeichen der Konferenz mit ihren insgesamt rund 40 Sessions und Live-Demos, Tag 3 ist... [... mehr auf Giza-Blog.d]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
© Copyright 2006-2013 Kay Giza. All rights reserved. Legal

ppedv Team Blog: Angular-Listen mit Hash filtern

Beim Stöbern in SPA-Anwendungsfällen bin ich der Idee verfallen, Listen anhand der URL bzw. den enthaltenen Hash-Werten zu filtern. Eine URL setzt sich laut RFC 3986 wie folgt zusammen.

foo://example.com:8042/over/there?name=ferret#nose \_/ \______________/\_________/ \_________/ \__/ | | | | | scheme authority path query fragment | _____________________|__ / \ / \ urn:example:animal:ferret:nose

Der letzte Teil, das Fragment, wird beim HTTP Request vom Browser nicht zum Server übermittelt. Dies macht sich unter anderem Angular.js zu Nutze, um ein clientseitiges Routing der Views durchzuführen. Das ähnelt ASP.NET MVC, ist aber nach dem # Zeichen, das wir hier als Hash Key bezeichnen. So ist es möglich, die Ergebnismenge direkt per Link anzuspringen.

Im folgenden Beispiel filtern wir mit einer Art Navigationsleiste eine Liste. Damit wir den Browser nicht überfordern, geben wir den Hashkey als Parameter an und führen somit AJAX Call Backs zum ASP.NET Web API basierten Service durch.

Der Service liefert Chatnachrichten anhand eines Chatrooms. Das VB.NET Web API Sample decodiert die URL um z.B. Sonderzeichen korrekt zu behandeln.

   1:   Function Getchatmessage(room As String) As IQueryable(Of chatmessage)
   2:       Dim r = HttpUtility.UrlDecode(room)
   3:       Return db.chatmessage.Where(Function(c) c.room.roomname = r)
   4:   End Function


Folgende UI bietet dem Benutzer drei Optionen:


Die Links werden in der Form ASPX-Seite in der FriendlyUrl Notation ohne Erweiterung, gefolgt vom Hashkey und dem Wert erzeugt.


Erste Lektion: Angular fügt nach dem Hashkey einen Slash (Schrägstrich) in die URL im Browser ein, obwohl im HTML Source keiner steht.


Ich habe dazu recherchiert und herausgefunden, dass es einen Hashbang Mode, oder HMTL5 Mode, gibt. Der genaue Grund ist mir noch unklar. Später wird ein JavaScript Replace das wieder gerade biegen.

Um die HTML-Inhalte zu erstellen, habe ich eine Server Rendering-Methode gewählt. Hier habe ich auf Webforms gesetzt. Dies ist einfacher und erlaubt auch besseres Caching, also schnellere Ausführung.

Vorbereitend definieren wir eine Angular-App samt dazu gehörigem Controller. Die Anzeige des Hash per Databinding {{}} dient Kontrollzwecken. Das Listview Web Server-Steuerelement binden wir per Model Binding an die Room Liste. Der VB.NET Codebehind Source Code findet sich im nächsten Listing.

Der Name des Rooms wird passend zur URL encodiert. Wenn der Benutzer diesen Link klickt, passiert faktisch nichts, außer dass die URL im Browser um den Hashwert ergänzt wird.

   1:  <body ng-app="App">
   2:      <form id="form1" runat="server">
   3:          <div ng-controller="chatController">
   4:              <div>Hash:{{target}}</div>
   5:              <div>
   6:                  <asp:ListView ID="roomlist" runat="server" 
   7:                      SelectMethod="roomlist_GetData">
   8:                      <ItemTemplate>
   9:                          <a href='/chat#<%#HttpUtility.UrlEncode(Item.roomname)%>'>
  10:                              <%#Item.roomname%>
  11:                          </a>| 
  13:                      </ItemTemplate>
  14:                  </asp:ListView>

Dies ist der Inhalt der dazu gehörigen aspx.vb Datei. Es kommt ein Entity Framework Code First Model zum Einsatz.

   1:   Public Function roomlist_GetData() As IQueryable(Of room)
   2:          Dim db As New ConcordeContext
   3:          Return db.room
   4:   End Function


Nun kommt der spannende Teil, der Angular.js Controller. Dieser führt einen Callback per $http aus und übergibt dabei den Hashwert aus der URL als Parameter. Dabei hilft $location, das per Path (eigentlich sollte es hash() sein) den passenden Wert aus der URL liefert. Nach Aufruf des REST-Services stehen die JSON-Daten in der Variable data (Zeile 20) und werden direkt der Chatmessages-Eigenschaft im $Scope zugewiesen.

Das Besondere an diesem Angular-Beispiel ist, dass ein Watcher (Zeile 5) auf dem Viewmodell gesetzt wird, der die Änderung der URL als Event-Geber nutzt und den Service Call initiiert. Ohne diesen läuft der Controller nur einmal durch.

   1:  angular.module('App', [])
   2:    .controller('chatController',
function ($scope, $http,$location,$window) {
   3:      $scope.chatMessages = [];
   4:      $scope.location = $location;
   5:      $scope.$watch('location.absUrl()', function () {
   6:          $scope.target = $location.path(); 
   7:          $scope.ladeMessages();
   8:      }, true);
   9:      $scope.ladeMessages = function () {
  10:          if ($scope.target != null) { 
var para = $scope.target.replace('/', ''); };
  12:          $http(
  13:       {
  14:           method: 'GET',
  15:           url: 'api/chatmessages',
  16:           params: {
  17:               room: para
  18:           }
  19:       })
  20:      .success(function (data, status) {
  21:          $scope.chatMessages =  data;
  22:      })
  23:      };
  25:  });

Nun fehlt noch der deklarative HTML5 Teil, der entweder eine Meldung für leere Daten oder die Liste anzeigt. Dies ist der einfachste Teil. Der Scope enthält die Liste der ChatMessages, die mit der ng-repeat-Direktive durchlaufen wird. Dies ähnelt einem ASP.NET Repeater Control, nur eben clientseitig.

   1:   <div ng-show="chatMessages.length==0">
   2:                keine Daten...
   3:   </div>
   4:    <div ng-repeat="msg in chatMessages">
   5:                      {{msg.Message}}
   6:   </div>

Holger Schwichtenberg: Satya Nadella kommt zu Microsofts Technology Summit 2014 nach Berlin

Die Anmeldung zu der vom 11. bis 13. November 2014 gehenden Konferenz ist jetzt eröffnet.

Holger Sirtl: Satya Nadella kommt zum Microsoft Technical Summit 2014

Wer heute die Webseite zum Microsoft Technical Summit gesehen hat, hat’s sicher gesehen: Satya Nadella, Microsoft CEO wird da sein und eine Keynote halten!!!


Jetzt gibt’s also keine Ausrede mehr… schnell anmelden!

Hier nochmal die wichtigsten Eckdaten

Microsoft Technical Summit

11./12. November 2014 (Konferenz)
13. November 2014 (Workshops)

Best Western Premier Hotel MOA Berlin
Stephanstrasse 41
10559 Berlin Moabit


Ich hoffe, wir sehen uns da!!!

codefest.at [MS]: Visual Studio Online – die Cloud auch für Entwickler


Möglicherweise habt ihr schon den Microsoft Team Foundation Server (TFS) in einem eurer Projekte eingesetzt. Vielleicht nur als reines Source Code Verwaltungstool, oder ihr habt auch mehr davon verwendet, z. B. die Prozessvorlagen für die agile Softwareentwicklung, oder Scrum. Vermutlich habt ihr damit auch Work Items zugewiesen, Bug Tracking verwendet und Builds automatisiert.

Diesen TFS habt ihr vermutlich in einem Windows Server in eurem (Firmen-)Netzwerk installiert. Das Entwicklungsteam verwendet Visual Studio, um sich an den TFS anzuhängen. Das bedeutet, dass die Hardware angeschafft, das Server OS lizenziert und installiert werden musste (bzw. eine VM zur Verfügung gestellt wurde) und jemand eine bestimmte Version des TFS installiert hat. Kurz gesagt, es fallen Kosten an: für die Hardware, die Software und die Wartung des (eigenen) Systems (z. B. Updates des Server OS bzw. des TFS müssen selbst eingespielt werden).

Falls ihr den TFS überhaupt noch nicht in Verwendung hattet, so ist möglicherweise ein anderes Source Code Verwaltungstool, wie z. B. Git, Tortoise, oder Jira im Einsatz. Alle aufgezählten Varianten haben Vorteile, aber auch verschiedene Nachteile.

In einem meiner Entwicklungsteams haben wir eine Menge Source Code und Zeit verloren, da das Infrastruktur-Team geschlampt hat. Wie? Nun ja, trotz mehrmaliger Rückfragen meinerseits, ob es ein funktionierendes Backup unseres Servers gibt, war im Ernstfall leider keines vorhanden. Obwohl diese Anfrage zuvor mehrmals positiv beantwortet worden war…..

Nun…ja….seither verlasse ich mich äußerst ungerne auf Infrastruktur-Teams und sehe mich gerne nach alternativen Lösungen zu dem In-House Hosting unseres Source-Codes um.

Als erste Variante gibt es natürlich den gehosteten TFS. Mehr Informationen findet Ihr z. B. hier:


Ihr entscheidet euch für eine Version des TFS (2010, 2012, oder 2013) und für die Basic (Source Control und Work Item Tracking), oder die Full Variante (Basic features und mit Sharepoint und Reporting).

Diese Variante hat bestimmt ihren Reiz, ich möchte euch aber eine weitere Möglichkeit erläutern: Visual Studio Online (VS Online).

VS Online – Allgemein

Wieder ein neues Produkt werdet Ihr euch jetzt möglicherweise denken, das ist aber so nicht ganz korrekt. Mit beiden Produkten könnt ihr:

· Euren Source Code in verschiedenen Versionen verwalten
· Work Items verwalten
· Bugs tracken
· Backlogs verwalten

Also im Großen und Ganzen all das, was ein gutes Application Lifecycle Management (ALM) Produkt können sollte.

Wie man anhand dieser Auflistung sehen kann, sind die Core-Funktionalitäten von TFS und VS Online gleich. Eigentlich ist es das selbe Produkt, allerdings mit unterschiedlichen Versionssprüngen und der zugehörigen Updates (VS Online hieß früher auch Team Foundation Service). TFS wird in eigenständigen Versionen ausgeliefert, aktuell 2013, davor 2012 und 2010. Dies kennt ihr z. B. von Visual Studio selbst, oder auch vom SQLServer, oder Office her. Immer, wenn ein neues Release am Markt ist, entscheidet ihr euch diese zu installieren und eure bestehende Software upzugraden (oder eben auch nicht).

VS Online kennt diesen Produktzyklus in dieser Form nicht. Es gibt keine Version 2013, 2012, oder 2010, stattdessen wird VS Online automatisch auf den neuesten Stand gebracht. Schön und gut, aber wer macht dann die Updates? VS Online steht „in der Cloud“ zur Verfügung. Microsoft’s Cloud Lösung heißt Azure und bietet mittlerweile eine Menge an Diensten, einer davon ist eben VS Online.

VS Online – Features

Es gibt zwei verschiedene Varianten von VS Online: Basic und Professional. Gemeinsam ist den beiden, dass keine eigene Infrastruktur, wie z. B. ein eigener Server zur Verfügung gestellt werden muss. Der Source Code liegt in der Cloud und ist von überall – von berechtigten Personen – abrufbar (ohne lästiger VPN Clients auf den Entwickler-Notebooks). Sehen wir uns einmal die beiden Versionen an.

Ich möchte euch zuerst die Features vorstellen, die mich überzeugt haben, mit meinem Entwicklungsteam auf VS Online umzusteigen.

Jeder VS Online Zugang verfügt über

. fünf kostenlose Benutzer (weitere Benutzer sind dann allerdings kostenpflichtig),
· eine unbegrenzte Anzahl von Projekten (im Team, oder „privat“ – also für einen Entwickler),
· gehostete Code-Repositories mit der Team Foundation-Versionskontrolle oder Git in unbegrenzter Größe.

Somit ist sichergestellt, dass auf den Source Code von allen Entwicklern immer und überall zugegriffen werden kann und so jederzeit Source Code eingecheckt werden kann. Sowohl mit einer unbegrenzten Anzahl von Projekten als auch einer unbegrenzten Größe dieser Projekte!

Weitere Vorteile der gebotenen Features für die gemeinsame Entwicklung innerhalb des Teams:

· Über sogenannte Teamräume wird jeder Entwickler über den aktuellen Projektstand informiert.
· Aufgliedern und Planen komplexer Projekte erfolgt mittels der agilen Portfolioverwaltung:

o Erfassen von Product-Backlogs.
o Definition und Verfolgung von Sprints.
o Zuweisen und Tracken von Work-Items.
o Einholen und Nachverfolgen von Feedback für Projektbeteiligte (mit dem Microsoft Feedback Client).

· Erstellen von Testplänen und Test Cases.
· Integriertes Bug-Tracking.
· Verwenden der Auslastungstests (bis zu 15.000 virtuelle Benutzerminuten pro Monat).

Des Weiteren inkludiert VS Online eine Version von Visual Studio Express für das Web, Windows oder Windows Desktop, aber als eingefleischte Entwickler habt ihr vermutlich schon eine der höherwertigeren Desktop Varianten der Visual Studio Editionen installiert. VS Online funktioniert allerdings auch mit Eclipse oder XCode, ist also nicht an Visual Studio gebunden.

All diese aufgezählten Punkte sind bereits in der VS Online – Basic Version enthalten und stehen zur freien Nutzung bereit. Solltet ihr euch mehr Features punkto Projektplanung wünschen, dann solltet ihr einen Blick auf die VS Online Advanced Variante legen, diese kostet allerdings $60,-- pro Benutzer im Monat. Eine VS Online Professional Variante ist ebenfalls erhältlich, diese umfasst ein monatliches Abonnement für die Visual Studio Professional IDE und schlägt mit $ 45,-- zu Buche.

Aber zu Beginn sollte die VS Online Basic Variante durchaus ausreichen, möglicherweise benötigt Ihr mehr Benutzer, dann kostet jeder weitere Benutzer (über die inkludierten 5 hinaus) $ 20,-- im Monat.

Kommen wir aber nun zur Anwendung von VS Online und legen ein Beispielprojekt an und checken auch gleich einmal (vorhandenen) Source Code ein.

Dazu sind folgende Schritte notwendig:

· Anlegen des VS Online Kontos.
· Anlegen eines neuen Projektes.
· Einchecken des lokalen Source Codes.

Drei kleine Schritte, mal sehen, ob es wirklich so einfach ist. In circa 10 Minuten könnt ihr selbst darüber urteilen……legen wir also los, die Zeit läuft!

VS Online – Anwendung

Das VO Online - Konto

Zur Verwendung von VS Online wird ein VS Online-Konto benötigt. Das klappt schnell und problemlos mit dem Browser und folgendem Link: http://go.microsoft.com/fwlink/?LinkId=307137&clcid=0x407


Nach erfolgreicher Anmeldung ist euer Konto jederzeit unter folgender Adresse im Browser erreichbar: .visualstudio.com">.visualstudio.com">.visualstudio.com">http://<kontoname>.visualstudio.com

Eine zweite Variante steht euch auch noch über das Azure Managementportal zur Verfügung: http://manage.windowsazure.com bzw. https://portal.azure.com/


Wie auch immer ihr euren VS Online Zugang anlegt, auf jeden Fall seid ihr nun glücklicher Besitzer eines VS Online Zugangs.

Nach erfolgreicher Anmeldung werdet ihr aufgefordert, ein neues Projekt anzulegen. Sehr gut, denn das ist es ja auch, was wir im nächsten Schritt machen wollen. Das ist allerdings nur beim ersten Mal so, nächstes Mal befindet ihr euch im VS Online DashBoard, wo ihr die Zusammenfassung eures Accounts einsehen könnt.


Anlegen eines neuen Projektes

Ich habe in letzter Zeit an einigen mobilen Projekten mit Xamarin in Visual Studio gearbeitet und eines dieser Projekte würde ich gerne zu VS Online deployen, um damit die die Source Code Verwaltung durchzuführen. Das bedeutet also, dass ich lokal bereits ein Projekt habe, in VS Online existiert dieses aber noch nicht – es muss also angelegt werden, danach dieses VS Online Projekt mit meinem lokalen Verzeichnis verbunden werden, dann kann der Source Code eingecheckt werden. Das klappt natürlich auch umgekehrt, also zuerst das VS Online Projekt erstellen, danach erst in das Codieren einsteigen. Wie auch immer, das VS Online Projekt muss angelegt werden.

Falls ihr gerade euer VS Online Konto erstellt habt, dann seid ihr schon auf der richtigen Eingabemaske. So legt nun ein neues Projekt an, der „New“-Button lädt gerade dazu ein, gedrückt zu werden.

Auf jeden Fall müssen nun ein paar Angaben zu dem Projekt gemacht werden:

  1. Der Name des Projektes ist einzutragen,
  2. optional kann dazu eine Beschreibung erfasst werden.
  3. Als Scrum Master kommt mir das „Microsoft Visual Studio Scrum 2013.3“ Template gerade recht (andere Optionen sind: MSF for Agile Software Development 2013.3 und MSF for CMMI Process Improvement 2013.3).
  4. Als Versions-Kontrolle setze ich auf die „Team Foundation Version Control“, da ich damit jahrelange (gute)Erfahrungen habe, die andere Option wäre Git - SVN wird leider nicht unterstützt.

Wie bereits erwähnt, habe ich das Projekt auf meinem lokalen Rechner, ich habe es also einfach mit den einzugebenden Werten (jaja, wie lange grübelt man normalerweise am Projektnamen…) wie man nachfolgend sehen kann:


Mit dem „Create Project“ Button ist dieser Schritt auch schon so gut wie abgeschlossen. Den Rest der Arbeit erledigt VS Online, welches das Projekt und den zugehörigen Team Room anlegt und zur Verfügung stellt, wo ihr euch später mit den anderen Teammitgliedern über das Projekt austauschen könnt..

Mit „Navigate to project“ gelangen wir zur Detailansicht, bzw. öffnet sich diese von selbst, wenn ihr das erste Mal ein Projekt angelegt habt.


Hier ist natürlich noch nicht allzu viel zu sehen, als sehr hilfreich wird sich gleich die rechte obere Ecke erweisen, wenn wir zum nächsten Schritt gelangen.

Mappen und Einchecken des lokalen Source Codes

Bevor Ihr den VS Online Account mit eurem lokalen Projekt verbinden könnt, überlegt bitte noch einmal kurz, ob eure lokale Visual Studio 2013 Installation mit eurem Microsoft Account verbunden ist – gegebenenfalls kontrolliert das bitte, bzw. führt die Anmeldung – rechts oben - im Visual Studio 2013 durch.


Wenn ihr schon dabei seid, könnt Ihr noch in Visual Studio 2013 kontrollieren, ob Ihr Team Foundation Server als momentanes Source Control plug-in verwendet. Dazu einfach das Menü Tools -> Options und Source Control aufrufen und gegebenenfalls die ComboBox anpassen.


Nun ist es an der Zeit den VS Online Account mit einem (lokalen) Projekt zu verbinden. Dazu verwendet man am einfachsten den ‚Open in Visual Studio‘ Button im rechten oberen Bereich.


Sobald dieser gedrückt wird und ihr die Abfrage bestätigt, dass eine lokale Applikation geöffnet werden soll (ich empfehle euch die kleine CheckBox anzuklicken, damit diese Meldung in Zukunft nicht mehr gezeigt wird), öffnet sich auf dem lokalen Rechner Visual Studio 2013. Angezeigt wird der Team Explorer, der darauf wartet, dass das VS Online Projekt mit einem lokalen Projekt gemapped wird.

Dazu führt ihr folgende Schritte durch (in den Bildern unten der Reihe nach dargestellt):

  • Drücken des Links bei der Meldung “configure your workspace”
  • Jetzt muss das VS Online Projekt ($/Azure Informer) auf das lokale Verzeichnis gemappt werden, bei mir liegt der Source Code unter „C:\Development\Mobile\AzureInformer“.
  • Nachdem der “Map & Get” Button gedrückt wurde, ist VS Online mit dem lokalen Projekt verbunden.


Nachdem diese Schritte erledigt wurden, kann das Projekt unter Source Code-Verwaltung gestellt werden. Spätestens jetzt solltet ihr euer Projekt in Visual Studio 2013 öffnen. Einchecken ist nun keine große Sache mehr, das gelingt mit der rechten Maustaste an eurer Solution im Solution Explorer und der Auswahl von „Add Solution to Source Control…“. Das gleiche Spielchen noch einmal, allerdings wird nun „Check In…“ angewählt.

image_thumb26 image_thumb28

Die Ansicht wechselt wieder auf den „Team Explorer“, jetzt noch schnell ein Kommentar für das Einchecken des Source Codes eingeben, den Check-In Button drücken und der Source Code ist in guten Händen, immer und überall für mein Team und mich erreichbar.

image_thumb19 image_thumb20

Geschafft, der Source Code ist bei VS Online hinterlegt. Die nächsten Schritte wären nun, weitere Team Mitglieder einzutragen, danach Work Items zu erfassen und an das Team zu verteilen. Die faszinierende Reise mit VS Online kann für mein Team und mich beginnen!


Ich durfte in meinem Arbeitsleben bisher 3 Entwicklungsteams leiten und ich hätte mir jedes Mal die unproblematische Möglichkeit der Kollaboration innerhalb des Teams, sowie die jederzeitige Verfügbarkeit des Source Codes von jedem Ort der Welt gewünscht. VS Online macht es möglich eine unlimitierte Anzahl von Projekten mit unlimitierter Größe zu verwalten. Für Entwicklerteams mit bis zu 5 Leuten ohne jeglicher Kosten. Microsoft ist hier wieder ein hervorragendes Stück Software gelungen, einfach verpackt, ready to use for everyone!

Berndt Hamböck ist seit 2007 MCT, darüber hinaus befasst er sich mit Lösungen für komplexe Anwendungsszenarien mit den neuesten Microsoft Technologien. Die Erfahrungen aus der Projektarbeit gibt er in Vorträgen und Trainings weiter und begleitet Entwicklerteams in Softwareunternehmen bei Projekten im Microsoft Umfeld.

„Das ist ein Gastbeitrag. Die Meinung des Autors muss sich nicht mit jener von Microsoft decken. Durch den Artikel ergeben sich keinerlei Handlungsempfehlungen. Microsoft übernimmt keine Gewähr für die Richtigkeit oder Vollständigkeit der Angaben.“

Sven Hubert: New feature for AIT Apply Company Policy: include and exlude projects

Coding guidelines are very useful and should be enforced wherever possible. The free tool AIT Apply Company Policy (ACP), which we already presented in another blog entry, can help here. But there might be some guidelines or rules that should be applied to only some projects or to all except some projects. This is now possible with the new version of AIT Apply Company Policy, which is available in the download section.

For example one could create an ACP package that will be applied to all projects, but for all test projects the documentation should not be created. Then the respective section in the CompanyPolicy.config could look like this:

<Documentation exclude="*.Test"> 
    <Configuration Name="Debug" enabled="true" /> 
    <Configuration Name="Release" enabled="true" />    
    <Configuration Name="Staging" enabled="true" /> 

The exclude attribute determines that in all projects ending with “.Test” the documentation will not be created.

In another scenario one could create an ACP package which should be applied only to test projects, e.g. specific rules for the static code analysis, and one has to make sure that this package can really be applied only to test projects. This is possible using the following entry:

<StaticCodeAnalysis includeOnly="*.Test"> 
    <Configuration Name="Debug" enabled="true" ruleSet="AIT.ruleset" /> 
    <Configuration Name="Release" enabled="true" ruleSet="AIT.ruleset" />     
    <Configuration Name="Staging" enabled="true" ruleSet="AIT.ruleset"/> 

Here the includeOnly attribute defines that the rules for the static code analysis is applied only to projects ending with “.Test”.

Furthermore it is possible to combine both of these attributes. This way, one can apply rules e.g. only to projects whose name contains “Infrastructure” but does not end with “.Test”.

New feature for AIT Apply Company Policy: include and exlude projects is a post from: AIT Blog

ppedv Team Blog: Windows Tipp - Wochentag in der Startleiste anzeigen

So mancher mag sich zuweilen die Frage stellen: Kann Windows auch den Wochentag in der Startleiste darstellen? Selbst wenn man sich diese Frage noch nie gestellt hat: wer diese Einstellung bei jemandem sieht, ist oft sehr angetan. Die meisten Benutzer möchten dann wissen, wie sie dies auch auf ihrem Computer einstellen können.

So wird's gemacht:

Die Einstellung vornehmen

Drücken Sie die Windows-Taste + R und geben "intl.cpl" ein, gefolgt von OK, danach wählen Sie Weitere Einstellungen… und den Reiter Datum.


Anpassung der Datumsdarstellung

Sie möchten, dass der Wochentag ausgeschrieben sein soll, dann geben Sie in das Feld Datum (kurz) statt "TT.MM.JJJ" "TTTT, TT.MM.JJJJ" ein.


Unterhalb der Felder stehen Erläuterungen zur Bedeutung der Buchstaben und deren Auswirkungen auf die Anzeige.


Bestätigen Sie die Einstellungen mit OK und der Wochentag erscheint, wie gewünscht, unten in der Startleiste.



Jürgen Gutsch: Agile Bodensee Konferenz am 01. und 02 Oktober 2014

Auch auf der diesjährigen Agile Bodensee Konferenz bin ich wieder dabei. Dieses mal – am 1. Oktober – mit einem Workshop mit dem Titel “TDD Extreme

Was sich dahinter verbirgt? Vor allem provokante Aussagen meinerseits und um das Thema TDD die ich versuche anhand von Beispielen und Übungen zu Beweisen ;)

Interessiert? Dann schreibt doch einfach eine Twitter-PM an @sharpcms oder eine Nachricht per Facebook an juergen.gutsch mit dem Stichwort “TDD@abkon”. Ihr erhaltet dann einen Rabattcode mit dem ihr 10% Rabatt auf ALLE Ticket-Kategorien bekommt und könnt so etwas günstiger an dem Workshop teilnehmen :)

Weitere Informationen zur Agile Bodensee Konferenz 2014 und vor allem die komplette Agenda über die zwei Tage erhaltet ihr direkt auf der Website: www.agile-bodensee.com

ppedv Team Blog: Windows 8.1 ohne Microsoft-Konto installieren

Manche Benutzer verwenden ein lokales Benutzerkonto, damit keine Daten bei Microsoft gespeichert werden. Beim Update auf Windows 8.1 müssen diese während der Installation ein Microsoft-Konto anlegen. Es gibt dennoch eine Möglichkeit, die Registrierung zu umgehen. Sie müssen nicht, wie suggeriert, ein neues Konto anlegen.

Wie Sie dabei vorgehen, lesen Sie hier.

Update starten:

Das Update auf Windows 8.1 ist im Windows Store zu finden. Mit der „Windows-Taste“ gelangen Sie auf die Kacheloberfläche. Klicken Sie hier auf Store, dann erscheint die Kachel Kostenloses Update auf Windows 8.1.


Unter Umständen erscheint die Meldung, dass Sie Updates installieren müssen.

Die verborgene Einstellung auswählen:

Jetzt wird das Update heruntergeladen, der Computer startet neu, danach bestätigen Sie wie üblich die Lizenzbedingungen und klicken dann auf Express-Einstellungen verwenden.

Wenn „Melden Sie sich bei Ihrem Microsoft-Konto an“ erscheint, klicken Sie unterhalb auf die nahe unsichtbare Zeile Neues Konto erstellen und auf Mit einem vorhandenen Konto fortfahren.


Sie lassen alles Weitere durchlaufen und installieren.

Das ist alles, so klappt es!

Golo Roden: Konsole & …: Rekursion

Die Fähigkeit einer Funktion in JavaScript, sich rekursiv aufrufen zu können, scheint nichts Besonderes zu sein. Dennoch gibt es dabei ein paar Aspekte zu beachten, insbesondere im Hinblick auf die kommende Version der Sprache: ECMAScript 6.

Karsten Kempe: TFS loves Git: Pull Requests

Der Pull Request ist ein Mechanismus, mit den Entwickler andere Teammitglieder über die Fertigstellung eines Features informieren, zu einem Review auffordern oder zur Zustimmung für die Aufnahme in einen integrierten Source Code Stand bitten können. Dieser Workflow kommt in Open Source Plattformen wie GitHub oder Bitbucket stark zum Einsatz und war bislang ein vermisstes Feature im TFS und Visual Studio Online. Seit ein paar Wochen gibt es diesen Mechanismus jetzt auch für Git Projekte in Visual Studio Online und bald auch im TFS on-prem.

Ein Entwickler entwickelt ein Feature in einem dedizierten Branch auf einem lokalen Repository. Sobald er seinem Team eine Version zur Verfügung stellen will, pusht der Entwickler den Branch in ein öffentliches Repository in Visual Studio Online. Dort kann er dann einen Pull-Request absetzen und das Team zum Review auffordern. Das Team wird daraufhin den Code untersuchen, darüber diskutieren und kommentieren. Am Ende wird der bereitgestellte Code von einem Verantwortlichen aus dem öffentlichen Feature Repository in das Master Repository überführt. Wenn die Entwicklung des Features komplett abgeschlossen ist, wird das öffentliche Repository gelöscht.

TFS Git Pull Requests

Abbildung 1: Pull Request Workflow

In folgendem Video könnt Ihr Euch ansehen, wie dieser Vorgang in Visual Studio Online funktioniert.


Pull-Requests erleichtern die Zusammenarbeit in weit verteilten Teams, in denen oftmals nur isoliertes Arbeiten möglich und meistens auch gewünscht ist. Damit der integrierte Master-Stand nicht zerstört wird, setzen viele Open Source Communities auf diesen Mechanismus. Dadurch wird die Code-Qualität des Master Repositories stabilisiert und die Qualität des ganzen Teams verbessert.

Jürgen Gutsch: Geplanter Umzug meines Blogs

Im Zuge des Umbaus meiner eigenen Website, habe ich mich dazu entschlossen, auch meinen Blog umzuziehen. Nicht weil das System auf dem Community Server von ASP.NET Zone schlecht wäre, sondern eher deshalb, weil ich mein Blog enger in meine Website integrieren möchte. In den vergangenen Monaten wurde die Website wieder immer mehr eine persönliche Portfolio Seite und das Blog soll der hauptsächliche Content-Lieferant der Website werden.

Auch vorher hatte ich bereits die Idee, dass ich mein Blog mehr in meine Kontrolle holen möchte. Allerdings läuft das bisherige System gut und stabil und es gab keinen zwingenden Grund für einen Umzug. Dennoch hatte ich mir einige vorhandene Systeme angeschaut, die mir aber alle zu umfangreich sind, um sie in meine Website zu integrieren. In vielen Fällen fehlte mir jedoch die MetaWeblog API um das Blog per Windows Live Writer zu bedienen, den ich immer noch sehr gerne verwende. (Tipps und Hinweise zu modernen Blog APIs und modernen Authoring-Tools nehme ich hier sehr gerne entgegen.) Sehr gerne schreibe ich morgens oder Abends offline im Zug um die Posts dann später zu veröffentlichen.

Bis ich nun ein wirklich passendes System finde, tendiere ich dazu ein kleines Blog-Framework zu schreiben, dass ich beliebig in jedes ASP.NET Projekt integrieren kann. Für den Anfang soll der SimpleObjectStore die Persistierung übernehmen. Da für dieses Tool beliebige DataProvider bereitgestellt werden können, kann das Framework dann auch bei Bedarf auf eine SQL Database gehen. Ich für meinen Teil werde den DataProvider für den Azure Table Storage verwenden, da die Website selber auf einer Azure Website gehosted wird.

Ziel ist es eine Bibliothek bereitzustellen, welche die nötigen Controller und Models bereitstellt. Die zugehörigen Views muss dann jeder Nutzer dieser Bibliothek selber bereitstellen:


  • BlogController
    • Für Artikel-Listen und Kommentare
  • MetaWeblog Controller
    • Für den Windows Live Writer
    • ggf. per API Controller
  • BlogML Controller
    • Import/Export
  • RSS Controller
    • per API Controller


  • BlogArticleList
  • BlogArticle
  • Comment
  • Tag

Das wird wohl in den nächsten Monaten meine Beschäftigung neben der Arbeit und Familie sein. Mal sehen wie weit ich damit gehe.

Warum selber machen?

Na, um zu lernen. :) In den letzten Monaten sind interessante Neuerungen zu ASP.NET herausgekommen, die ich natürlich gerne genauer anschauen und umsetzen möchte.

Auch hier gilt: Für Vorschläge zu einer alternativen leichtgewichtigen Lösung bin ich immer zu haben.

codefest.at [MS]: V-Play -- Cross-Plattform 2D Spiele-Engine

Spiele-Entwickler kennen Sie wahrscheinlich schon: die österreichische Game Engine V-Playermöglicht die Erstellung von 2D Spielen, die man dann für verschiedene Plattformen deployen kann. Der Gründer von V-Play, Christian Feldbacher, hat schon beim letzten Mobile Developer After-Workdie Engine vorgestellt und demonstriert, wie man damit entwickeln kann.

Die gute Nachricht ist, dass es seit letzter Woche nun auch Support für die Windows Runtimegibt. Das heißt, Spiele, die ihr mit der Engine erstellt, könnt ihr nun auch als Windows Phone und Windows Store Apps deployen. Eine detaillierte Anleitung, wie ihr das machen könnt, findet ihr auf dem V-Play Blog.

Die V-Play Engine gibt es als 14-tätige Trial-Version gratis als Download. Probiert es mal mit einem ersten Spiel aus. Wenn ihr auf dem Geschmack gekommen seid, so könnt ihr in den nächsten Wochen noch interessante Infos zum Thema Gaming auf diesem Blog erwarten.

Ralf Westphal: Warnung vor dem Microservice – Versuch einer Definition

Services sind wieder im Trend. Jetzt unter der Bezeichnung Microservice oder kurz: µService. Das empfinde ich grundsätzlich als Fortschritt. Schon vor einer “Moore-Periode” :-) (also 18 Monaten) habe ich das als konsequente Entwicklung beschrieben unter dem Titel “Software als Web of Services”. Und noch weiter zurück, im Jahr 2005, hatte ich mir in einer Artikelserie unter der Überschrift “

Dirk Primbs [MS]: The zombie apocalypse

“Daddy, why do you always say that the Zombie apocalypse will come and why don’t we prepare for it?”
This question coming from our youngest recently reminded us to flag our pop culture humour more clearly, especially when joking about the potential end of the world.

Zombies are quite in fashion these days. I’m myself a huge fan of “The Walking Dead”, the series _and_ the original comic preceding it. I also watched World War Z, read through the Zombie Survival Guide and I really love the idea to be stranded with my family on a deserted island with tropical fruits growing all around me and a fully equipped yet autarc mansion in the middle of it when it happens.

This (and the tendency to creepy humour which my wife and I share) leads us to referencing zombies every now and then and making fun of the sort “don’t throw away this broken [whatever], what if the zombie apocalypse strikes and you’re in need of a deadly weapon?” or like “in case of the Z.A. we’ll barricade in the children’s rooms. The zombies never make it through that mess without a guide”. Turns out our children wonder how much truth is in the fiction (or alternatively wonder if adults really can believe in such a crazy szenario).

The fact of the matter is that I loved the theme from very early on. A book that I read ages ago and of which I can’t recall the title phantasized that all adults are whiped off the earth by some strange virus and books of that kind were on my reading lists ever since…

Just to name a few:
The Stand
I am legend (must read!)
World War Z (as mentioned)

I guess what fascinated me most was the question how we could hope to strive if no foundation exists anymore. Heck, I’m not even knowledgable enough to repair my shoes, let alone pull something off as a full scale farm (without the help of experienced farmers that is). Truth is, I’m not skilled in anything really useful. I can program, I can create online videos and podcasts, I studied psychology and business administration to some degree and I know how to navigate inside large tech corporations… I’d look into a brisk post-apocalyptic future indeed.

And if you look closely then you’ll discover that in our extremely specialized world almost no one knows enough about the processes around us to restart something remotely resembling civilization, or, to stay at a smaller scale, at least a comfortable living for a few selected survivors.

Since it makes a fascinating thought experiment though – what is necessary to enable mankind to restart quickly – a scholar found the time to write a book on it. (Yep, I’m reading a lot :-))

The Knowledge starts with the assumption that earth has been ripped of 70+% of humans and the survivors need to restart. This means basic knowledge of machinery, medicine, agriculture, etc. is in short supply and the book takes a stab to provide a fascinating and educating overview. I’ll have to admit after reading through my last book – How to create a mind (Ray Kurzweil) – it is quite a shock to get thrown back from envisioning humankinds next evolutionary step to basic survival but, boy, it is fun!

To circle back to the intro: I’ll stash that book for the certain zombie apocalypse, right next to my fully charged laptop, just in case anyone needs either a programmer or someone who simply read a lot, after humankind has been whiped out :-)

Picture credit

The post The zombie apocalypse appeared first on Dirk Primbs Online.

Fabian Deitelhoff: dotnetpro: Screencasts der Rubrik “Frameworks” jetzt online verfügbar

Vor einiger Zeit war das Team der dotnetpro so freundlich, die Screencasts zur Rubrik “Frameworks” auch online zur Verfügung zu stellen. Dass freut mich sehr, ist es ab jetzt doch um einiges einfacher, sich die Videos anzuschauen.

Verlinkt sind die einzelnen Screencasts immer beim jeweiligen Artikel im Online-Portal. Beispielsweise hier für den Artikel “Geschwindigkeitsrausch”. Dafür ist allerdings ein Abo und ein Login auf der Webseite erforderlich. Abbildung 1 zeigt einen Screenshot des eingebetteten Videos.

Abb. 1: Eingebetteter Screencast auf der dotnetpro Webseite.

Abb. 1: Eingebetteter Screencast auf der dotnetpro Webseite.

Zusätzlich besteht die Möglichkeit, jeden Screencast als WMV- oder MP4-Datei herunterzuladen. Wer also bis jetzt keine Lust auf den Datenträger hatte, der jeder Ausgabe beiliegt, kann sich die Screencasts nun auch online ansehen.

Und wie immer gilt: ich freue mich über konstruktives Feedback jeder Art!

Sven Hubert: ALM kompakt: Prüfung eines Work Item Feldes auf ein bestimmtes Textmuster

Bei der Anpassung von Process Templates kann es vorkommen, dass die Möglichkeiten von AllowedValues oder SuggestedValues (siehe All FIELD XML elements reference in der MSDN) nicht ausreichend sind. Wenn man z.B. die freie Texteingabe ermöglichen möchte, diese jedoch einem bestimmten Muster folgen soll. Ein einfaches Beispiel dafür ist die Eingabe einer MAC-Adresse.

Das MATCH-Element

Man könnte also auf die Idee kommen, eine Feldvalidierung mittels regulärer Ausdrücke durchzuführen. Die Konfigurierbarkeit von TFS Process Templates sieht hierfür eine eingeschränkte Variante vor: Das MATCH Element. Dieses ermöglicht eine sehr einfache Musterdefinition. Es wird nach folgender Syntax verwendet:

<MATCH pattern="patternValue" for="userGroupName" not="userGroupName" />

Laut MSDN sind folgende Pattern Values möglich:

  • “A” represents an alphabetical character.
  • “N” represents a numeric character.
  • “X” represents any alphanumeric character.

(siehe Online-Dokumentation in der MSDN)

Das Beispiel der MAC-Adresse lässt sich in der Work Item Type Definition konfigurieren, wie in Abbildung 1 dargestellt.

Abbildung 1: MATCH Element für eine MAC-Adresse

Abbildung 1: MATCH Element für eine MAC-Adresse

Für den Anwender der Work Items äußert es sich so, dass eine Hinweismeldung angezeigt wird, wenn der eingegebene Wert nicht definierten Textmuster entspricht (siehe Abbildung 2).

Abbildung 2: Verstoß gegen das Textmuster

Abbildung 2: Verstoß gegen das Textmuster


Wie vorher beschrieben, bietet das MATCH-Element eine sehr einfache Möglichkeit der Musterdefinition. Von “echten” regulären Ausdrücken ist dies weit entfernt. Wenn man beispielsweise prüfen möchte, ob ein Testfeld ein bestimmtes Präfix hat, reicht diese Möglichkeit bereits nicht mehr aus. Eine weitere Einschränkung ist der Feldtyp, auf den das MATCH-Element anwendbar ist. Es ist ausschließlich für die Verwendung mit String-Feldern vorgesehen. Da sich insbesondere für Beschreibungen die HTML-Felder immer größerer Beliebtheit erfreuen, lassen sich diese Felder mit dem MATCH-Element ebenfalls nicht überprüfen.


Wer weitergehende Prüfungen der Feldinhalte benötigt, muss sich wohl mit der TFS API auseinandersetzen. Eine Möglichkeit in einer standardisierten Form Erweiterungen für den TFS bereitzustellen, die serverseitig geprüft werden, bietet TFS ASAP. Mit dieser Plattform lassen sich Regeln ereignisbasiert (z.B. mit dem Speichern eines Work Items) sowie zeitgesteuert (z.B. einmal stündlich) ausführen. Dabei bietet sie bereits bewährte Mechanismen zur Integration serverseitiger Erweiterungen in den TFS. Im Falle der erweiterten Prüfung auf Textmuster mit regulären Ausdrücken könnte man beispielsweise eine E-Mail an den Verursacher versenden lassen oder die Änderung sogar wieder rückgängig machen. Mehr Informationen zu TFS ASAP sowie den Bezug einer Testlizenz gibt es unter http://www.tfsasap.com

ALM kompakt: Prüfung eines Work Item Feldes auf ein bestimmtes Textmuster is a post from: AIT Blog

ppedv Team Blog: Mehr Infos während Laufzeit oder Debug einer Web-Anwendung

Wer mit Visual Studio eine ASP.NET Anwendung schreibt, nutzt in der Regel den Debugger. Man kann aber auch Informationen über den Fluss in der Console ausgeben, sowohl server- als auch clientseitig.

Die Idee kam mir, während ich mit VB.NET Timer Code geschrieben habe und das Ticking beobachten wollte, ohne Breakpoints zu setzen. ASP.NET Servercode einfach mit

   1:   Debug.WriteLine("tick...")

Und schon tickt's im Visual Studio Output Window.


Mit JavaScript und diversen Frameworks wird das Thema noch schwieriger, weil Breakpoints manchmal in unüberschaubaren Code-Konstrukten enden. Auch hier kann man Log Messages ausgeben lassen und diese in den Developertools von Chrome oder IE mit F12 betrachten. Wer noch ein Alert verwendet, sollte schnellstens umstellen.

   1:    <script>
   2:          var myVar = setInterval(function () { myTimer() }, 1000);
   4:          function myTimer() {
   5:              console.warn("tick..");
   6:              console.log("tick...");
   8:          }
   9:      </script>


Im Internet Explorer 11:


dasselbe in Chrome:


Es existiert auch noch eine Methode Console.error mit dann rot gefärbter Ausgabe.

ppedv Team Blog: Auswertung zum StoragePool-Benchmark

Dies ist ein Update zu meinem vorherigen Beitrag über die Storage-Pools im Windows Server 2012 R2


Ich habe noch ein paar weitere Tests bezüglich der Storage-Pools gemacht und diese in einer Tabelle ausgewertet:



Zusammenfassend kann man hier nun also sehen:

  • In den lesenden Disziplinen ist ein “echtes” RAID0 mittels RAID-Controller und den beiden SSDs am schnellsten
  • In den schreibenden Disziplinen ist der Storage-Pool mit einem Simple-Laufwerk am LSI-Controller am besten – dabei auch deutlich schneller als das controllereigene RAID0 von LSI und HP mit den SSDs
  • Der direkte Vergleich zwischen den Storage-Pools am HP-Controller und am LSI-Controller geht erstaunlicherweise zu Gunsten des LSI-Controllers aus und dies auch durchweg, obwohl der LSI-Controller (im Gegensatz zum HP-Controller) über keinen eigenen Cache verfügt (mit aktiviertem BBWC würde der HP-Controller wohl beim Schreiben noch deutlich besser werden)
  • Geht es um Datenredundanz (hier also RAID1 o.ä.), dann ist der Storage-Pool im Mirror-Modus mit der Kombination HDD plus SSD am besten!
  • Ein Storage-Pool mit 2 HDDs im Mirror-Mode ist fast genau so gut (oder genau so schlecht) wie die RAID1-Implementierung des HP- oder des LSI-Controllers

ppedv Team Blog: Microsoft Azure: Wartungsarbeiten in der Region Westeuropa

An diesem Wochenende führt Microsoft Wartungsarbeiten an der Netzwerkhardware in den Rechenzentren der Region Westeuropa durch. Dabei wird es zu Reboots der virtuellen Maschinen kommen, die zwischen 30 und 45 Minuten dauern können. Betroffen davon sind Instanzen von virtuellen Maschinen und Clouddiensten. Die Wartungsarbeiten finden am Freitag ab 20 Uhr und am Samstag ab 20 Uhr statt. An einem Tag sind die virtuellen Maschinen betroffen, während am nächsten Tag die Clouddienste betroffen sind.

Wie Microsoft am Freitag Abend bekannt gab, werden die Wartungsarbeiten für die Region Nordeuropa am kommenden Wochenende (22./23.08) zu den selben Zeiten durchgeführt.

Martin Hey: Attribute in Metadaten prüfen

Heute wurde mir eine gute Frage zu einem Problem gestellt, das ich bisher als trivial abgetan habe: Wie ermittle ich in ASP.NET für eine Eigenschaft des Models, ob dort ein bestimmtes Attribut gesetzt ist? Solche Attribute (insbesondere die vom Typ ValidationAttribute) werden ja verwendet, um Eingabevalidierung vorzunehmen.

Einstiegspunkt soll eine ExtensionMethod auf HtmlHelper sein, wie man sie in ASP.NET häufig findet und die einfach nur einen Text in der Html-Seite ausgeben soll.
public static MvcHtmlString RequiredMark<TModel, TValue>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TValue>> expression)
    var required = expression.IsRequired();
    return new MvcHtmlString((!required ? "kein " : string.Empty) + "Pflichtfeld");
Spannender Teil daran ist jetzt die schon verwendete ExtensionMethod IsRequired, die für die eigentliche Magie zuständig ist. Diese ist auch noch recht trivial: Sie prüft die Eingabe und ruft die noch zu erstellende Methode HasAttribute auf, die dann die eigentliche Prüfung auf das gesuchte Attribute durchführt:
private static bool IsRequired<T, V>(this Expression<Func<T, V>> expression)
    var memberExpression = expression.Body as MemberExpression;
    if (memberExpression == null)
        throw new InvalidOperationException("Expression must be a member expression");

    return HasAttribute(memberExpression.Member, typeof(RequiredAttribute));
Auch diese Methode ist recht einfach implementiert - schließlich gibt es in der Klasse Attribute eine statische Methode IsDefined, die dafür verwendet werden kann:
private static bool HasAttribute([NotNull] MemberInfo memberInfo, [NotNull] Type attributeType)
    if (memberInfo == null)
        throw new ArgumentNullException();

    var isDefinedOnMember = Attribute.IsDefined(memberInfo, attributeType);

    return isDefinedOnMember;
Funktioniert super ..... Funktioniert super und deswegen hören hier die meisten Lösungsvorschläge in einschlägigen Foren auch schon auf.... Funktioniert super, so lange man das Attribut direkt auf dem Model definiert. Allerdings gibt es auch die Möglichkeit, Metadatentypen zu definieren, die dann die Attribute beinhalten. Das ist immer dann sinnvoll, wenn das eigentliche Modell automatisch generiert wird - aus einem Designer oder aus einem T4-Template.

Schauen wir uns ein Beispiel an:
public class MyViewModel
    public string Name { get; set; }
Dafür funktioniert die bisher erstellte Lösung. Aber bei dem folgenden Beispiel schlägt unsere Prüfung fehl:
public class MyViewModel
    public string Name { get; set; }

public class MyViewModelMetaData
    public string Name { get; set; }

Wie kann das Problem gelöst werden? Ganz einfach - zusätzlich zu der schon erstellten Prüfung auf direkt gesetzte Attribute muss nun noch dem Metadatenattribut auf dem Typ gefolgt werden und in diesem Typ geprüft werden welche Attribute auf dem gleichnamigen Member gesetzt sind:
private static bool HasAttribute([NotNull] MemberInfo memberInfo, [NotNull] Type attributeType)
    if (memberInfo == null)
        throw new ArgumentNullException();

    // hier prüfe ich direkt gesetzte Attribute
    var isDefinedOnMember = Attribute.IsDefined(memberInfo, attributeType);
    if (isDefinedOnMember)
        return true;

    // jetzt wird noch der Metadatentyp geprüft
    var type = GetMetadataType(memberInfo);
    if (type == null)
        return false;

    return type.GetProperties().Any(prop => prop.Name.Equals(memberInfo.Name, StringComparison.OrdinalIgnoreCase) && Attribute.IsDefined(prop, attributeType));
Nun liefert die erstellte Methode auch in diesem Fall korrekte Ergebnisse.

Happy coding.

friends header

bloggers headline

links header

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