Am Montag den 17.1. fand das erste Windows Phone Pizza Tour Event des Jahres an der TU Graz statt. Mike Alexander gab unterstützt von Andreas Neuhold und Martin Cores vom U-Crew Team sowie Peter Prantner eine Übersicht zum Development auf dem Windows Phone. Mit 74 Teilnehmern musste eine Pizza-und Cola Bestellung wesentlich ausgeweitet werden.  Höhepunkt war die Verlosung eines brandneuen Nokia Lumia 800 Smartphones, natürlich über eine Windows Phone Verlosungs App.   Wir danken allen Teilnehmern und gratulieren der Gewinnerin. Die nächsten Termine zur Pizza Tour werden im Blog angekündigt.   Links Windows Phone 7.5 = SDK 7.1 Download Kostenlose AppHub Registrierung um Apps in den Windows Phone Marketplace zu stellen: https://www.dreamspark.com/

Wenn das Phone sagt es liegt ein Update bereit ist sind die folgenden Seiten mit einer History der MS WP7 Updates und Info zur Release hilfreich. Nicht jedes Update ist für die eigene Geographie, Carrier und Phone Modell anwenderbar. Die endgültige Freigabe einer Release erfolgt durch den Mobilfunkbetreiber. Updates können auch Hardware Hersteller Firmware beinhalten. Windows Phone update history Windows Phone Blog Mit unterem Code Snippet kann am Phone die OS Major-Minor Release-und Buildnumber in einen XAML TextBlock geschrieben werden.   Version pV = System.Environment.OSVersion.Version; textBlockVersion.Text = pV + "\nMajor: " + pV.Major + " Minor: " + pV.Revision + " Build: " + pV.Build; .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; } 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

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

Die erste W3C Developer Konferenz fand vom 15.-16.11. in Redmond mit Microsoft als Host Sponsor statt. Die W3Conf war eine großartige Möglichkeit zu sehen, wie dasselbe HTML5 Markup über verschiedene Browser verwendet werden kann. Microsoft Teilnehmer waren unter anderem Paul Cotton (W3C HTML Work Group co-chair) sowie Giorgio Sardo und Rey Bango – siehe untere Session Videos für HTML5 <video> Browser wie IE9.   Giorgio Sardo - HTML5 Demo Fest: The best from the web   HTML5 Video wird vom Browser nicht unterstützt.   Rey Bango - The Great HTML5 Divide: How Polyfills and Shims Let You Light Up Your Sites in Non-Modern Browsers.   HTML5 Video wird vom Browser nicht unterstützt.   Alle Session Videos

Ganz frisch wurde gestern die neue Version des Coding4Fun.Phone.Toolkit v1.5.0 für Windows Phone auf codeplex veröffentlicht. Das Toolkit liefert eine Reihe von nützlichen Controls für Windows Phone Silverlight applications. In der neuen Version sind einige neue Controls hinzugekommen und es wurden einige Bugfixes durchgeführt. Das Toolkit kann nur für die Entwicklung von Phone Apps mit Mango (Version 7.1) verwendet werden. Download von CodePlex: Coding4Fun.Phone.Toolkit v1.5.0 coding4fun.codeplex.com Alternativ kann das Coding4Fun Phone Toolkit natürlich auch über NuGet geladen werden: PM> Install-Package Coding4Fun.Phone.Controls.Complete Das Toolkit liefert eine Reihe von neuen Controls. Diese können in Visual Studio hinzugefügt werden, es stehen recht viele neue Controls zur Verfügung. Im eigenen Windows Phone Projekt muss nur eine Referenz zu den entsprechenden Assemblies erstellt, z.B. zu Coding4Fun.Phone.Controls.dll. Hier ein Beispiel des neuen MessagePrompts: Viel Spaß beim Ausprobieren! PS: Bis zum  29. Februar 2012 läuft der Windows Phone App-Wettbewerb “app in the snow” (siehe Startschuss für unseren “app in the snow” Wettbewerb...)! Mitmachen!

