Um Metro Style Anwendungen für Windows 8 zu erstellen, bedarf es auch eines Systems mit Touch-Oberfläche. Hier eignet sich z.B. der Samsung Series 7 Slate PC sehr gut dafür! Ergänzend zum Artikel “Unterstützung bei der Veröffentlichung Ihrer Windows 8 Apps” wollen wir daher noch auf das folgende Trainingsangebot hinweisen: Bei Global Knowledge arbeitet man in den Windows 8 Developer Kursen auf eben diesem Gerät. Und das Beste: Nach dem Kurs kann man das Gerät inklusive Docking Station und Bluetooth Tastatur mit nach Hause nehmen! Das sind die Windows 8 Kurse: Entwicklung von Windows 8 Metro Applikationen mit XAML und C# (GKW8XAML), nächster Termin: 2. bis 3. April 2012 Entwicklung von Windows 8 Metro Applikationen mit HTML und JavaScript (GKW8HTML), nächster Termin: 4. bis 5. April 2012 Entwicklung von Silverlight und Windows 8 Metro Applikationen mit XAML und C# (GKW8SILVER), nächster Termin: 16. bis 20. Juli 2012 Wer sich anmelden möchte: ==> zu den 3 Kursen und allen Infos ... Der Vortragende ist übrigens Christian Nagel, der uns ja auch am BigDay (http://BigDay2012.at) tatkräftig unterstützen wird. tweetmeme_url = 'http://codefest.at/post/2012/03/16/Windows-8-Developer-Kurse-Get-your-own-Slate-Device!!.aspx';

Die Windows 8 App Labs eröffnen Ihnen die einmalige Chance, Ihre App bereits im Windows 8 Beta Store zu veröffentlichen. So können Sie noch vor dem endgültigen Release von Windows 8 Ihre App einer breiten Öffentlichkeit zugänglich machen. Bewerben Sie sich, indem Sie sich bei uns mit einer kurzen Beschreibung ihrer App anmelden – via Mail an Andreas.Schabus@microsoft.com oder Feedbackformular auf codefest.at. Neben der Grundvoraussetzung, dass die App lauffähig ist, werden Teilnehmer anhand der Originalität der App-Idee und der gelungenen Umsetzung des Metro Style für das Windows 8 App Excellence Lab akzeptiert. Im Windows 8 App Excellence Lab helfen Ihnen Windows 8-Experten von Microsoft in Bezug auf UI/UX, Performance-Optimierung sowie technischer Problemlösungen/Debugging Ihrer App den letzten Schliff zu verleihen. Nach Abschluss erhalten Sie die Möglichkeit als einer der ersten Ihre App in den Store zu publizieren. Wir möchten jedem engagierten Entwickler den Zugang zum Windows 8 Beta-Store ermöglichen, bitten aber um Verständnis, dass die Plätze in den Labs leider begrenzt sind. Lernen sie das Potential der Plattform bei einer unserer Veranstaltungen (z.B. dem Microsoft BigDay 2012. http://BigDay2012.at) oder über unsere Web-Seiten - http://dev.windows.com bzw. http://design.windows.com – kennen, überzeugen Sie uns mit Ihrer App und positionieren Sie sich als einer der ersten in einem neu entstehenden Markt.

Nicht vergessen! Am Freitag findet wieder unser wöchentlicher Katapult.TV Webcast statt. Diese Woche wird Euch Andi Schabus in die Welt des "nativen" C++ Codes entführen. Viel Spaß beim Katapult.TV zu Visual C++ 11: Datum: Freitag, 09. März 2012 Zeit: 08:30 – 09:15 Sprecher: Andreas Schabus Ort: kostenloser Live Webcast über Katapult.TV Anmeldung: Über die Katapult.TV Webseite Auch wenn Visual Studio in den letzten beiden Versionen meistens mit .NET in Verbindung gebracht wurde, so ist es doch seit jeher auch eine sehr gute Entwicklungsumgebung um "nativen" C++ Code zu entwickeln. Und das wird sich auch mit Visual Studio 11 nicht ändern - im Gegenteil. Nicht nur, dass der Compiler viele der neuen C++ 11 Features unterstützt, es gibt auch einige neue bzw. verbesserte Werkzeuge, um die Erstellung von qualitativ hochwertigen Code zu vereinfachen. Am besten einfach dazukommen, mitschauen und mitdiskutieren! Ünbrigens: Wer gerne Visual Studio 11 schon heute ausproberen will: Visual Studio 11 Beta - Jetzt herunterladen und testen tweetmeme_url = 'http://codefest.at/post/2012/03/07/Going-Native-Visual-C-2011.aspx';

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,…

Heute war ein großer Tag für Microsoft. Das Windows-Team veröffentlichte Windows 8 Consumer Preview und Windows Server “8” Beta. Und es wurde Visual Studio 11 Beta with .NET 4.5 Beta zum Download freigegeben! [More]

Ab HEUTE ist es soweit. Die Windows 8 Consumer Preview wurde im Rahmen des Mobile World Congress 2012 in Barcelona der Öffentlichkeit vorgestellt. Millionen begeisterte Nutzer haben nun die Möglichkeit die wunderbare, neue Welt des Metro-Design mit Windows 8 ausführlich zu testen. Wenn auch Sie unsere Windows 8 Consumer Preview kennenlernen möchten, steht Sie Ihnen unter folgendem Link zum Download bereit: http://preview.windows.com. Entwickler können mit der jetzt ebenfalls bereitgestellten Visual Studio 11 Beta Software für Windows 8 entwickeln. Darüber hinaus finden Sie hier auch jede Menge weitere Informationen zur Windows 8 Consumer Preview. Also jetzt downloaden, testen, Spaß haben und begeistern. Stay tuned & visit the Windows Blog

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

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]

Jeder Developer verwendet seine Tools. Nützliche Helferlein erleichtern die Arbeit oder liefern einen Mehrwert. Ganz neu ist ein .NET-Tool von Telerik frei zum Download verfügbar: Telerik JustDecompile. Das Tool liegt derzeit als Beta-Version vor und macht genau das: Dekompilieren von .NET Assemblies. [More]

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/

Welcher Developer kennt das nicht: Du willst rasch ein Visual Studio Projekt als ZIP weitergeben… und beginnst damit, nur die relevanten Files zu identifizieren und alle “unnötigen” Files wie bin, obj, TFS-Bindings etc. zu löschen. Genau dafür gibt es ein neues Tool! Clean Project auf codeplex. “Clean Project is a utility that cleans Visual Studio project directories so you can quickly upload or email a zip file with your solution. “ Die Vorgangsweise scheint ruck-zuck zu funktionieren: Select Tools / Clean, Remove Source Bindings and Zip Solution Attach the zip file and send the email Viel Spaß beim Testen! //

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

Das optionale Toolkit besteht aus drei Sample Anwendungen und 2 Projekt Templates welche die gemeinsame Verwendung von Azure, SQL Azure und WP7 zeigen. Weitere verwendete Technologien dabei sind MVC3, OCR und Machine Translation von MS Research, Blobs, Queues, Tables, ACS Authentifizierung, OAuth und OData.  Prereq ist >= Visual Studio 2010 Professional oder Microsoft Visual Web Developer 2010 Express + Microsoft Visual Studio 2010 Express for Windows Phone, der Installer (Setup.cmd) prüft auf weitere Dependencies.    Downloads Windows Azure Toolkit for Windows Phone 7 Windows Azure Windows Phone 7 Mango     Disclaimer Der Beitrag gibt die Meinungen des Autors wieder, welche nicht denen des Herausgebers entsprechen müssen. Allgemeine rechtliche Hinweise