Am 4. April findet das nächste CloudCamp in Wien statt und im Gegensatz zum letzten CloudCamp, das Ende letzten Jahres in St. Pölten stattgefunden hat, gibt es diesmal auch einen Vorschlag für die Agenda. Proposed agenda: 15:45 Gathering & Open Space introduction 16:00 Cloud Computing 101, Alexander Wöhrer (FH St. Pölten) and Mario Meir-Huber (Codeforce) 16:20 Cloud for CIOs, Damianos Soumelidis (HEXA) 16:40 Hybrid Cloud Architectures, Sam Johnston (Equinox) 17:00 Service integration, Thomas Kunz (ATOS) 17:15 Topic finding for parallel sessions 17:30 Group phase 1 18:45 Buffet & networking 19:45 Group phase 2 21:00 Wrap up Social Event @ TBD Wie aus der Agenda ersichtlich ist, bleibt jedoch genügend Raum für spontan gefundene Themen, so wie wir es auch beim letzten Mal gemacht haben, als ich für eine Gruppe von ca. 10 Personen ein quasi Hands-On-Lab für Windows Azure improvisiert habe. Derartiges rund um Windows Azure ist natürlich auch diesmal wieder möglich, wenn sich genügend Interessenten finden. Also Ideen, Fragen und Notebooks mitnehmen und nicht auf die aktivierte Windows Azure Subscription vergessen. Ressourcen: Anmeldung zum CloudCamp Vienna hier Windows Azure Infos Windows Azure Free-Trial oder MSDN Azure Benefits

Cool war’s, obwohl mir heiß war *gg* . Am 15. März 2012 fand, im Rahmen der zwei Wochen zuvor bereitgestellten Visual Studio 11 Beta, Katapult.me unser lokaler Visual Studio 11 Beta Launch statt. 154 Teilnehmer und Teilnehmerinnen vor Ort und 50 Online-Gäste waren live dabei als erstmals in Österreich Visual Studio 11 Beta vorgestellt wurde. Wir (Michael Köster, Gerwald Oberleitner und ich) haben uns gefreut euch über die aktuelle Dinge rund um Visual Studio 11 Beta zu informieren. Für die Teilnehmer und Teilnehmerinnen gab es interessante Sessions, farbenfrohe T-Shirts, Bücher und einen Zugang zur TFS Service Preview. Die Slides und auch das Cheat Sheet für die Visual Studio Shortcuts gibt es online zum Download auf der Katapult.04 Website. Wer die Sessions live verpasst hat kann sie sich auf http://katapult.tv ansehen: Was gibt es Neues in Visual Studio 11? Agile Entwicklung mit Visual Studio 11 und TFS 11 Team Zusammenarbeit mit Visual Studio 11 Manuelles und Automatisiertes Testen mit Visual Studio 11 Tipps & Tricks zur effektiveren Nutzung von Visual Studio 11 Carpe Diem – Lebe den Tag – Mit Visual Studio 11 einfach früher nach Hause gehen Viel Spaß mit Visual Studio 11 Beta wünscht euch Andreas Pollak Product Marketing Manager Visual Studio & Expression ACHTUNG – SONDERANGEBOTE – NUR KURZE ZEIT,…

Unlängst ist eine überarbeitete Version des Leitfadens für Windows Azure Service Bus für Software Entwickler von Alan Smith zur Verfügung gestellt worden. Hinzugekommen sind u.a. auch ein Kapitel über die neuen Features des Service Bus, die mit der September 2011 Release hinzugefügt wurden. Der Leitfaden ist weiterhin kostenlos und kann hier heruntergeladen werden.

Hier etwas für’s Wochenende zum Spielen . Brian Keller hat auf seinem Blog darüber informiert, dass er das Hyper-V Image für Visual Studio 11 Beta aktualisiert hat. Ebenso wurden die Hands-on-Labs und die Demoscripts auf den aktuellen Stand gebracht. Hier findest die Beschreibung, die Labs und den Download des Visual Studio 11 Beta ALM Hyper-V Images . Limitierungen Dieses Image ist eine virtuelle Hyper-V Maschine und funktioniert auf einem Windows Server 2008 x64 (Windows Server 2008 R2 SP1 wird empfohlen). Virtual PC wird nicht unterstützt, da VPC keine 64-Bit Guest Systeme unterstützt. Brian hat noch nicht versucht dieses Image auf Windows 8 consumer preview zu hosten, wird aber einen Update auf seinem Post dazu veröffentlichen. Die Systemzeit dieser Maschine wird beim Starten automatisch auf den 15. Februar 2012 eingestellt. Das ist für die Projekt Management Hands-on-Labs notwendig. Wenn Du mit dieser virtuellen Maschine über die Hands-on-labs hinaus Visual Studio 11 Beta testen möchtest kannst du diese Einstellung deaktivieren: (Task Scheduler -> Task Scheduler Library -> Set Date and Time -> Right-Click -> Disable) Es empfiehlt sich das beigefügte Dokument “Working with…” zu lesen, welches wichtige Instruktionen zur Verwendung enthält. Enthaltene Hands-on-Labs für Visual Studio 11 Beta Agile Project Management in Team Foundation Server 11 Building the Right Software - Generating Storyboards and Collecting Stakeholder Feedback with Visual Studio 11 Diagnosing Issues in Production with IntelliTrace and Visual Studio 11 Exploratory Testing and Other Enhancements in Microsoft Test Manager 11 Making Developers More Productive with Team Foundation Server 11 Unit Testing with Visual Studio 11 - MSTest, NUnit, xUnit.net, and Code Clone Andreas Pollak Product Marketing Manager Visual Studio & Expression Jetzt Visual Studio 11 Beta herunterladen und zukünftig früher heimgehen,…