Windows Live Skydrive ist ein kostenloser Dienst aus den Windows Live Cloud-Services. Skydrive bietet 25GB online Storage, auf welche nun über ein offizielles API zugegriffen werden kann. Die untere Graphik zeigt die neu hinzugekommenen APIs in Dunkelblau. SkyDrive APIs für Folders, Photos und Dokumente im Live SDK 5.0 sind: ein C# Managed API für Windows Phone 7.5 Mango ein generisches REST API, welches von verschiedenen Plattformen aus verwendet werden kann ein JavaScript API (gemeinsam mit REST API) APIs für die Windows 8 Developer Preview Authentifizierung mit dem IETF OAuth 2.0 Protokoll  Die Managed APIs wrappen teils REST Operationen. Die REST und JavaScript APIs nützen JSON. Neben Skydrive inkludiert das Live SDK die aktuellen APIs zur Windows Live ID, für den Zugriff auf Hotmail Kontakte sowie Kalender und Messenger Operationen. Mittels des Web-basierten Interactive SDK auf http://isdk.dev.live.com/ können das SkyDrive und die anderen Live APIs gleich im Browser mit JavaScript/REST ausprobiert werden. Downloads Live SDK 5.0 Windows Phone: für das Sample Photo Sky on the Go sind sowohl die Windows Phone Mango Developer Tools 7.1 (externe Versionsnummer WP Mango ist 7.5 und entspricht 7.1) als auch das  Windows Phone Toolkit Nov 2011nötig. Die Toolkit DLL ist dann z.B. unter C:\Program Files (x86)\Microsoft SDKs\Windows Phone\v7.1\Toolkit\Oct11\Bin\Microsoft.Phone.Controls.Toolkit.dll   Disclaimer Der Beitrag gibt die Meinungen des Autors wieder, welche nicht denen des Herausgebers entsprechen müssen. Allgemeine rechtliche Hinweise

Mitmachen ist ganz einfach: bis Ende Februar viele coole Apps auf den Windows Phone Marketplace stellen, dann nur noch uns ein Mail (mit Deiner App Hub ID und den App ID´s) schicken und voilá … wer die meisten Apps am Marketplace hat darf sich stolzer Besitzer einer Xbox Kinect 250 GB und eines Nokia Lumia 800 nennen. Übrigens: auch der zweite und dritte Platz werden prämiert. Und falls Windows Phone Development noch ein Buch mit 7 Siegeln für Dich ist: wir haben erst kürzlich eine Step to Step Anleitungfür Studierende veröffentlicht (vom Titel nicht abschrecken lassen, auch Nicht – Studierende finden dort allerhand Tipps und Tricks) Und das Windows Phone SDK gibt es zum kostenlosen Download.     Teilnahmebedingungen: Veranstalter ist die Microsoft Österreich GmbH. Teilnahmeberechtigt sind alle Entwickler mit österreichischer Marketplace ID, ausgenommen Mitarbeiter von Microsoft und deren Angehörige sowie Amtsträger. Minderjährige sind teilnahmeberechtigt, wenn der gesetzliche Vertreter in die Teilnahme und in diese Teilnahmebedingungen vorher eingewilligt hat. Teilnahmevoraussetzung ist die Veröffentlichung von Windows Phone 7 Apps im österreichischen Marketplace von 1.12.2011 bis 29.2.2012 und Senden der Kontaktdaten und der österreichischen Marketplace ID per E-Mail an wp7at@microsoft.com. Die Gewinner werden schriftlich verständigt und erklären sich mit der Veröffentlichung des Vornamens und des Anfangsbuchstabens des Nachnamens auf codefest.at einverstanden. Der Rechtsweg ist ausgeschlossen und die Ausbezahlung in bar nicht möglich. Mit Ihrer Teilnahme stimmen Sie diesen Teilnahmebedingungen vollständig und bedingungslos zu. Durch das Absenden Ihrer Daten willigen Sie in die Speicherung Ihrer Daten durch die Microsoft Corporation in den USA und der Microsoft Österreich GmbH ein. Die erhobenen Daten dienen einzig der Auslosung und Benachrichtigung der Gewinner, sie werden nicht zu anderen Werbezwecken genutzt oder an Dritte weitergegeben. Diese Einwilligung können Sie jederzeit mit Wirkung für die Zukunft widerrufen. Ein Widerspruch ist an Microsoft Österreich GmbH, Am Europlatz 3, A-1120 Wien, oder an austria@microsoft.com zu richten.

