ppedv Team Blog: Windows 8 Tipp – Windows in den Ruhezustand versetzen

Neulich wurde ich gefragt, ob es denn die Möglichkeit gäbe, den Rechner, wie in früheren Windows-Versionen, in den Ruhezustand zu versetzen. Ja. Zwar ist dieser nun in Windows 8 nicht mehr standardmäßig verfügbar, und doch lässt er sich wieder hervorzaubern.

Rufen Sie die Energieoptionen auf, indem Sie nach Betätigen der Windows-Taste auf dem Kachelbildschirm Energieoptionen eingeben, im Suchfeld wählen Sie diese Option aus.

clip_image002

Danach rufen Sie auf der linken Seite den Befehl: Auswählen, was beim Drücken des Netzschalters geschehen soll.

clip_image004

Um die Einstellung zu vervollständigen, klicken Sie jetzt im oberen Bereich des Fensters auf: Einige Einstellungen sind momentan nicht verfügbar.

clip_image006

Nun muss nur noch im unteren Bereich des Fensters die Option Ruhezustand aktiviert werden.

clip_image008

clip_image010

Nun können Sie wieder auf Wunsch den Ruhezustand aktivieren. Dies lässt sich wahlweise per Tastenkombination Windows-Taste + F4 oder per Windows-Taste und Klick auf das Ausschalten-Symbol vornehmen.

Stefan Lange: Surface Pro 3 Systempartition verkleinern

Gestern habe ich pünktlich zum angegebenen Liefertermin meinen Surface Pro 3 erhalten. Nach dem ersten Start hatte das System wie allgemein üblich nur eine Partition mit einer Größe von ca. 500GB. Da dies eher unpraktisch praktisch ist, wollte ich als erstes die Systempartition verkleinern. Leider konnte ich über die Datenträgerverwaltung die Größe der Partition zunächst lediglich auf ca. 320GB verringern.

Die richtige Vorgehensweise finde ich nicht so ganz logisch, daher hier die Kurzanleitung.

So verkleinert man das Systempartition

  1. BitLocker für Laufwerk C: aktivieren
    Auf dem Surface Pro 3 ist das System-Volume bereits im Auslieferungszustand verschlüsselt, wird aber beim Start von Windows automatisch freigegeben, wenn BitLocker noch nicht aktiviert wurde. Zum Deaktivieren von BitLocker muss man ihn aber erst mal aktivieren. Also über das Kontextmenü von Laufwerk C: „BitLocker aktivieren“ auswählen.
  2. Passwort festlegen
    Im nachfolgenden Wizard Passwort eingeben und ggf. den Wiederherstellungsschlüssel sichern. Die Aktivierung selbst benötigt keine weitere Rechenzeit, da das Volume ja bereits verschlüsselt ist.
  3. BitLocker deaktivieren
    Nach dem Aktivieren gibt es im Kontextmenü nun den Eintrag „BitLocker verwalten“. Diesen Punkt aufrufen und dann „BitLocker deaktiveren“ auswählen. Die Systempartition wird anschließend entschlüsselt, was ein wenig dauert.
  4. Volume verkleinern
    Nun kann man in der Datenträgerverwaltung „Volume verkleinern…“ aufrufen und die gewünschte Größe einstellen.
  5. Anschließend BitLocker wieder aktivieren.

Hintergrund

Vermutlich legt Bitlocker versteckte Dateien auf dem verschlüsselten Volume an. Da man versteckte Dateien nicht verschieben sollte, lässt sich die Partition mit Bordmitteln nur bis zu der Stelle verkleinern, wo diese Dateien liegen. Das Deaktivieren von BitLocker entschlüsselt das Volume, die Datei(en) verschwinden, das Verkleinern funktioniert.

Sven Hubert: Ideen für die Verwendung des MSDN Azure Freikontingents: Ein Blick auf die kommende Visual Studio Version

Spannende Zeiten kommen auf uns zu. Microsoft hat in der vergangenen Woche die dritte Community Technology Preview der kommenden Visual Studio Version bereitgestellt. Die Liste der Neuerungen ist lang. Besonders stechen vor allem ASP.NET vNext und .NET Native heraus. Da bekommt man gleich Lust die neuen Funktionen auszuprobieren. Wenn da der Aufwand für die Installation nicht wäre. Eine Einrichtung einer CTP auf dem lokalen System ist zu riskant. Das Aufsetzen einer virtuellen Maschine dauert zu lange. Gibt’s da nicht was Einfacheres? Klar! Unter Windows Azure steht für MSDN Abonnementen ein vorbereitetes Image zur Verfügung. In wenigen Minuten ist dieses eingerichtet

Falls noch nicht geschehen ist zunächst eine Freischaltung des Azure Zugangs im MSDN Portal notwendig. Danach ist Einrichtung eine Sache von wenigen Klicks.

Einrichtung des virtuellen Computers

Einrichtung des virtuellen Computers

Im Image Katalog steht die aktuelle Vorschauversion zur Verfügung.

Auswahl des Images

Da die Maschine nicht rund um die Uhr laufen wird, kann man bei der Wahl der Maschine großzügig sein. Ein virtueller Rechner mit 3,5 GB Arbeitsspeicher schlägt mit rund 12 Cent zu buche. Das MSDN Freikontingent erlaubt damit auch mehr als nur einen kurzen Blick.