Die bereits letzte Woche angekündigte Visual Studio 11 Beta wurde soeben zum Download bereitgestellt. Dank der Unterstützung bestehender Projekte (ohne Konvertierung!) können Sie mittels der "Go-Live" Lizenz Visual Studio 11 bereits jetzt produktiv in ihren Projekten einsetzen und können von den vielen Verbesserungen profitieren. Katapult.me & Visual Studio 11 Beta Launch Stay tuned und erleben Sie mit uns unseren österreichischen Visual Studio 11 Beta Launch Event am 15. März live auf Katapult.TV Am 15.03.2012, ab 10:00 Uhr LIVE auf Katapult.TV. Visual Studio 11 Beta ist nachhaltig und zukunftsorientiert. Visual Studio 11 investiert weiterhin in bereits bestehende Technologien wie Windows Forms, WPF, MFC,… und bietet hier erstklassige Unterstützung. Darüber hinaus bietet Visual Studio die besten Tools für die Entwicklung von Webapplikationen mit HTML 5, CSS 3 oder moderner Metro-Style Anwendungen unter Windows 8. Mit der Windows 8 Consumer Preview, die ebenfalls ab heute verfügbar ist, entwickeln Sie schon heute mit Visual Studio 11 Beta für Windows 8. Visual Studio 11 Beta, einfach produktiver entwickeln. Das neue schlanke Userinterface setzt den Quellcode und ihre Lösung in den Mittelpunkt. Die integrierte Suche über Quellcode oder selbst über die Funktionen in Visual Studio hilft ihnen bei der blitzschnelle Navigation durch ihren Code. Der neue Solution Explorer hat es in sich. Navigieren Sie im neuen Solution Explorer bis zur Funktionsebene hinunter verfolgen Sie die Aufrufhierachie. Die Vorschau-Funktion hält dabei ihren Arbeitsplatz frei von unnötig geöffneten Fenstern. Auf Veränderungen schnell zu regieren ist heutzutage ein MUSS. Aber bitte mit Qualität. Rasche nachvollziehbare Teamkommunikation, Transparenz, unkompliziertes flexibles Qualitätsmanagement und nahtlose Integration im Betrieb sind Erfolgsfaktoren für ihre Projekte. Visual Studio mit Team Foundation Server passt sich an ihren persönlichen Entwicklungsprozess an und bietet ihnen darüber hinaus die notwendigen Funktionspalette (Nahtlose Teamkommunikation, Storyboarding, CodeReviews, Qualitätsmanagent) um ihr Projekt erfolgreich zu implementieren. Mehr Informationen zu Visua Studio 11 Beta finden Sie hier: S. Somasegars Blog: “The Road to Visual Studio 11 Beta” Jason Zanders Blog: “Sneak Preview of Visual Studio 11 and .NET Framework 4.5 Beta” What's new in Visual Studio 11 Beta Da Sie Dank Visual Studio 11 Beta nun ihre täglichen Aufgaben schneller erledigen können wünsche ich Ihnen viel Spaß mit der neu gewonnenen Freizeit und freue mich auf Ihr Feedback! Andreas Pollak Product Marketing Manager Visual Studio & Expression

Das Model-View-Controller (MVC) Framework für Web-Applikationen geht in Runde 4. Die klare Trennung des Datenstroms in Model, View und Controller ermöglicht unter anderem Dinge wie Unit Testing, Test-driven development (TDD) bis hin zu angepasster Ausgabe auf verschiedenen Geräten. Die Beta-Version von MVC 4 kann bereits getestet werden und steht zum Download bereit. [More]

Dieser walkthrough zeigt, wie einfach Line of Business (LOB) Applicationen mit Visual Studio LightSwitch und SQL Azure in der Cloud erstellt werden könen. Das Video präsentiert einige Highlights von Visual Studio LightSwitch und zeigt eine rasche, funktionelle, interaktive Silverlight Applikation ohne bzw. mit sehr wenig Code. [More]