Am Do. den 1.12.2011 veranstaltet der Studiengang für Mobile Computing der FH OÖ in Hagenberg einen Vortrag zum Thema „Application Development for Windows Phone 7.5 (Mango)“. Vortragender ist Ben Riga (Microsoft/Redmond) seines Zeichens Senior Technical Evangelist für Windows Phone. Datum: Donnerstag, 1. Dezember 2011 Zeit: 17:00 - 20:00 Uhr Ort: Audimax, FH OÖ Campus Hagenberg, Gebäude FH 2 Vortragssprache: Englisch Im Anschluss an die Veranstaltung lädt Microsoft zu einem Buffet. Programm: 1. Introduction to Windows Phone 7.5 Development - Part 1 (55 min): Developers on the Windows Phone platform build compelling, connected experiences that enhance the phone and integrate tightly with the end-user experience. In this session, we'll provide an overview of the Windows Phone device and some important new features that come with the new release. We'll review how with Visual Studio you get all the tools you need to get your app to market fast. We'll cover the basic tools for building Windows Phone apps including creating, editing, compiling, profiling and debugging. We'll also cover deploying to physical devices and to the emulator for testing.   2. Introduction to Windows Phone 7.5 Development - Part 2 (55 min): With Windows Phone 7.5 comes the ability for users to switch quickly between running applications. This dramatically enhances the end-user experience and will be expected by end-users. In this session, you'll learn how fast app switching works and how to prepare your application for this new functionality. Finally, we'll cover how to incorporate some important new features like Live Tiles, background tasks, file transfers and audio.        3. Building Games for Windows Phone 7.5 (55 min): In this session we review the game development model for Windows Phone 7.5 using the XNA Framework. We cover the game loop, content pipeline, as well as how to render game content to the screen. In addition, attend this session to learn how to render both XNA Framework and Silverlight content together in an application or game.   PRESENTER:   Ben Riga is Senior Technical Evangelist for Windows Phone in Microsoft's Developer and Platform Evangelism (DPE) group. In this role he runs around demonstrating the compelling technical and business value of the Windows Phone platform and how partners benefit when publishing apps to the Windows Phone marketplace. Ben also supports the Microsoft field by engaging in key projects and recruiting target customers and partners.

Das Open Data Protocol (OData) ist ein REST-basiertes Web Protokoll für Daten Services. OData nutzt Web-Stack Technologien wie JSON und Atom über HTTP. Es bietet ähnliche Funktionen wie ODBC, ADO.NET und JDBC für CRUD (Create, Read, Update, Delete) Operationen. OData hat breite Library-Unterstützung mit den Windows .NET Communication Foundation (WCF) Data Services bis zu JavaScript. Die OData Spezifikation ist von Microsoft unter der Open Specification Promise veröffentlicht. Tentative Inhaltspunkte der Vorstellung sind: Web Services Übersicht Einstiegs Demo Die OData Spezifikation Protocol Stack HTTP REST JSON Atom, AtomPub Protokoll Operationen - Semantik Query Options Batch Requests Service Metadata Entity Data Model Providers NetFlix EBay Northwind odata.org Windows Azure Table Storage Windows Azure Marketplace DataMarket Libraries .NET WCF ASP.NET Ajax Toolkit datajs Tools: LINQPad Protokoll Overhead Security Eco System Windows Client/WCF C# Sample - Visual Studio Odata Service Binding zu XAML JavaScript Sample – VS 11 DP Anmelden