Auswahl des Images

Die Einrichtung des Images benötigt ein paar Minuten. 

Verbinden mit der Maschine

Danach kann über den Remote Desktop auf den virtuellen PC und das Visual Studio zugegriffen werden.

Starten der CTP

Microsoft hat durch die Bereitstellung des Images eine schnelle und einfache Möglichkeit geschaffen die neuesten Technologien, ohne Beeinträchtigung des lokalen Systems, auszuprobieren. Dank dem MSDN Freikontingent zudem in den meisten Fällen kostenfrei.

Der frühe Blick ermöglicht es selbst einschätzen zu können wie das, was kommt, die eigenen Lösungen beeinflussen wird. Gleichzeitig erhält Microsoft ein frühes Feedback zu den gezeigten Lösungen.

Probieren Sie es aus. Es lohnt sich!

Ideen für die Verwendung des MSDN Azure Freikontingents: Ein Blick auf die kommende Visual Studio Version is a post from: AIT Blog

ppedv Team Blog: beste Sprecher

Bin aktuell am reflektieren, ob meiner erstmaligen Teilnahme bei der #NRWConf im September. Seit mindestens 15 Jahren spreche ich auf Entwickler Konferenzen.

TechEd, Basta, Synopsis, Microsoft Days, TechDays, Winsummit, TechTalk VSone, ADC, GUI&DESIGN, ICE Lingen, Developer Conference Hamburg, SDN Netherlands ...

image

Dazu veranstalten wir auch eigene Formate mit teilweise über 500 Teilnehmer wie SharePoint Conference, ADC++, ADC X, VSone, SQL Days und GUI&DESIGN.

Ich habe also hunderte Auftritte verfolgt. Viele waren gut, einige bodenlos, manche aber auch sensationell.

Es ist relativ einfach für die “geht gar nicht” Sprecher und Vorträge Ursachen zu nennen:

  • Samples gehen nicht
  • Vortrag endet viel zu früh
  • Spricht undeutlich
  • monoton
  • Inhaltlich völlig daneben
  • wirkt unvorbereitet

 

Die üblichen Rhetorik Tipps tauchen da nicht auf wie

  • schaut zur Wand
  • Körperhaltung
  • Füllwörter wie Äh..

Das mag in mittelmäßigen Session nicht stören.

Schwierig wird es herauszufinden was einen Top 1 Vortrag ausmacht. In unserem Team haben wir zwei Kollegen Martin und Andreas die in den Teilnehmerfeedbacks über mir liegen können. Martin hatte auf dem letzen Microsoft Server Summit den Top Vortrag im Teilnehmerranking. Ich war leider nicht dabei um zu analysieren warum. Aber andere #1 Sprecher und das passende Thema kenne ich.

  • Clemens Vasters zu .net Zeiten
  • Christian Weyer über WCF
  • Neno Loje speziell zu ALM
  • Ingo Rammer Debugging
  • Michael Willlers mit dem Finger in der Wunde
  • Rainer Stropek Live Coding
  • Don Box über SOAP
  • Scott Hanselman zu allem
  • Anders Hejlsberg zu C#

Dies nur als Auszug und hoffe damit niemanden vor dem Kopf zu stoßen, weil er in der Hannes Hit List nicht auftaucht.  Und da frage ich  mich jedes Mal, was ist denen gemeinsam. Alles Männer? Sonst wenig. Einzig die Begeisterung für Ihr Thema. Wobei bei Mr C# die durchaus verbergen kann, das ist eher ein religiöser Akt.

Ein durchaus häufiger Diskussionspunkt ist PowerPoint. Ich halte wenig von Zero Slides - just Code Vorträgen. Manches muss einfach auf skizziert werden. Didaktisch ist das natürlich super wenn man das live per Pen Eingabe tun kann, weil dann der Teilnehmer die Entstehung lernt, Kostet aber viel Zeit. Meine Regeln dazu:

  • Gut Lesbar bis zum letzten Platz
  • nichts wichtiges im unteren Bereich
  • weniger Text ist mehr
  • mind 2 Minuten pro Slide einkalkulieren

Konferenz Slides haben das Ziel, den Vortrag zu stützen und nicht als Lernunterlage zu dienen!

Softwareentwickler machen interessanterweise bessere Vorträge als IT Pros, wobei letztere durchaus aufgeholt haben. Es muss wohl am Code liegen. Da gibt's die Fraktion die das runter kodiert als wärs ein Maschinenschreibwettbewerb, die aus der Toolbar Drag&Dropper, die Code in PowerPoint und die ich habe ein fertiges Sample.

Demo Code sollte nie wesentlich länger als eine Bildschirmseite sein. Wenn möglich sollte man diesen tippen um den Zuseher mehr Einblick in die Entstehung zu gewähren. Variablen nenne ich immer möglichst sinn frei, wie Hannes. Ich bin als Teilnehmer oft verwirrt ob das nun eine Framework Funktion ist oder per Nuget Wunder erschienen ist oder sonst was. Das stört das lernen.

Und Code muss funktionieren. Also vorher ausprobieren. Live bug fixing kommt nur selten gut an. Man merkt das sofort am steigen Geräuschpegel im Auditorium. Plötzlich verspürt jeder Hustenreiz.