Das Windows Azure Trainings Kit nennt sich zwar “January Refresh”, aber das Veröffentlichungsdatum des Downloads entspricht dem aktuellen Datum: Windows Azure Training Kit - January Refresh. Das Kit dient vor allem dazu, um mit Windows Azure warm zu werden. [More]

Wer aller muss E-Mails oder Newsletter aus eigenen Applikationen versenden? Nun, viele Apps tun genau das: Sie informieren über bestimmte Aktionen per E-Mail. Und wie macht man das am besten? Hm, früher hat man noch seinen eigenen E-Mail Server, SBS oder was auch immer verwendet. Security und Spam sind da oft ein Thema beim Betreiben eines eigenen E-Mail-Systems. Darum wollen sich Developer meistens nicht kümmern (müssen). Heute verwendet man dazu Cloud Services wie Office 365. Oder: Windows Azure! Dazu gibt es eine tolle Aktion: 25.000 E-Mails per SendGrid versenden – für alle Windows Azure Kunden frei! http://sendgrid.com/azure.html Danke an Christian Weyer, thinktecture, MVP for Connected Systems, für den Tipp in unserer cloudusergroup!

Wie bekommt man Daten aus einem lokalen SQL Server in SQL Azure? Mit Tools, wie dem SQL Azure Migration Wizard oder mit dem nigel-nagel-neuen SQL Azure Import/Export Service. Wie das Windows Azure MSDN Blog verkündet, ging das SQL Azure Import/Export Service heute in den Produktivbetrieb. Der Name ist etwas sperrig – aber beschreibt genau die Funktion. Announcing SQL Azure Import/Export Service Now in Production Einige Highlights des Services: Verbesserte Leistung Verbesserte Connectivity Selektiver Export (Neu) Fortschritts-Anzeige (Neu) Das Service ist nun von CTP in Produktion Neue sample EXE Weitere Details und Beispiel-Videos gibt es im Blog von DAC Guy: SQL Azure Import/Export Service has hit Production Das SQL Azure Import/Export Service steht allen Windows Azure Kunden kostenfrei zur Verfügung.

Wie werden fast&fluid Client Anwendungen, welche das User Interface nicht blockieren, in .NET erstellt? Wie kann in server-seitigen Anwendungen mit Worker Threads das Ausschöpfen des Thread Pools verhindert werden? Der Webcast gibt eine Übersicht zur asynchronen Programmierung mittels C# async/await, sowie dem Task-based Asynchronous Pattern in .NET. Topics sind: Synchrone Programmierung: Client UI-und server-seitige Problemstellungen Asynchrone Programmiermodelle in .NET async/await in .NET 4.5 Erstellung eines async/await Beispiels Tips und Caveats Asynchrone Programmierung relativ zu paralleler Programmierung Dataflow Unterstützung in .NET   Anmeldung: http://www.katapult.tv/

Topic ist die Erstellung und das Deployment einer kleinen Node.js Framework-basierten Anwendung mit Zugriff auf die Azure Table Storage über das Windows Azure SDK für Node.js. Node ist ein häufig eingesetztes Javascript Framework. Das Ziel von Node.js ist die Vereinfachung der Entwicklung von skalierbaren Web Andwendungen. Damit ist es z.B. möglich mit wenigen Zeilen JavaScript Code einen einfachen Webserver aufzusetzen. In diesem Webcast führen wir das Deployment einer auf Node.js Framework basierten Anwendung in Azure durch.     Datum, Zeit: 13.1.2012 8:30 – 9:15 Anmeldung: http://www.katapult.tv/   Disclaimer: Allgemeine rechtliche Hinweise