Entwicklungsumgebungen wie der Team Foundation Server unterstützen große verteilte Entwicklungsorganisationen. Ein neuer Artikel bei heise Developer zeigt, wie SYNGO, ein Geschäftsgebiet von Siemens Healthcare, den TFS eingeführt hat. Dies war ein anspruchsvolles Projekt - SYNGO entwickelt bildgebende Softwareapplikationen mit einigen hundert Entwicklern und Entwicklerinnen in Standorten auf mehreren Kontinenten. Die Entwicklungsprojekte sind somit geographisch verteilt. Das Produkt selbst besteht aus mehreren tausend Anforderungen, die in vielen Millionen Zeilen C++ und C# umgesetzt sind. Erfahren Sie, wie das Team von SYNGO die hohen Anforderungen an Software-Engineering im Medizinbereich mit Hilfe von Team Foundation Server meistern konnte und welches Fazit die Verantwortlichen ziehen. Hier geht es zum Artikel auf heise developer. Andreas Pollak Product Marketing Manager Visual Studio & Expression Pragmatischer Einkauf kann teuer sein! Spare bares Geld mit der richtigen Beratung für Visual Studio!! Unser persönliches Rückrufservice berät Dich gerne.

Windows Embedded Enterprise v.Next (voraussichtlich ein Quartal nach allgemeinen Verfügbarkeit von Windows 8 verfügbar) Diese Produkte sind voll funktionale Versionen der Microsoft Desktop Betriebssysteme. Sie sind für spezielle gebaute Hardware und Software für integrierte Lösungen gedacht, welche mit der vollen Version von Windows kompatibel sein müssen und die Flexibilität einer eigens entwickleten Benutzerschnittstelle benötigen. Die Windows Embedded Enterprise Family besteht aus: New: Windows 7 Professional SP1 for Embedded Systems New: Windows 7 Ultimate SP1 for Embedded Systems Windows Vista Business for Embedded Systems Windows Vista Ultimate for Embedded Systems Windows XP Professional for Embedded Systems Windows Embedded Standard v.Next (Hier wird es im ersten Quartal von 2010 eine Community Technology Preview geben. Die allgemeine Verfügbarkeit ist voraussichtlich drei Quartale nach Windows 8) Diese Version wird die ARM Architektur unterstützen und alle Management und Sicherheitsfunktionalitäten von WIndows 8. Diese Produkte können sehr detailliert angepasst werden. Windows Embedded Compact v.Next (wird in der zweiten Hälfte von 2012 folgen und in Visual Studio 2010 unterstützt) Windows Embedded Compact ist die Weiterentwicklung von Windows Embedded CE. Compact ist ein komponenten orientiertes Real-time Betriebssystemmit der eine Vielzahl von sehr kleinen und ressourcenschonenden Geräte gebaut werden. Compact bietet auch Unterstützung für Silverlight und die neuesten Browser Technologien: Silverlight fürWindows Embedded basiert auf Silverlight v3.0 und kann mit Microsoft Expression Blend entwickelt werden. Compact enthält auch eine aktualisierte Version von Internet Explorer, die auf der selben Technologie aufbaut wie sie auch in  Microsoft Windows Phone 7 zum Einsatz kommt und bietet auch Unterstützung für Flash 10.1, multi-touch, usw… Andreas Pollak Product Marketing Manager Visual Studio & Expression Pragmatischer Einkauf kann teuer sein! Spare bares Geld mit der richtigen Beratung für Visual Studio!! Unser persönliches Rückrufservice berät Dich gerne.

Mit 11 neuen Samples zu Dynamics NAV, Silverlight, ASP.NET und dem Windows Driver Kit (WDK) beinhaltet das Microsoft All-In-One Code Framework nun tagesaktuell 705 Samples. Auf die Samples wird entweder über den unten gezeigten, downloadbaren Sample Browser oder über eine Visual Studio Extension zugegriffen. Installation in VS: Tools – Extensions – Online Gallery – Search “sample browser” oder direkter Download der Extension. Aufruf über Tools – Search Code Sample oder über Context Menü.      Downloads: Sample Browser Anwendung Windows 7 VS 2010, VS 11 Developer Preview Sample Browser Extension