Vorträge müssen eine Geschichte erzählen. Anfang und Ende mit Höhepunkten drin. Wie prüft ich ob die Geschichte wirkt? Bei sehr großen Vorträgen wie TechEd gibt es sogenannte Reheasals. Also Probe vor kleinem Fachpublikum. Ich hasse das. Ich brauch das echte Publikum um mich entfalten zu können. Persönlich bin ich dazu übergegangen die Session per Camtasia ein oder auch mehrmals aufzuzeichnen. Mein persönlicher Review. Ich lade auch gerne Kollegen ein die Videos anzusehen. Dabei lernt man natürlich auch die Samples fehlerfrei runter zu tippen bzw. die Stolpersteine kennen.

Hab ich schon erwähnt? die Samples müssen laufen!

Dazu braucht es natürlich einwandfreier Technik. Immer die Adapter dabei haben, einen Presenter und externe Maus. Seit vielen Jahren nutze ich einen zweiten Monitor, der per USB angeschlossen wird. Ich verwende ein älteres Modell von MiMo. Die Kollegen setzen auf was größeres von Lenovo. Beide per USB ohne zusätzliche Stromversorgung nutzbar. PowerPoint 2013 zeigt dann die Notizen im zweiten Monitor an. In die Notes schreibe ich mir dann Zahlen, oder Namen rein die nicht unmittelbar geläufig sind und auf den Slides aus didaktischen Gründen keinen Sinn machen.

Früher hatte ich auch die Code Samples auf dem zweiten Screen per Notepad geöffnet. Heute nutze ich dafür wieder Papier. Für jede Demo ein Blatt in großer Schrift mit Textmarker Highlight auf Stellen in denen ich gerne Fehler mache. Z.B. typische Buschtabendreher oder fehlende Imports.

All das macht mich zu einem guten Sprecher. Wenn die Tagesform stimmt, es mein Thema ist und das Publikum mitzieht werde ich sehr gut. Aber noch nicht der Beste.

Auf meiner TechEd Teilnahme hatte ich eine lange Diskussion zum Thema. Spannend ist, das Sessions am ersten Tag schlechter bewertet werden. Am besten läuft's ab Tag 3 später Vormittag. Themen in denen neue Produkte und Features gezeigt werden haben #1 Potential. Oder Themen die so in die Tiefe gehen, das kaum mehr wer im Saal mitkommt.

Entertainment kommt immer gut an, will aber geübt sein. Ich hatte drei mal in meinem Leben die Chance ein Thema in einer Tour zu präsentieren. Bis zu 20 mal das selbe. Da kannst an jedem Wort feilen. Ist echt eine super Erfahrung. Witz und Ironie sind aber auch ein gefährliche Sache. Ich hatte in einem User Group Vortrag eine sehr dicke Frau in Leggings in meinen Slides. So etwas geht in Österreich und vielleicht Bayern. Wo anders hatte ich im Anschluß eine Beschwerde im Postfach. Über die ich übrigens sehr dankbar bin. Fettnäpfchen müssen raus, Weil eine 6 im Feedback reicht um dich von deinem #1 Ziel zu entfernen.

Und nicht vergessen: die Beispiele müssen 100% funktionieren.

Holger Schwichtenberg: Verlosung einer Freikarte für die BASTA!-Konferenz

Die wohl größte deutsche .NET-Konferenz findet vom 23. bis 25. September in Mainz statt.

Holger Sirtl: Serie: Eigene Anwendungen auf Microsoft Azure - Teil 6: Auswahl des besten Ausführungsmodells

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 nun auf die Frage ein, welches der Ausführungsmodelle in welcher Situation das bestgeeignete ist.

Alternative Ausführungsmodelle

In der ersten Teilen dieser Blog-Serie wurden die vier Modelle vorgestellt, die unter Azure zur Ausführung eigener Anwendungen oder Anwendungsteile zur Verfügung stehen:

  • Virtual Machines
    zur Ausführung eigener oder vorgefertigter persistenter virtueller Maschinen nach dem Infrastructure-as-a-Service Ansatz (IaaS).
  • Cloud Services
    zur Ausführung ein- oder mehrschichtiger Cloud Apps in automatisiert verwalteten nicht-persistenten virtueller Maschinen zweierlei Arten (Web oder Worker Roles) nach dem Platform-as-a-Service Ansatz (PaaS).
  • Websites
    zum Hosting eigener Web-Anwendungen in automatisiert bereitgestellten, skalierbaren Umgebungen, die mit unterschiedlichen Runtimes (ASP.NET, PHP, Node.JS, Java, …) und Frameworks (Wordpress, …) vorkonfigurierbar sind.
  • Mobile Services
    zur schnellen Bereitstellung von Backends für mobile Anwendungen verschiedener Plattformen (Windows Phone, Windows Store, iOS, Android, …) auf Basis der Websites Plattform nach dem Backend-as-a-Service Ansatz (BaaS).

Bereits die Kurzbeschreibung der einzelnen Modelle gibt hinweise darauf, wann welches Modell das bestgeeignete ist.

Vergleich der wichtigsten Funktionalitäten

Letztlich kommt es häufig auf einzelne Features und Funktionalitäten an bzw. darauf, in welchem Modell diese verfügbar sind, welches Ausführungsmodell für ein konkretes Implementierungsvorhaben verwendet werden sollte. Folgende Tabelle gibt einen Überblick über die Verfügbarkeit einzelner Funktionalitäten in den einzelnen Ausführungsmodellen (sie ist ein Ausschnitt aus der etwas umfangreicheren Tabelle in der Azure-Dokumentation):