Das folgende einfache Beispiel zeigt das GUI-Thread Blocking Verhalten einer Windows Presentation Foundation (WPF) Anwendung beim Download eines Files mittels der .NET WebClient-Klasse. Es zeigt, dass mittels async/await das GUI responsive bleibt. Alternativ dazu steht das Blocking Verhalten einer standard synchronen Variante. Das Beispiel folgt Teil Iund Teil IIeiner Serie aus 3 Teilen. Async-Sync zur Laufzeit Das Programm downloadet ein durch eine URL spezifiziertes File entweder synchron, oder asynchron mittels async/await. Es zeigt, dass der UI Thread in der synchronen Variante blockiert, in der asynchronen nicht. Die zweite Workload im Beispiel ist die Errechnung der Faktoriellen n! eines Integers n. Hier wird in der asynchronen Variante ein Worker Thread verwendet womit er gleichzeitig zum Download und UI Verwendung non-blocking Verhalten bringt. In der  synchron Variante läuft die Berechnung im UI Thread und blockiert daher. Der asynchrone Download kann durch die Verwendung eines Cancelation Tokens unterbrochen werden. Das Programm ist WPF-basiert mit XAML. Prerequisites Die Async CTP Funktionalität ist aktuell in mehreren Deliverables enthalten. Das Beispiel verwendet den Async CTPv3 mit Visual Studio 2010 – siehe Downloads. Dependency ist auf die Reference DLL AsyncCtpLibrary.dll, welche in der VS Solution in einen Folder Libraries gelegt wurde und sich nach der CTPv3 Installation in "%HOMEPATH%\Documents\Microsoft Visual Studio Async CTP\Samples" befindet.   Aufbau-Beschreibung Eingegebene URLs in eine WPF Textbox wird mittels (Uri.IsWellFormedUriString(textBoxURL.Text, UriKind.Absolute)) .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } validiert. n mittels Test auf Int32. Die Faktorielle wird wie folgt berechnet. public static BigInteger Factorial(int n){ BigInteger _factorial = 1; for (int i = 2; i <= n; i++) { _factorial *= i; } //Thread.Sleep(20000); return _factorial;} .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Der synchrone Download läuft über die WebClient.DownLoadFile Methode: WebClient client = new WebClient(); client.DownloadFile(textBoxURL.Text, destinationFile);   Der asynchrone Download Block hat den async Modifier dem Button Click Handler vorangestellt. await am Ende dispatched die Methode WebClient.DownloadFileTaskAsync asynchron.   public async void buttonDownloadAsync_Click (object sender, RoutedEventArgs e) ... await client.DownloadFileTaskAsync (new Uri(URL), destinationFile, cts.Token); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Der Async Download wird in dem einfachen Beispiel mit Return void gestartet, was auch als “fire and forget” bezeichnet wird. Der Download kann über den TPL Cancelation Mechanismus abgebrochen werden. Dazu wird zuerst ein Cancelation Token angefordert: cts = new CancellationTokenSource(); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } und wie im obigen await Statement als Argument übergeben. Für den async Download wird ein Progress Bar eingeblendet und ein Cancel Button mit u.A. enabled: progressBar.Visibility = Visibility.Visible; .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Das Event und der Delegate zum Update des Progress Bars sind   client.DownloadProgressChanged += new DownloadProgressChangedEventHandler (client_DownloadProgressChanged); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } … progressBar.Value = e.ProgressPercentage;   Ein Worker Thread zur nicht-blockierenden Factorial Berechnung wird wie folgt mit einem Lambda Ausdruck gestartet: BigInteger ret = await TaskEx.Run(() => Factorial(factorNumber)); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Downloads Async Support ist in aktuell 3 verschiedenen Downloads enthalten: (a) Async CTP: AsyncCtpLibrary.dll als Reference hinzufügen, (b) VS11 mit .NET 4.5 und (c) .NET 4.5 CTPv3: ein side-by-side Update von .NET <= 3.5 und in-place Update für 4.0. Achtung: da bei dem in-place Update zu z.B. dem Task Typ keine neuen statischen Members zu System.Threading.Tasks.Task hinzugefügt werden können haben manche Types zwischenzeitlich differierende Namen wie TaskEx. Zum Download: Download VS11 mit .NET 4.5 CTP Download .NET 4.5 CTP Download Async CTP Version 3(Beispiel in Teil III verwendet Async CTPv3) Task-based Asynchronous Pattern Dokument (Stephen Toub) Visual Studio 2010 Project Directory    Source // ---------------------------------------------------------------------------------- // Microsoft Developer & Platform Evangelism // // Copyright (c) Microsoft Corporation. All rights reserved. // // THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, // EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES // OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. // ---------------------------------------------------------------------------------- // The example companies, organizations, products, domain names, // e-mail addresses, logos, people, places, and events depicted // herein are fictitious. No association with any real company, // organization, product, domain name, email address, logo, person, // places, or events is intended or should be inferred. // ---------------------------------------------------------------------------------- using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Documents; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Navigation; using System.Windows.Shapes; using Microsoft.Win32; using System.Net; using System.Threading.Tasks; using System.Numerics; using System.Threading; namespace dpe.CTPasyncWPF { public partial class MainWindow : Window { public string destinationFile; public string URL; int factorNumber = 20000; private CancellationTokenSource cts; public MainWindow() { InitializeComponent(); textBoxStatus.Text = "Enter Download URL"; factorialslider.Value = factorNumber; } public void ValidateURL() { if (Uri.IsWellFormedUriString(textBoxURL.Text, UriKind.Absolute)) { URL = textBoxURL.Text; } else { textBoxStatus.Text = "URL Validation Error"; } } public static BigInteger Factorial(int n) { BigInteger _factorial = 1; for (int i = 2; i <= n; i++) { _factorial *= i; } //Thread.Sleep(20000); return _factorial; } private void buttonDownloadSynchronous_Click(object sender, RoutedEventArgs e) { ValidateURL(); if (destinationFile == null) { SaveFileDestination(); } else { WebClient client = new WebClient(); client.DownloadFile(textBoxURL.Text, destinationFile); } } public async void buttonDownloadAsync_Click(object sender, RoutedEventArgs e) { ValidateURL(); if (destinationFile == null) { SaveFileDestination(); } else { progressBar.Visibility = Visibility.Visible; progressBar.Background = Brushes.Blue; downloadLabel.Visibility = Visibility.Visible; cancelAsyncDonwload.IsEnabled = IsEnabled; cts = new CancellationTokenSource(); try { WebClient client = new WebClient(); client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(client_DownloadProgressChanged); textBoxStatus.Text = "DownloadFileTaskAsync Download "; await client.DownloadFileTaskAsync(new Uri(URL), destinationFile, cts.Token); textBoxStatus.Text = "Continuing from await Download"; } catch (OperationCanceledException) { textBoxStatus.Text = "Download canceled on Task Parallel Lib Token"; } } } void client_DownloadCallback(object sender, DownloadDataCompletedEventArgs e) { textBoxStatus.Text = "Synchronous Download completed"; } private void FormatStatusTextBox() { textBoxStatus.Text = "\n"; } void client_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e) { progressBar.Value = e.ProgressPercentage; } private void quit_Click(object sender, RoutedEventArgs e) { Application.Current.Shutdown(); } private async void burnCyclesMultithreaded_Click(object sender, RoutedEventArgs e) { textBoxStatus.Text = "Running Factorial - Worker Thread"; // UI not redrawn instantaniously BigInteger ret = await TaskEx.Run(() => Factorial(factorNumber)); textBoxStatus.Text = Convert.ToString(ret); } private void ofdButton_Click(object sender, RoutedEventArgs e) { SaveFileDestination(); } private void SaveFileDestination() { try { Microsoft.Win32.SaveFileDialog sfd = new Microsoft.Win32.SaveFileDialog(); Nullable<bool> rtn = sfd.ShowDialog(); if (!string.IsNullOrEmpty(sfd.SafeFileName)) { destinationFile = sfd.SafeFileName; } textBoxStatus.Text = "Destination File " + "\"" + destinationFile + "\"" + " selected"; } catch (Exception ex) { MessageBox.Show(ex.Message); } } private void textBoxURL_Keydown(object sender, KeyEventArgs e) { if (e.Key.Equals(Key.Enter)) { ValidateURL(); textBoxStatus.Text = "URL Changed to " + URL; } } private void burnCyclesBlocking_Click(object sender, RoutedEventArgs e) { textBoxStatus.Text = "Running Factorial Blocking"; FormatStatusTextBox(); BigInteger ret = Factorial(factorNumber); textBoxStatus.Text = (Convert.ToString(ret)); } private void factorialslider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e) { FactorialNumberSelected.Text = Convert.ToString(factorialslider.Value); textBoxStatus.Text = "Factorial Number Changed to " + FactorialNumberSelected.Text; } private void FactorialNumberSelected_TextChanged(object sender, TextChangedEventArgs e) { int intresult; bool inferInt32 = Int32.TryParse(FactorialNumberSelected.Text, out intresult); if (inferInt32) { factorNumber = Convert.ToInt32(FactorialNumberSelected.Text); textBoxStatus.Text = "Changed Factorial Number to " + FactorialNumberSelected.Text; } else { textBoxStatus.Text = "Enter an Integer "; } } private void ClearStatus_Click(object sender, RoutedEventArgs e) { textBoxStatus.Clear(); } private void cancelAsyncDonwload_Click(object sender, RoutedEventArgs e) { cts.Cancel(); } } } Zurück zu Teil I (synchron/asynchron, async in .NET), weiter zu Teil II (async/await)   Disclaimer: Allgemeine rechtliche Hinweise

.NET4.5 inkludiert neuen Language-und Library Support für asynchrone Programmierung mit den asyc-und await Keywords. Sie ermöglichen gemeinsam mit dem Task-based Asynchronous Pattern (TAP) die wesentlich erleichterte Erstellung von sowohl neuem Client/Server asynchronem Code, als auch das Refactoring existierenden synchronen Codes. async/await eignet sich für computational, Netzwerk-und I/O Loads mit mittlerer-hoher Latency. Wie im ersten Teil der Serie gezeigt existieren in .NET bereits eine Reihe an Asynchron Ansätzen. async/await depreciated APM, folgt EAP - welches für manche multi-threaded Probleme noch weiter Lösung ist und baut auf die Task Parallel Library (TPL) auf. Im Zuge der erweiterten Asynchron Funktionalität in .NET sind in .NET 4.5 verschiedenste async Methoden und Handler in z.B. der BCL, WPF, ASP.NET, ADO.NET etc. für sowohl C# als auch VB hinzugekommen. C# async/await besteht aus (1) dem C# Modifier Keyword async und der Operator Keyword await, (2) Klassen der TPL wie System.Threading.Tasks.Task(Of TResult) und (3) umfangreichem Compiler Support. Der async Modifier – siehe unten - wird der Methode vorangestellt, was sie als asynchron deklariert. Neben normalen Methoden kann async auch mit Lambda Ausdrücken und anonymen Methoden verwendet werden. public async void buttonDownloadAsync_Click (object sender, RoutedEventArgs e) ... await client.DownloadFileTaskAsync (new Uri(URL), destinationFile, cts.Token); .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } .csharpcode, .csharpcode pre { font-size: small; color: black; font-family: consolas, "Courier New", courier, monospace; background-color: #ffffff; /*white-space: pre;*/ } .csharpcode pre { margin: 0em; } .csharpcode .rem { color: #008000; } .csharpcode .kwrd { color: #0000ff; } .csharpcode .str { color: #006080; } .csharpcode .op { color: #0000c0; } .csharpcode .preproc { color: #cc6633; } .csharpcode .asp { background-color: #ffff00; } .csharpcode .html { color: #800000; } .csharpcode .attr { color: #ff0000; } .csharpcode .alt { background-color: #f4f4f4; width: 100%; margin: 0em; } .csharpcode .lnum { color: #606060; } Der await Operator steht vor dem asynchronen Aufruf und schließt einen async/await Block ab; oben wird ein WebClient.DownloadFileTaskAsync asynchron aufgerufen. Die Methode DownloadFileTaskAsync ist neu mit 4.5 und NICHT die bereits aus dem EAP bekannte WebClient.DownloadFileAsync. Semantik Die Semantik von await ist anders als der Name intuitiv erahnen lässt nicht das Blockieren des aktuellen Threads und Warten auf ein Signal um zu synchronisieren (wie in System.Threading.WaitHandle). wait hingegen bedeutet: “Under the covers, the await functionality installs a callback on the task via a continuation. This callback will resume the asynchronous method at the point of suspension”  [Stephen Toub, Task-based Asynchronous Pattern]. In anderen Worten und verdeutlicht durch das Beispiel in Teil III der Serie: der aufrufende Thread kehrt sofort nach dem Async Dispatch zurück und kann durch die WPF Message Loop Pump neue Work Messages annehmen. Der async/await Block selbst bleibt bei await bis zum Callback stehen. Wenn im Standard-Synchronization Context der aufrufende Thread der UI Thread ist kann dieser während auf den Callback gewartet wird andere Arbeit verrichten. Der User sieht es als “flüssiges” UI Verhalten in dem er in der selben oder anderen App andere Operationen starten kann. “Unter der Motorhaube” passiert allerdings viel mehr: der Compiler erzeugt einen Callback für den async Task. Aus dem gesamten Programm mit seinen async/await Blöcken generiert er transpartent eine State-Machine für die Callbacks und Task Events. Mit der erzeugten State Machine wird der Programmfluss auf nur einen Thread umgeordnet. Der Compiler erzeugt damit das Äquivalent zu kooperativem Multitasking zur compile-Zeit. async/await ist damit weder parallel, noch multi-threaded. Stattdessen wird der Thread des aufrufenden Synchronization Contexts – typisch der UI Thread – besser genutzt. Der Kern der async/await Technologie ist damit im Compiler. Da das Verhalten von async/await auch mit existierenden Konstrukten erreicht werden kann, können sie auch als “Syntactic Sugar” bezeichnet werden.     Vorteile Die Vorteile dieses Ansatzes sind enorm: Der eigene Code ähnelt nach wie vor der synchronen Form, läuft jedoch asynchron. Es muss nicht multi-threaded programmiert werden mit seinen bekannten Challenges. Man muss weiters keine Callbacks und Handler manuell schreiben, der Compiler generiert sie. Verglichen mit APM und Thread Pool Ansätzen ermöglicht async/await hohe Kompaktheit. Weiters integriert async/wait mit der TPL; Task und Task<T>sind kombinierbar (engl.: composable). await retourniert entweder void, den TPL Task, oder Task<T>; Methoden der TPL wie die Kombinatoren WhenAll, WhenAny sind für async/await verwendbar. async/await nutzt den CancelationToken Task Cancel Mechanismus der TPL (siehe Beispiel). Für Progress Reporting sind in der CTP das Interface IProgress<T> und die Klasse, Progress<T> hinzugekommen. Eine weitere Erweiterung der CTP gegenüber der .NET 4.0 TPL ist das Tasks await-ed werden können. Die eigenen Types müssen dafür nur die Methoden IsCompleted, Incomplted und GetResults() haben. Nachteile Nachteile von async/await (teils von jedem anderen Async Ansatz) sind: Overhead: es eignet sich nicht für kleinst-Operationen und sollte auch nicht verwendet werden, wenn die Return-Zeit so gering ist dass eine standard synchroner Fluss ausreicht. Sinnvolle Granularitäten sollten gefunden werden. await kann nicht in Main(), catch und finally verwendet werden. async/await ist nicht multi-threaded aber sehr wohl concurrent (dt.: nebenläufig) wenn mehrere asynchrone Operationen gleichzeitig ausständig sind. Der Task-based Asynchronous Pattern (TAP) erlaubt awaits in async Methoden welche Task(T) zurück liefern – Nesting. Behavioral Equivalance: ist das Verhalten des asynchronen Programmes dasselbe wie das des Synchronen? Das Verhalten von Business Logik bei einfacher Änderung der Aufrufe in asynchron async/await sollte sich generell an sich nicht ändern (Disclaimer: muss aber trotzdem auf Äuquivalenz getestet werden!!). Ausnahmen sind z.B. falls das Programm exklusiv State im Synchronization Context hält; wenn ein Thread der ursprünglich exklusiv verwendet wurde nun interleaved mehrfach verwendet wird müssen Auswirkungen bedacht werden. Ein Beispiel ist der UI Thread: falls ein Programm Annahmen über den globalen State des UI hat müssen sie im Zuge eines async/await Refactorings asserted werden.   Zurück zu Teil I (synchron/asynchron, async in .NET), weiter zu Teil III (Beispiel Anwendung). Downloads Async Support ist in aktuell 3 verschiedenen Downloads enthalten: (a) Async CTP: AsyncCtpLibrary.dll als Reference hinzufügen, (b) VS11 mit .NET 4.5 und (c) .NET 4.5 CTPv3: ein side-by-side Update von .NET <= 3.5 und in-place Update für 4.0. Achtung: da bei dem in-place Update zu z.B. dem Task Typ keine neuen statischen Members zu System.Threading.Tasks.Task hinzugefügt werden können haben manche Types zwischenzeitlich differierende Namen wie TaskEx. Zum Download: Download VS11 mit .NET 4.5 CTP Download .NET 4.5 CTP Download Async CTP Version 3(Beispiel in Teil III verwendet Async CTPv3) Task-based Asynchronous Pattern Dokument (Stephen Toub) Disclaimer: Allgemeine rechtliche Hinweise

Das neue Jahr bringt neue Paradigmen – fast&fluid wird Mainstream im GUI und asynchrone Programmierung generell damit eine Notwendigkeit. Wer kennt es nicht: nach einem Click in einer GUI Anwendung, welche auf einem starken Rechner mit guter single-und Multithreaded Performance läuft, scheint sie trotzdem festzustecken; man sagt die Anwendung “blockiert” (engl. blocked), was häufig durch Anwendungs Workload auf dem User Interface (UI) Thread hervorgerufen wird. Dem Anwender bleibt nichts anderes übrig als zu warten bis die blockierende Operation endet um das GUI weiter verwenden zu können. Das Problem von blocking Behavior ist allerdings nicht nur auf den Client beschränkt. Eine Server-seitige multi-threaded Anwendung kann schnell den Zustand eines ausgeschöpften Thread-Pools erreichen, wenn einzelne Threads z.B. für I/O Operationen blockieren. In der 3-teiligen Serie werden wir sehen, wie das neue async/await in .NET asynchrone Programmierung in vernünftiger Granularität zum Default Ansatz gegen Blocking machen soll. Synchron-Asynchron Die Programmausführung in dem Kontext wird auch als synchron bezeichnet; Programmschritte durchlaufen ein sequentiell Muster. Ein Programm Statement kommt erst zur Ausführung nachdem das Vorherige beendet wurde. Eine synchron aufgerufene Methode retouniert den Programmfluss erst wieder an den Aufrufer sobald sie selbst abgeschlossen ist. Synchrone Abläufe im weiteren Sinn inkludiert auch die Verarbeitung nach einem strickten Zeittakt wie in synchronen Netzen, parallele Modelle wie SIMD (single instruction multiple data) in GPUs und Pipelining in aktuellen CPUs. Asynchrone Programmierung hingegen erlaubt die Ausführung von Programmteilen ohne der vorherigen Beendigung anderer Prozesse und Methoden. Nach einem asynchronen Aufruf springt das Programm sofort wieder zum Aufrufer zurück, die Resultate liefert die aufgerufene Methode sobald fertig. Lang laufende Operationen (engl.: long-running) müssen damit nicht zu Blocking Verhalten der Anwendung führen. Praktische Vorteile von Asynchronität sind flüssige GUIs am Client, höhere Skalierbarkeit von server-seitigem Code, und besseres Antwortzeit Verhalten von Enterprise Anwendungen. Nun stellt sich die Frage warum nicht schon immer asynchron programmiert worden ist? Die Antwort war bis jetzt zumeist dass es wesentlich komplexer ist, es nicht dem omnipräsenten sequentiellen Gedankenmodell entspricht, Concurrency Issues entstehen können und Test/Debug entsprechend schwieriger sein kann. In einer Abgrenzung zur Parallel Programmierung werden wir sehen, dass async/await in .NET nicht parallel ist und letztere Hindernisse in der Async Verwendung größtenteils ausräumt.  Asynchrone Programmier Modelle in .NET In .NET sind bereits eine Reihe an asynchronen Programmier Modellen vorhanden. async/await und der Task-based Asynchronous Pattern ist nur die letzte Iteration Asynchron in den .NET Mainstream zu bringen. .NET 1.0 inkludierte neben dem umfangreichen System.Threading.Thread, welches natürlich auch für Asynchron verwendet werden kann, das vergleichsweise komfortablere Asynchronous Programming Model (APM). Mit den Konstrukten Begin/End in dem sog. IAsyncResult Pattern hat zum Beispiel die FileStream Klasse Methoden zum asynchronen Lesen/Schreiben als Begin{Read, Write}. Die asynchrone Operation läuft dabei in einem separaten Thread. Resultate werden entweder über IAsyncResult Objekte direkt oder Callbacks mit IAsyncResult retouniert. Ebenfalls seit .NET 1.0 kann über APM hinausgehend jede Methode über einen Delegate asynchron aufgerufen werden. Der Delegate ist dabei ein Wrapper zur synchronen Methode; die CLR startet dann via Delegate ein Replika der Methode in einem Worker Thread. Der Event-based Asynchronous Pattern (EAP) kam mit .NET 2.0 hinzu, womit APM depreciated wurde. EAP Methoden und Events im Framework haben das Namensschema {Operation}Async respektive {Operation}Completed. Eine häufig verwendete Methode ist z.B. WebClient.DownloadFileAsync, ein weiterer Namespace mit einigem EAP Support ist System.Net. System.ComponentModel.BackgroundWorker ist der universelle Weg in EAP Threads aus dem ThreadPool zu nutzen. Die Task Parallel Library (TPL) brachte umfangreiche Library-und Language Enhancements für vor allem multi-threaded und paralleles Programmieren (Parallel.For, PLINQ etc.) Die darin enthaltenen System.Threading.Tasks.Task und Task<T> “Task Klassen” sind nicht nur Basis für das folgende async/await sondern können auch in dem APM und EAP Patterns verwendet werden.  Zur Umsetzung des Dataflow Paradigmas-Skeletons gibt es seit .NET 3.5 SP1 die Reactive Extensions (Rx). Ähnlich den vorherigen asynchronen Ansätzen bei denen der Kontrollfluss eines Programmes asynchron abläuft erlaubt Dataflow automatisches asynchrones Propagieren von Datenänderungen. Rx nutzt IObservable<T> für Notifications zu Datenänderungen, und LINQ-Operatoren. Mit .NET 4.5 kommt komplementär die umfangreiche TPL Dataflow Library (System.Threading.Tasks.Dataflow) hinzu. Wesentliche Eigenschaften der TPL Library sind ein low-level Message Passing Ansatz für hohen Throughput und geringe Latency sowie die Zusammensetzbarkeit (engl.: composability) mit anderen async Konstrukten und Libraries wie zum Beispiel async/await. Rx und TPL vereinfachen Data Concurrency ungemein. Weiter zu Teil II (async/await) und Teil III (Beispiel Anwendung) sobald gepostet. Downloads Async Support ist in aktuell 3 verschiedenen Downloads enthalten: (a) Async CTP: AsyncCtpLibrary.dll als Reference hinzufügen, (b) VS11 mit .NET 4.5 und (c) .NET 4.5 CTPv3: ein side-by-side Update von .NET <= 3.5 und in-place Update für 4.0. Achtung: da bei dem in-place Update zu z.B. dem Task Typ keine neuen statischen Members zu System.Threading.Tasks.Task hinzugefügt werden können haben manche Types zwischenzeitlich differierende Namen wie TaskEx. Zum Download: Download VS11 mit .NET 4.5 CTP Download .NET 4.5 CTP Download Async CTP Version 3(Beispiel in Teil III verwendet Async CTPv3) Task-based Asynchronous Pattern (Stephen Toub)   Disclaimer: Allgemeine rechtliche Hinweise