Feature Websites und
Mobile Services
Cloud Services
(Web Role)
Virtual Machines
Zugang zu weiteren Azure Services
(Service Bus, Storage, SQL Database)
Betrieb einer Web-Tier oder Webservice-Tier mehrschichtiger Anwendungen
Betrieb einer Middle-Tier mehrschichtiger Anwendungen  
Integrierter My-SQL-as-a-Service Support
Mehrere Deployment-Umgebungen (Staging und Produktion)  
Scale-Up ohne Redeployment    
Unterstützung eines Virtual Networks  
Unterstützung für den Traffic Manager
Remote Desktop Zugang zu den virtuellen Maschinen  
Linux als Gast-OS    
.NET-Unterstützung
Java-Unterstützung (●)
PHP-Unterstützung (●)
Automatisches Einspielen von Gast-OS-Upgrades und -Patches  
Nahezu sofort verfügbares Deployment    
Code-Deployment aus TFS
Code-Deployment aus GIT, FTP (●)
Remote Debugging

● = verfügbar, (●) = kann implementiert werden

Dabei sollte nicht vergessen werden, dass sich die Modelle problemlos kombinieren lassen. D.h. es ist leicht möglich, eine in einer Website betriebene Web-Anwendung auf einen in einer Virtual Machine betriebenen Datenbankserver (SQL Server, MySQL, Oracle, …) zugreift.

Szenarien

Für einige Szenarien können recht einfach erste Empfehlungen für die Ausführungsoption genannt werden (detailliertere Beschreibung in Teil 1 dieser Serie):

Szenario Naheliegende
Ausführungsoption
Hosting einer ASP.NET- oder PHP-basierten Webseite Websites
Betrieb einer bestehenden Linux-basierten LOB-App Virtual Machines
Bereitstellung eines REST-Backends für mobile Anwendungen Mobile Services
Cloud-Anwendung, die auf Ressourcen im lokalen Unternehmensnetzwerk zugreifen soll Cloud Services oder
Virtual Machines

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.

Fazit

Mobile Services sollten immer dann gewählt werden, wenn…

  • für Mobile Anwendungen Backend-Dienste bereitgestellt werden sollen, da hier die Entwicklerproduktivität mit Abstand am höchsten ist.

Websites sollten immer dann gewählt werden, wenn…

  • es keinen entscheidenden Grund dagegen gibt

Cloud Services sollten immer dann gewählt werden, wenn…

  • die Vorteile einer automatisch verwalteten Umgebung im Sinne eines PaaS-Ansatzes sollen genutzt werden sollen.
  • die Flexibilität eines direkten Zugriffs auf die virtualisierte Umgebung (d.h. administrativer Zugriff auf einzelne Instanzen) benötigt wird
  • Skalierung ggf. auch nur in einzelnen Rollen erfolgen soll.
  • die Anwendungslogik (aufgrund der nicht-persistenten Instanzen) zustandslos implementiert werden kann (Persistenz selbst implementiert wird).

Virtual Machines sollten immer dann gewählt werden, wenn…

  • Linux als Gast-OS für die eigene Anwendung benötigt wird
  • die eingesetzten virtuellen Maschinen automatisch (in Blob Storage) persistiert werden sollen.
  • Es werden administrativer Zugriff und entsprechende Konfigurationsmöglichkeiten benötigt

Natürlich sind dies alles nur erste Hinweise. Die hier angeführten Gründe stellen keinen Anspruch auf Vollständigkeit. An dieser Stelle sei nochmals wiederholt:

  • Die Ausführungsmodelle lassen sich miteinander kombinieren.
  • Ein Wechsel des Ausführungsmodells ist möglich (aber ggf. mit etwas Aufwand verbunden).

Weitere Informationen

Alexander Schmidt: Endlich! Das Surface Pro 3 ist da!

Bestellt war es schon lange und heute kam endlich das unscheinbare Päckchen an. Hier meine ersten Eindrücke. Pünktlich zum avisierten Termin kam heute nachmittag das neue Teil ins Büro geschneit. Es waren auch gleich genügend fachkundige Personen um mich versammelt, damit das Auspacken zu einer großen und vor allem von allerlei nützlichen und unnützen Kommentaren […]

Holger Schwichtenberg: Analyse: .NET wird zunehmend modularer

In einer kommenden .NET-Variante besteht auch das Framework selbst aus mehreren Softwarekomponenten.

Holger Sirtl: Serie: Eigene Anwendungen auf Microsoft Azure - Teil 5: Mobile 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 Mobile Services ein.

Konzept der Mobile Services

Mobile Services bauen auf der Website Plattform auf. Während Websites auf ganz allgemeine Web-Anwendungen abzielen, gehen Mobile Services eine Abstraktionsebene höher: Mobile Services sind spezielle Websites, die für den Einsatz als Backend für Mobile Anwendungen optimiert sind und damit eine sehr schnelle Umsetzung ermöglichen. Mitunter werden Mobile Services aufgrund dieser Eigenschaft der Servicekategorie BaaS (= Backend-as-a-Service) zugeordnet.

Mobile Anwendungen, d.h. leichtgewichtige Anwendungen, die auf mobilen Endgeräten ausgeführt werden, sind häufig über Backend-Services vernetzt. Über diese Dienste tauschen die einzelnen Clients Daten aus, speichern Daten, führen Authentifizierung durch etc. Microsoft Azure Mobile Services bieten eine Sammlung genau solcher, häufig benötigter Dienste auf Microsoft Azure an. Zu diesen Diensten gehören unter anderem folgende Funktionen:

  • Benutzerauthentifizierung (via Microsoft Account, Facebook, Twitter und Google ID) mit entsprechender Zugriffskontrolle bei Service-Aufrufen
  • Speicherung von Daten in Blob, Table, Queue Service oder SQL Database
  • Kommunikation via Service Bus
  • Push Notifications
  • Zeitgesteuerte Ausführung serverseitiger Skripte

Darüber hinaus ist es möglich, neben den Daten-basierten Schnittstellen (für das Schreiben, Lesen, Ändern, Löschen von Daten) eigene Schnittstellen mit in .NET oder JavaScript implementierter Funktionalität implementieren.

Die vorkonfigurierten Microsoft Azure Mobile Services können ohne größeren Programmieraufwand sehr einfach als Backend-Dienste für verschiedene Client-Umgebungen eingesetzt werden. Folgende Tabelle gibt einen Überblick über die derzeit unterstützten Client-Umgebungen und darüber, mit welcher Backend-Variante (.NET und/oder JavaScript) diese eingesetzt werden können.

Client-Umgebung Mobile Service in
JavaScript
Mobile Service in
.NET
iOS
Windows Phone
Windows Store C#
Windows Store JavaScript
Xamarin iOS
Xamarin Android
Android
HTML  
PhoneGap  
Sencha  
Appcelerator  

Es können Vorlagen für entsprechende neue Apps oder Code Fragmente für bestehende Apps aus dem Portal heruntergeladen werden. Die Entwicklung einfacher mobiler Anwendungen, die Cloud Dienste nutzen sollen, vereinfacht sich dadurch deutlich. In vielen Fällen können per Copy-Paste Datenbankzugriffe in der betreffenden Client-Umgebung implementiert werden.

Entwicklung von Mobile Services

Mobile Services basieren auf Websites. Die Implementierung kann entweder über JavaScript (dann wird als Grundlage eine vorkonfigurierte Node.js-Installation verwendet) oder über .NET (C#) (dann wird eine vorkonfigurierte ASP.NET-Umgebung als Grundlage verwendet) erfolgen. Bei der JavaScript-Variante können die Funktionalitäten direkt über das Portal eingegeben werden. Für einfachere Szenarien ist dies ideal.

Im Falle von .NET kann vom Portal eine Visual-Studio-Solution heruntergeladen werden. Diese basiert letztlich auf einer Website-Anwendung, d.h. sie enthält sämtlichen Code, der dann in Form eines Mobile Service ausgeführt wird. Damit hat ein Entwickler stärkere Eingriffsmöglichkeiten in die internen Abläufe. Die Solution kann (z.B. zu Testzwecken) auch lokal ausgeführt werden und dann via WebDeploy in einen Mobile Service auf Azure deployt werden.

Fazit

Rein technisch gesehen, können die von Mobile Services abgedeckten Funktionalitäten auch mit Websites umgesetzt werden. Während bei Websites jedoch gewisser Programmieraufwand anfällt, wird dieser bei Mobile Services minimiert. In vielen Fällen können Backend-Zugriffe mit vorgefertigten Code-Fragmenten per Copy-Paste implementiert werden. Daher gilt die Regel:

  • Wenn für Mobile Anwendungen Backend-Dienste bereitgestellt werden sollen, sind Mobile Services erste Wahl, da hier die Entwicklerproduktivität mit Abstand am höchsten ist.

Für Funktionalitäten, die über Mobile Services nicht umgesetzt werden können, lassen sich Mobile Services mit anderen Ausführungsmodellen (Websites, Cloud Services, Virtual Machines) kombinieren.

Weitere Informationen

Informationen zu Mobile Services

Informationen zur allgemeinen Entscheidung für ein Ausführungsmodell

codefest.at [MS]: Modern meets Retro – Game Development Challenge

Es ist endlich soweit!!!

Aufmerksame Codefest-Leser haben es wahrscheinlich schon kommen sehen: Die große Challenge für das Thema Game Development kommt mit super-coolen Preisen. Diese Challenge besteht aus zwei weitgehend unabhängigen Teilen:

  • Teil A der Challenge: Game Development Contest
  • Teil B der Challenge: Gaming Hackathon

Die Details zu den beiden Teilen findet Ihr in diesem Post weiter unten.

Die Challenge beginnt absichtlich erst in den nächsten Wochen. Dafür werdet Ihr hier ab sofort laufend wichtige Tipps und Tricks vorfinden mit denen Ihr Euch bestens auf den kommenden Wettbewerb vorbereiten könnt. Stay tuned!

 

Coole Sache! Let’s Do This – but where to start?

Wir haben bereits begonnen einige Artikel zu posten, die euch den Anfang erleichtern, in die Welt der Spiele-Entwicklung zu kommen. Wir haben in den nächsten Wochen vor weitere Posts zu diesem Thema herauszubringen. Ihr könnt auch immer wieder in diesem Post nachschauen, um eine aktuelle Liste aller Posts zu sehen.

Bisher erschienen:

 Codefest-Promo-Lang-01

Teil A der Challenge: Game Development Contest

 22. September – 31. Oktober 2014

Entwickelt ein Spiel und veröffentlicht es in dem Zeitraum vom 22. September bis 31. Oktober in den Windows und/oder Windows Phone Store. Schickt den Link eures eingereichten Spiels, mit dem ihr teilnehmen möchtet, an AppsAT@microsoft.com. Ihr habt die Wahl, welche Spiele-Engine ihr für die Entwicklung verwenden möchtet.

Die besten eingereichten Spiele werden am 9. Dezember ermittelt und bekommen einen Preis. Als Auswahlkritieren werden die Downloadzahlen und Ratings im Windows / Windows Phone Store herangezogen.

Contest Preise:

  • 1 XBox 360
  • 2 Xbox One Spiele (Watch Dogs), im Wert von je 50 €
  • 3 PC-Spiele (Watch Dogs), im Wert von je 50 €
  • 10 Lizenzen für das PC-Spiel Panzer Tactics HD, im Wert von je 30 €

Weiters gibt es einen (zusätzlichen) Sonderpreis für die 10 besten Spiele, die mit der Crossplattform Engine V-Play entwickelt. V-Play vergibt 10 Indie-Lizenzen im Wert von jeweils 250 €, die für ein Jahr gelten!

 

Teil B der Challenge: Gaming Hackathon

10. – 12. Oktober 2014

Anmeldelink

Ihr könnt die Spiele natürlich vor Ort bei uns entwickeln. Wir haben ein tolles Programm mit Game Developern aus der österreichischen Spieleentwicklungsindustrie für euch vorbereitet, damit ihr einen guten Einstieg die Welt der Spiele-Entwicklung bekommt.

Das Programm besteht aus folgenden Vorträgen/Workshops:

Zusätzlich gibt es auch hier einen Hackathon Contest. Die besten Spiele, die bei diesem Hackathon in den Store eingereicht werden, gewinnen einen Preis. Alle Developer/Teams, die teilnehmen, können 3 Minuten lang ihr Spiel pitchen und das Publikum wählt die Gewinner.

Hackathon Preise:

Wenn ihr zum Hackathon kommen wollt, dann könnt ihr euch schon jetzt hier anmelden.

Ihr könnt Euch selbst aussuchen, ob ihr nur einen Teil oder beide Teile der Challenge macht. Ihr könnt mit einem Spiel an beiden Challenges mitsamt der Sonderpreis-Kategorie teilnehmen und auch jeweils mehrere Spiele einreichen.

Zusätzlich bieten wir für die besten Spiele Promotionmöglichkeiten durch unsere lokalen Social Media und Marketingkanäle an.

Wir freuen uns schon, eure witzigen und coolen Spiele zu sehen und wünschen euch natürlich viel Spaß bei der Challenge!

Holger Sirtl: Neuerungen in Microsoft Azure: allgemeine Verfügbarkeit der neuen SQL Database Editionen mit gesenkten Kosten und verbesserten SLAs

Microsoft hat heute im Bereich SQL Database einige Neuerungen und Bekanntmachungen veröffentlicht. Folgende Punkte gibt es auf dem offiziellen Azure-Blog zu lesen:

  • Die Service-Tiers Basic, Standard und Premium erhalten den Status der allgemeinen Verfügbarkeit. Damit sind entsprechende SQL Databases produktiv nutzbar und erhalten vollen Support.
  • Kostensenkungen für Premium und Standard Tiers. Die Preise, die ab GA gelten, liegen 50% unter den bisher für GA kommunizierten Preisen.
  • Neues Performance Level S0. Innerhalb des Standard Tiers gibt es mit S0 ein neues Level für Einstiegsszenarien. Innerhalb der Service Tiers kann flexibel zwischen den Levels gewechselt werden, um auf Lastschwankungen reagieren zu können. Die einzelnen Performance Level beschreiben minimale Durchsatzraten, die jeweils garantiert werden.
  • Stundengenaue Abrechnung. Für die neuen Service Tiers stellt Microsoft die Abrechnung auf stundengenaue Erfassung (war bisher tagesgenau) um. Damit können die Kosten besser der anliegenden Last angepasst werden.
  • Erhöhte Verfügbarkeitsgarantie von 99,99% für die neuen Service Tiers.

Darüber hinaus wurde bekanntgegeben, dass die ���alten” Editionen (Web und Business) noch etwas länger verfügbar sind und unterstützt werden als bisher geplant. Sie werden noch bis September 2015 verfügbar sein und damit bis genau ein Jahr nach Einführung der neuen Editionen.

Zusammenfassung der verfügbaren Dienst Editionen

SQL Database wird in drei Editionen angeboten: Basic, Standard und Premium. Basic eignet sich als kostengünstige Alternative für geringere Lasten und Datenbankgrößen bis 2 GB, Standard bietet höhere Transaktionsleistungen für Datenbanken bis 250 GB und Premium garantiert höchste Performanz- und Transaktionsleistung bei Datenbanken bis 500 GB. Zwischen den Editionen kann zur Laufzeit einfach gewechselt werden, so dass auf Änderungen in den Lastanforderungen reagiert werden kann.

Folgende Tabelle gibt einen Überblick über die aktuell verfügbaren Editionen. Weitere Informationen (und in Kürze die aktuellen Euro-Preise auf der Azure-Website zu SQL Database.

Basic Standard Premium
Uptime SLA 99,99% 99,99% 99,99%
Maximale DB-Größe 2 GB 250 GB 500 GB
Wiederherstellung innerhalb 24 Std. innerhalb 7 Tage innerhalb 35 Tage
Disaster Recovery Restore in eine andere Region Geo-Replikation mit passivem Replikat Aktive Geo-Replikation mit bis zu 4 lesbaren Replikaten
Preise für bestimmte Performance Level Basic = $4,99 S0 = 15$
S1 = 30$
S2 = 75$
P1 = 465$
P2 = 930$
P3 = 3.720$
DTU Basic = 5 S0 = 10
S1 = 20
S2 = 50
P1 = 100
P2 = 200
P3 = 800

Allgemeiner Überblick zu SQL Database

Mit SQL Database verfügt Microsoft Azure über eine echte relationale Datenbank als Cloud Service. Diese ist schnittstellenkompatibel zu SQL Server. Damit ist es möglich, SQL Database über bekannte Technologien (z.B. Entity Framework, ADO.NET, JDBC) und Werkzeuge (z.B. SQL Server Management Studio) zuzugreifen. In vielen Fällen reicht es aus, die Adressierung der anzusprechenden Datenbank über den Connection String zu einer entsprechenden Cloud Datenbank vorzunehmen.

Funktional bildet SQL Database eine Teilmenge von SQL Server ab. Zur Verfügung stehen die bekannten Datenbankkonstrukte wie Tabellen, Views, Joins, atomare Transaktionen, Datenintegrität bei konkurrierenden Zugriffen etc. Ebenso wird die SQL Sicherheitsarchitektur mit der Möglichkeit unterstützt, Benutzer anzulegen und diesen Berechtigungen zu vergeben. Auf MSDN gibt es einen guten Artikel, der Azure SQL Database und SQL Server gegenüber stellt.

Weitere Informationen

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.

Installation

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.

Conclusion

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:

Fazit

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();

   4:

   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:

DateTime.Now.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff''Z");

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>

  14: </TRANSITION>


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>

  29:


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:         },

   8:

   9:         "value": "Active"

  10:     },

  11:     {

  12:         "field": {

  13:             "refName": "System.Reason"

  14:         },

  15:

  16:         "value": "Validation Test Failed"

  17:     },

  18:     {

  19:         "field": {

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

  21:         },

  22:

  23:         "value": "Jakub Sabacinski"

  24:     },

  25:

  26:     {

  27:         "field": {

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

  29:         },

  30:

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

  32:     },

  33:     {

  34:         "field": {

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

  36:         },

  37:

  38:         "value": null

  39:     },

  40:     {

  41:         "field": {

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

  43:         },

  44:

  45:         "value": null

  46:     },

  47:     {

  48:         "field": {

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

  50:         },

  51:

  52:         "value": null

  53:     },

  54:     {

  55:         "field": {

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

  57:         },

  58:

  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.
].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)})(window,document,’script’,’//www.google-analytics.com/analytics.js’,’ga’);ga(‘create’, ‘UA-53295572-3′, ‘auto’);ga(‘send’, ‘pageview’);

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.

httpatomoreillycomsourcemspgermanyimages1818902.png

 

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

Hinweis

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.

image

Abb 1: schematischer Aufbau einer Website
(Quelle:
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.

Fazit

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.

 

Batarang

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

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

Batarang

 

Mehrere Browser zusammen verwenden

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

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

 

Plunker

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

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

Plunker

 

ngMock

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

 

ngAnimate

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

 

Animate.css

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

 

Jasmine

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

 

Fazit

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

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


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?

Irrgarten

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.

clip_image002

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

clip_image003

Öffnen Sie hierfür links den Ordner:

HKEY_CURRENT_USER\Control Panel\Mouse -> MouseHoverTime

 

clip_image005

Ä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:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Taskband

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

clip_image007

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

clip_image009

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

clip_image002

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

clip_image004

Klicken Sie auf Weiter

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

clip_image006

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

clip_image012

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.

clip_image013

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.

Fertig!

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.

image

Abb 1: schematischer Aufbau eines Cloud Service
(Quelle:
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.

Fazit

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.

image

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.

image

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);

task.Start();

task.Wait();

}

}

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

{

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

{

ProcessData();

}

}

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

{

Parallel.For(0, runs, i =>

{

Task task = new Task(ProcessDataAsync);

task.Start();

task.Wait();

});

}

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

{

Parallel.For(0, runs, i =>

{

ProcessData();

});

}

Console.ReadKey();    }

static async void ProcessDataAsync()

{

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

System.Threading.Thread.Sleep(1);

int x = await task;

}

static void ProcessData()

{

System.Threading.Thread.Sleep(1);

}

}

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.

image

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.

Fazit

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">
        <legend>Sign-In</legend>

        <div class="form-group">
            <label for="name"
                   class="col-sm-2 control-label">
                User name:
            </label>
            <div class="col-sm-10">
                <input type="text"
                       class="form-control"
                       name="name"
                       id="name"
                       placeholder="User name">
            </div>
        </div>
        <div class="form-group">
            <div class="col-sm-offset-2 col-sm-10">
                <button type="button"
                        id="signout"
                        class="btn btn-default pull-right"
                        disabled="disabled">Sign-out</button>
                <button type="button"
                        id="signin"
                        class="btn btn-primary pull-right">
                    Sign-in
                </button>
            </div>
        </div>
    </fieldset>
</form>

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"
              disabled="disabled">
        <legend>Chat</legend>

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

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

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';
    $('#chatarea').append(messate);
};

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);
    $('#name').val('');
};

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!');
            return;
        }

        chatter.server
            .signIn($.connection.hub.id, name);
    });

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

        chatter.server
            .signOut($.connection.hub.id, name);
    });

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

        chatter.server
            .post($.connection.hub.id, message);
        $('#message').val('');
        $('#message').focus();
    });
};

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 () {
        enableChat();
    },
    postMessage: function (message) {
        addMessage(message);
    },
    userRemoved: function () {
        disableChat();
    }
});

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(
       "SoftDeleteColumnName",
        (type, attributes) => attributes.Single().ColumnName);

modelBuilder.Conventions.Add(conv);

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
                    .MetadataProperties
                    .Where(p => 
                        p.Name.EndsWith("customannotation:SoftDeleteColumnName"))
                    .FirstOrDefault();

        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(
                tree.MetadataWorkspace,
                tree.DataSpace,
                newQuery);
        }

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

                var setClause =
                    DbExpressionBuilder.SetClause(
                            DbExpressionBuilder.Property(
                                DbExpressionBuilder.Variable(
                                    deleteCommand.Target.VariableType, 
                                    deleteCommand.Target.VariableName),
                                column),
                            DbExpression.FromBoolean(true));

                var update = new DbUpdateCommandTree(
                    deleteCommand.MetadataWorkspace,
                    deleteCommand.DataSpace,
                    deleteCommand.Target,
                    deleteCommand.Predicate,
                    new List { setClause }.AsReadOnly(),
                    null);

                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 = 
                SoftDeleteAttribute.GetColumnName(expression.Target.ElementType);

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

            return DbExpressionBuilder.Filter(
                binding,
                DbExpressionBuilder.NotEqual(
                    DbExpressionBuilder.Property(
                        DbExpressionBuilder.Variable(
                                binding.VariableType, binding.VariableName),
                        columnName),
                    DbExpression.FromBoolean(true)));
        }
        else
        {
            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.

Fazit

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
   2:   
   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
  11:   
  12:   
  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
  21:   
  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
   2:   
   3:  Public Class modellContext
   4:      Inherits DbContext
   5:   
   6:      Public Sub New()
   7:          MyBase.New("name=modellContext")
   8:      End Sub
   9:   
  10:      Public Property chatmessage As System.Data.Entity.DbSet(Of chatmessage)
  11:      Public Property room As System.Data.Entity.DbSet(Of room)
  12:   
  13:  End Class

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

image 

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.

image

Ist die Datenbank nicht vorhanden, legen wir sie an.

image

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.

image

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:

http://www.ppedv.de/schulung/kurse/AdoNetEF_Entity%20Framework_EntityDataModels_EDM_Framework_%204.0_WPF_WCF.aspx

http://www.ppedv.de/schulung/kurse/SQL-Performance-Optimierung-Sicherheit-Indizes-Verwaltung-Komprimierung-Verbesserung.aspx

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
Services
Websites Mobile
Services
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
Ausführungsoption
Grund
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
(http://de.wikipedia.org/wiki/WebSocket)

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

Setup

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>
    @Scripts.Render("~/bundles/chatter")
}

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

[Update]

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(
            "~/Scripts/jquery-{version}.js",
            "~/Scripts/jquery.signalR-{version}.js"));

[/Update]

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.

[HubName("chatter")]
public class ChatHub : Hub
{
    private readonly Chatter _chatter;

    public ChatHub() :
        this(Chatter.Instance)
    {
    }

    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).userAdded();
    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)
{
    Users.Remove(connectionId);
    Clients.Client(connectionId).userRemoved();
    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:

image

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

image

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

image

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" 
ItemType="Concorde.room"
   7:                      SelectMethod="roomlist_GetData">
   8:                      <ItemTemplate>
   9:                          <a href='/chat#<%#HttpUtility.UrlEncode(Item.roomname)%>'>
  10:                              <%#Item.roomname%>
  11:                          </a>| 
  12:                  
  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('/', ''); };
  11:       
  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:      };
  24:   
  25:  });
  26:   

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!!!

image

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

Hier nochmal die wichtigsten Eckdaten

Microsoft Technical Summit

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

Ort:
Best Western Premier Hotel MOA Berlin
Stephanstrasse 41
10559 Berlin Moabit

Web:
www.technical-summit.de

Ich hoffe, wir sehen uns da!!!

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

Einleitung

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:

http://www.discountasp.net/tfs/

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

image_thumb1

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/

image_thumb30

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.

image_thumb32

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:

image_thumb17

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.

image_thumb18

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.

image_thumb22

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.

image_thumb25

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.

image_thumb11image_thumb14

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.

image_thumb10image_thumb23image_thumb24

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!

Zusammenfassung

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" /> 
</Documentation>

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"/> 
</StaticCodeAnalysis>

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.

clip_image001

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.

clip_image002

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

clip_image003

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

clip_image005

Fertig

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.

image

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.

image

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.

friends header

bloggers headline

links header

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