dotnet-forum.de - Developer Blogs

RavenDb 2.0 on IIS with Windows Authentication returns a 401 Unauthorized #ravendb

Alexander Zeitler — Fri, 17 May 2013 00:32:00 GMT

If you’re hosting RavenDb 2.0 on IIS 7.5 / 8 and you have activated Windows authentication according to the official RavenDb documentation, your browser might keep prompting for the username and password and show you “Unauthorized” after the third attempt when you’re trying to create a new database:

If this is the case, you should set

<add key="Raven/AnonymousAccess" value="Admin" />

inside the web.config

Now you can create (and delete) new databases using Windows Authentication:

SetWindowHookEx - cool oder nur Fingerübung?

Martin Hey — Thu, 16 May 2013 16:19:00 GMT

Die Anforderung ist recht schnell erklärt: Erkenne, wann ein Fenster einer Anwendung maximiert, minimiert oder wiederhergestellt wird. "Das kann doch so schwer nicht sein" denkt man sich da, schließlich wirft Windows ja nur so mit Nachrichten um sich, die man einfach nur abfangen muss. Die Windows-API ist dein Freund. Ok, ganz so einfach ist es dann doch nicht, sonst bräuchte dieser Blogpost ja nicht geschrieben werden.

Damit das Fensterhandling und auch so ziemlich alles andere in Windows funktioniert, werden Nachrichten an Fenster gesendet. Zumeist macht Windows das selbst (z.B. Fenster 358: Maximiere dich"). Kommt diese Nachricht am Fenster an, gibt es dort eine Kette von "Abonnenten" - die hook chain. Und in diese Kette kann man eigene Funktionen eingliedern lassen, die dann Teil dieser Kette werden.

Mit diesem Wissen ist die relevante Methode ist auch recht schnell gefunden: SetWindowsHookEx in der user32.dll. Damit gliedert man eine Funktion in die hook chain ein und bekommt dabei einen Handle für den nächsten Teilnehmer der Kette - also den an den die Nachricht dann geschickt werden muss, wenn meine Bearbeitung fertig ist.

Eine gute Anlaufstelle für Fragen, wenn es um die Syntax oder die Verwendung geht, ist entweder die Windows API-Dokumentation in der MSDN - wo C-Syntax verwendet wird und die Parameter inzwischen auch recht ausführlich beschrieben sind - oder pinvoke.net - wo es auch Beispiele zur Umsetzung in C# oder VB.NET gibt. Dort lernt man dann auch schnell, dass man einige Voraussetzungen schaffen muss, um diese Funktionen verwenden zu können.

Wie implementiert man den Hook?

Zunächst werden die Methoden definiert, die importiert werden sollen: Mit SetWindowHookEx kann die Methode in die Kette eingereiht werden. Und natürlich benötigt man dann auch noch UnhookWindowsHookEx, um diesen Eintrag später auch wieder entfernen zu können. Des weiteren habe ich schon erwähnt, dass man dafür Sorge tragen muss, den Folgeeintrag in der Kette aufzurufen, deshalb wird auch noch CallNextHookEx benötigt.

[DllImport("user32.dll")]
static extern IntPtr SetWindowsHookEx(int code, HookDelegate func, IntPtr hInstance, uint threadId);

[DllImport("user32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool UnhookWindowsHookEx(IntPtr hhk);

[DllImport("user32.dll")]
static extern int CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);

Im Import von SetWindowsHookEx wird im zweiten Parameter auf einen Delegate verwiesen. Dieser muss ebenfalls definiert werden:

public delegate int HookDelegate(int code, IntPtr wParam, IntPtr lParam);

Und man sieht, dass SetWindowsHookEx eine ThreadId erwartet. Damit die Funktion aber nun mit einen Fenster-Handle verwendet werden kann, wird nun noch GetWindowThreadProcessId benötigt, um dieses Mapping durchführen zu können. aber das ist nur Makulatur und für die eigentliche Funktionalität irrelevant:

[DllImport("user32.dll", SetLastError = true)]
static extern uint GetWindowThreadProcessId(IntPtr hWnd, IntPtr lpdwProcessId);

So weit, so gut. Nun sieht man in den Deklarationen aber auch, dass sehr viele int-Werte verwendet werden. Für Menschen sind Zahlen immer etwas schwierig zu lesen - aus diesem Grund werden noch ein paar Enumerationen deklariert.

Der Hooktype definiert, welche Art von Nachricht interessant sind. Danach richtet sich im späteren Verlauf, wie die Informationen der Nachricht interpretiert werden müssen:

public enum HookType : int
{
    WH_JOURNALRECORD = 0,
    WH_JOURNALPLAYBACK = 1,
    WH_KEYBOARD = 2,
    WH_GETMESSAGE = 3,
    WH_CALLWNDPROC = 4,
    WH_CBT = 5,
    WH_SYSMSGFILTER = 6,
    WH_MOUSE = 7,
    WH_DEBUG = 9,
    WH_SHELL = 10,
    WH_FOREGROUNDIDLE = 11,
    WH_CALLWNDPROCRET = 12,
}

Für die gewünschte Funktionalität wird WH_CallWndProcRet von Interesse sein, da diese Art von Nachricht dann aufgerufen wird, wenn eine Fensterfunktion fertig ausgeführt ist. Die Nachricht dieses Nachrichtentyps lässt sich mit folgendem Struct darstellen:

[StructLayout(LayoutKind.Sequential)]
public struct CwpRetStruct
{
    public IntPtr lResult;
    public IntPtr lParam;
    public IntPtr wParam;
    public uint message;
    public IntPtr hwnd;
};

Dabei wird dann im Feld message stehen, welche Nachricht geschickt wurde - im gezeigten Fall werden nur Systemcommands von Interesse sein:

public enum WindowsMessages : uint
{
    WM_SYSCOMMAND = 0x0112
}

Und im Feld wParam wird stehen, welche genaue Ausprägung dieses Command hat:

public enum SystemCommands : int
{
    SC_SIZE = 0xF000,
    SC_MOVE = 0xF010,
    SC_MINIMIZE = 0xF020,
    SC_MAXIMIZE = 0xF030,
    SC_NEXTWINDOW = 0xF040,
    SC_PREVWINDOW = 0xF050,
    SC_CLOSE = 0xF060,
    SC_VSCROLL = 0xF070,
    SC_HSCROLL = 0xF080,
    SC_MOUSEMENU = 0xF090,
    SC_KEYMENU = 0xF100,
    SC_ARRANGE = 0xF110,
    SC_RESTORE = 0xF120,
    SC_TASKLIST = 0xF130,
    SC_SCREENSAVE = 0xF140,
    SC_HOTKEY = 0xF150,
    SC_DEFAULT = 0xF160,
    SC_MONITORPOWER = 0xF170,
    SC_CONTEXTHELP = 0xF180,
    SC_SEPARATOR = 0xF00F,

    SCF_ISSECURE = 0x00000001,

    SC_ICON = SC_MINIMIZE,
    SC_ZOOM = SC_MAXIMIZE,
}

Nun aber genug der Vorbereitungen: Die Funktionalität muss auch noch implementiert werden. Der Rumpf meiner Klasse sieht nun wie folgt aus:

public class WindowMessageInterceptor : IDisposable
{
    private IntPtr nextHookPtr;

    private HookDelegate callbackDelegate;

    public WindowMessageInterceptor(IntPtr hWnd)
    {
    }

    public void Dispose()
    {
    }
}

Der Konstruktor erwartet ein Fensterhandle, es gibt Membervariablen für die Delegateinstanz und den Pointer auf den Folgeeintrag in der hook chain, im Konstruktor wird der Hook später gesetzt werden und im Dispose wird der Hook wieder entfernt werden.

Der Konstruktor sieht mit diesem Wissen auch recht unspektakulär aus:

public WindowMessageInterceptor(IntPtr hWnd)
{
    // determine ThreadId for specified Window
    var threadId = GetWindowThreadProcessId(hWnd, IntPtr.Zero);

    // initialize the callback delegate
    this.callbackDelegate = new HookDelegate(this.HookCallbackFunction);

    // setup a window message hook and add it to hook chain
    this.nextHookPtr = SetWindowsHookEx((int)HookType.WH_CALLWNDPROCRET, this.callbackDelegate, IntPtr.Zero, threadId);

    if (this.nextHookPtr == IntPtr.Zero)
    {
        throw new Exception("unable to apply hook");
    }
}

und ebenso das Dispose:

public void Dispose()
{
    if (this.nextHookPtr == IntPtr.Zero)
    {
        return;
    }

    UnhookWindowsHookEx(this.nextHookPtr);
    this.nextHookPtr = IntPtr.Zero;
}

Spannend ist die Callback-Funktion:

private int HookCallbackFunction(int code, IntPtr wParam, IntPtr lParam)
{
    // If code is less than zero, the hook procedure must return the value returned by CallNextHookEx.
    if (code < 0)
    {
        return CallNextHookEx(this.nextHookPtr, code, wParam, lParam);
    }

    // otherwise do all the things and call NextHookEx afterwards
    // convert the lparam to our struct
    var message = (CwpRetStruct)Marshal.PtrToStructure(lParam, typeof(CwpRetStruct));

    // evaluate the message
    if (message.message == (uint)WindowsMessages.WM_SYSCOMMAND)
    {
        Console.Write("syscommand detected: ");

        switch (message.wParam.ToInt32())
        {
            case (int)SystemCommands.SC_RESTORE:
                Debug.WriteLine("window restored from maximized state");
                break;
            case (int)SystemCommands.SC_MINIMIZE:
                Debug.WriteLine("window minimized");
                break;
            case (int)SystemCommands.SC_MAXIMIZE:
                Debug.WriteLine("window maximized");
                break;
            default:
                Debug.WriteLine("not important");
                break;
        }
    }

    return CallNextHookEx(this.nextHookPtr, code, wParam, lParam);
}

Was passiert hier?

Zunächst wird geprüft, ob der Code größer als 0 ist. Laut API-Dokumentation ist die Nachricht nur dann auch für diese Methode gedacht. Im Anschluss daran muss die Nachricht ausgewertet werden. Damit das passieren kann, bietet das Framework die Methode PtrToStructure. Damit kann der lParam-Wert des Callbacks, in dem sich die Informationen befinden, in das Nachrichtenformat konvertiert werden. Und aus dieser Nachricht interessiert nun, wie man der API entnehmen kann der wParam-Wert.

Im Anschluss wird der Hook an den Folgeempfänger weitergeleitet.

Der Test

Für den Test gibt es einen weiteren Konstruktor, der als ThreadId einfach die ThreadId der aktuellen Applikation übergibt:

public WindowMessageInterceptor()
{
    // initialize the callback delegate
    this.callbackDelegate = new HookDelegate(this.HookCallbackFunction);

    // setup a window message hook and add it to hook chain
    this.nextHookPtr = SetWindowsHookEx((int)HookType.WH_CALLWNDPROCRET, this.callbackDelegate, IntPtr.Zero, (uint)AppDomain.GetCurrentThreadId());

    if (this.nextHookPtr == IntPtr.Zero)
    {
        throw new Exception("unable to apply hook");
    }
}

Und das funktioniert auch ganz gut: Die entsprechenden Nachrichten werden angezeigt. Und auch wenn man das Fensterhandle der aktuellen Anwendung übergibt, funktioniert alles super

Aber.....

Versucht man das Ganze nun mit einem fremden Fensterhandle, so schlägt das Setzen des Hooks fehl. Aber warum?

Auch hier hilft die Dokumentation weiter. Sinngemäß steht dort: Hooks können innerhalb der eigenen Anwendung gesetzt werden, indem als Modul-Handle (Parameter 3) IntPtr.Zero übergeben wird und dann im vierten Parameter die ThreadId. Um den Hook auf fremde Fenster zu setzen, muss als ModulId die ModulId des fremden Programms angegeben werden, der Callback muss in einer Dll sein und das Fremde Programm muss diese Dll geladen haben. Und genau das ist der Knackpunkt, denn hier greifen Sicherheitsmechanismen von .NET, die genau das verhindern.

Resümee

Für den gezeigten Anwendungsfall kommt man mit SetWindowsHookEx nicht weiter, da nur die aktuelle Anwendung abgefragt werden kann. Und das geht mit Bordmitteln wesentlich einfacher, indem man Events auf dem Hauptfenster abonniert - in WPF wäre das das WindowStateChanged-Event.

Für alle Trekkies

Oliver Scheer — Thu, 16 May 2013 13:09:36 GMT

Zu gut Auf www.bing.com gehen und “beam me up” eintippen. ...read more...(read more)

Surface Pro in Deutschland verfübar ab dem 31.05.

Oliver Scheer — Thu, 16 May 2013 12:18:03 GMT

Ab dem 31. Mai 2013 gibt es Surface Pro in Deutschland über www.microsoftstore.com und im Fachhandel. Das Gerät wird in zwei unterschiedlichen Versionen verfügbar sein: Ein 64-GB Modell für 879 Euro (UVP) sowie eine Variante mit 128-GB für 979 Euro...(read more)

TFS Incremental build und writeable files

Thomas Schissler — Thu, 16 May 2013 11:36:15 GMT

Der TFS Build geht standardmäßig so vor, dass er vor einem Build, alle Dateien sauber löscht und dann den kompletten Workspace neu aus der Versionsverwaltung holt. Ein solcher “Clean Build” birgt natürlich das geringste Risiko, dass veraltete Dateien in den Build einfließen oder dass der Build Dateien benutzt die gar nicht mehr in der versionsverwaltung enthalten sind. Aber gerade bei größeren Projekten ist das natürlich auch sehr ineffizient. deshalb kann man im TFS Build einstellen, wie er sich verhalten soll.

In den Build Process Parametern gibt es eine Einstellung dafür.

Dieser Parameter hat 3 mögliche Einstellungen:

All – Mit dieser Einstellung werden sowohl der Source Code all auch alle Outputs des Builds gelöscht (Clean Build). Dies ist die Default-Einstellung
Outputs – Der Build löscht die Outputs, nicht aber die Sourcen. Für die Sourcen wird ein get Latest ausgeführt, d.h. es werden nur geänderte Dateien vom TFS heruntergeladen
None – Sowohl Outputs als auch Sourcen bleiben erhalten. Nach einem Get Latest wird ein Build ausgeführt und dabei nur Projekte gebaut bei denen sich die SOurcen bzw. die Referenzen geändert haben

So weit so gut. Ich hatte einen Build auf “Outputs” gestellt und dann folgenden Fehler bekommen:

Warning C:\Builds\101\Projekt\artiso_Working1_CI\Sources\Solutions\artisoSolutions\WCH_Diff\NoDeploy.testsettings - Unable to perform the delete operation because the file already exists locally

Völlig unlogisch, dass eine Datei nicht gelöscht werden kann, weil sie schon existiert, aber nun gut. Die Ursache war dann auch schnell gefunden. Um die Version in der AssemblyInfo.cs während des Builds zu ändern, hebe ich den Schreibschutz dieser Dateien auf. Und der Get hat nun ein problem, wenn da Dateien rumliegen die keinen Schreibschutz haben, da diese ja geändert sein könnten und er die nicht einfach überschreibt. Es gibt aber eine kleine Einstellung im Workflow mit der man dieses Verhalten anpassen kann:

Man sucht die Gte Workspace Activity im Workflow

Dann stellt man in den Properties die GetOptions auf “Overwrite”

Damit überschreibt der Build beim Get nun die Dateien ohne Schreibschutz-Attribut und der Build läuft problemlos durch – und das nun auch deutlich schneller als zuvor.

All I wanted was a pyramid…

Hendrik Loesch — Wed, 15 May 2013 20:44:19 GMT

… and all I got was this lousy Christmas tree. I like TDD and I like test automation. It is great to see the application growing with each successful test and to be sure that it will work even if a lot of changes are made on the code base. On the other I see [...]

Bing mit Star Trek Easter Egg

Stephan Walcher — Wed, 15 May 2013 17:16:12 GMT

Viele kennen sicherlich das Google Easter Egg do the barrel roll, durch das sich das komplette Google Fenster bewegt. Bing hat nun auch endlich sein erstes kleines Easter Egg das wohl passend zum neuen Star Trek Film eingeleitet worden ist. Gibt man nämlich bei Bing den Suchbegriff Beam me up, wird man vom normalen Hintergrund [...]

The post Bing mit Star Trek Easter Egg appeared first on Prometeo.

Interessante Trainings zu Visual Studio 2012 in der Microsoft Virtual Academy

Christian Binder — Wed, 15 May 2013 13:30:15 GMT

Software Testing with Visual Studio 2012 (exam 70-497) Jump Start

Live Event Details
May 28, 2013
9:00am - 5:00pm (PDT)

Link: https://www.microsoftvirtualacademy.com/liveevents/software-testing-with-visual-studio-2012-jump-start?CR_CC=200211930

Administering Visual Studio Team Foundation Server 2012 (exam 70-496) Jump Start

Live Event Details
May 29, 2013
9:00am - 5:00pm (PDT)

Link: https://www.microsoftvirtualacademy.com/liveevents/administering-visual-studio-team-foundation-server-2012-jump-start

Applying ALM with Visual Studio 2012 (exam 70-498) Jump Start

On demand Jump Start training
Link: https://www.microsoftvirtualacademy.com/training-courses/applying-alm-w-visual-studio-2012-jump-start

Building Business Apps with Visual Studio Lightswitch

https://www.microsoftvirtualacademy.com/training-courses/building-business-apps-with-visual-studio-lightswitch

Gewinnen durch Vorläufigkeit

Ralf Westphal — Tue, 14 May 2013 10:23:00 GMT

Warum soll im Business eigentlich immer alles perfekt sein? Oder, nein, nicht perfekt, aber "effizient". Ein Beispiel dafür ist mir gerade im Rahmen eines Hobbyprojekts untergekommen: der hey! publishing Verlag. Eine befreundete Autorin hat dort einen Roman veröffentlicht, "Die Martinis": Der ist als eBook erschienen. Und das war´s. Weiter ist nichts geschehen (Stand Anfang Mai 2013), obwohl

Windows Phone 8 Trainingskit

Oliver Scheer — Mon, 13 May 2013 15:41:22 GMT

Kostenlos als Download hier verfügbar: http://www.microsoft.com/en-us/download/details.aspx?id=38782&WT.mc_id=rss_alldownloads_all ...read more...(read more)

video2brain - Windows Store Apps mit XAML und C# – Das große Training + Geek-Gewinnspiel

Gregor Biswanger — Mon, 13 May 2013 15:10:55 GMT

Passend zu meiner letzten DVD “Meine erste Windows 8 App”, gibt es jetzt das umfangreiche Video-Training zum Thema “Windows Store Apps mit XAML und C#”. In diesem Video-Training erkunden und erlernen wir ausführlich die faszinierenden Möglichkeiten der App-Entwicklung für Windows 8 und Windows RT. Wir steigen mit den Grundlagen von XAML ein und sind auch bald mit den wichtigsten Neuerungen der Windows Runtime vertraut. Mit den Best Practices zum Thema MVVM - Model View ViewModel - und vielen Profi-Tipps steigst Du bald auf zum versierten App-Entwickler und -Designer.

Weitere Informationen

- Produktübersicht
- Inhaltsverzeichnis

Kostenfreie Probevideos

Einführung in XAML

App in den Store stellen

Facebook Fanpage

Weitere Tipps und Tricks zur Windows Store App Entwicklung findest du regelmäßig auf der Facebook Fanpage von “Meiner ersten Windows 8 App”: https://www.facebook.com/MeineErsteWindows8App

Großes Geek-Gewinnspiel in Kooperation mit WindowsDeveloper.de bis zum 19.05.2013

Zu Gewinnen gibt es eine Signierte-Version meiner DVD “Meine erste Windows 8 App”. Dabei wurde die DVD nicht von mir persönlich unterzeichnet, sondern ich habe diese direkt in Redmond vom WinRT-Team verewigen lassen. Dabei sind Unterschriften von Tim Heuer (Program Manager für Microsoft XAML), Unni Ravindranathen (Program Manager für Microsoft Expression) und drei weiteren Mitgliedern des WinRT Teams.

Außerdem verlosen wir vier Zugänge zum neuen video2brain-Online-Training “Windows Store Apps mit XAML und C#”.

Zum Gewinnspiel geht es hier lang: [Geek-Gewinnspiel] Zeit für Windows 8! – Einsteiger-Tutorials zu gewinnen

Nun wünsche ich allen viel Spaß beim Rätseln!

Besten Dank

Besten Dank an das ganze video2brain-Team!

IIS & Windows Authentication – Troubleshooting mit Negotiate & NTLM

Robert Mühsig — Sun, 12 May 2013 21:50:51 GMT

Windows Authentifizierung ist eine einfache (und naheliegende) Authentifizierungs-Option für “Haus-interne” Webapplikationen. Setup Im IIS selbst kann man die Windows Authentifzierung sehr leicht anschalten: Natürlich kann man dies auch über die web.config steuern: <system.web> ... <authentication mode="Windows"/> ... </system.web> ... Fehlermeldung “HTTP Error 401.2 – Unauthorized”: Dies kann (wie fast immer) viele Gründe haben, z.B. weil ...

dotnet Cologne 2013 – Windows Azure Mobile Services

Stefan Lange — Thu, 09 May 2013 17:45:00 GMT

Zu meinem Vortrag „Einführung in die Windows Azure Mobile Services“ auf der dotnet Cologne 2013 finden sich hier die Slides.

Die Slides wurden an den aktuellen RC der Mobile Services angepasst.

Materialien zum Vortrag:

Einführung in die Windows Azure Mobile Services (PDF – 2,66 MB)

TFS 2012 Lab Management mit Windows XP VMs

Thomas Schissler — Wed, 08 May 2013 18:12:46 GMT

Seit dem Update 2 ist es nun endlich wieder möglich, das Lab Management im TFS 2012 auch mit XP-Maschinen zu betreiben. Das Problem war hier bisher, dass der Test Agent 2012 das .Net Framework 4.5 benötigt, dass sich das aber auf XP nicht installieren lässt. Man kann nun die Test Agents für 2012 Update 2 hier herunterladen: http://www.microsoft.com/en-us/download/details.aspx?id=38186.

Wie man bei der Installation vorgehen muss, wird hier beschrieben: http://msdn.microsoft.com/en-us/library/jj153008.aspx#installagent. Das Dokument hat jedoch einen kleinen Schönheitsfehler. Es verschweigt nämlich die Tatsache, dass man vor der Installation des Test Agents das .Net Framework manuell installieren muss. Das Setup des Test Agents versucht nämlich das Framework zu installieren, wenn keines vorhanden ist, dummerweise aber immer das 4.5er. Probleme gibt es übrigens auch, wenn nur ein älteres Framework (z.B. 3.5) installiert ist. Dort schlägt die Installation fehl. Auch hier hilft einfach Framework 4.0 manuell zu installieren.

Lustig finde ich auch die Fehlermeldung “0x800713ec – Asia”

Json-Online-Tools: Viewer & Json2Csharp Generator

Robert Mühsig — Tue, 07 May 2013 23:28:59 GMT

Wo APIs im Spiel sind, ist das JSON Format nicht weit. Da ich immer mal wieder zwei Tools benutze, möchte ich diese hier auch mal kurz würdigen. JSON Viewer Wer nur den JSON-Text vor sich hat sieht meist die Struktur nicht. Über JSON Viewer kann man sich recht einfach einen Überblick verschaffen: [URL] JSON2CSharp Der ...

Coded UI Test unter Windows 8

Thomas Schissler — Tue, 07 May 2013 15:38:51 GMT

Wenn man unter Windows 8 Coded UI Tests auf laufen lassen möchte, hat man Probleme, wenn man die Tests z.B. in einer Lab Umgebung mit Autologon ausführen möchte. D.h. die Maschine bootet aus einem Snapshot und wird automatisch angemeldet. Dann bekommt man als erstes den Windows 8 Startbildschirm. Da der Coded UI Test diesen nicht steuern kann, haben wir hier ein Problem. Mit einem kleinen Tool kann man Windows 8 aber auch so konfigurieren, dass es direkt mit dem Desktop startet. Vielleicht ist das ja auch für andere Szenarien als dem hier beschriebenen interessant

http://win-8.de/MetroDeactivator/

Mehr verdienen durch Experiment

Ralf Westphal — Tue, 07 May 2013 10:10:00 GMT

Könnten Sie oder die Firma, für die Sie arbeiten, mehr verdienen? Ja? Wunderbar, dann los! Nein? Warum nicht? Woher weiß man das? Auf diese Frage bin ich neulich bei einem Aufenthalt im Marriott Hotel in Zürich gestoßen. Dort fand ich nämlich dieses Angebot vor: Zum Verkauf auf dem Zimmer standen solche 1 Liter Flaschen Wasser für 8,00 CHF (ca. 6,50 EUR) das Stück. Ein stolzer Preis,

Windows Azure Mobile Services - Windows Account Authentifizierung für Windows Store Apps

Sascha Dittmann — Tue, 07 May 2013 08:07:00 GMT

In den bisherigen Teilen meiner Windows Azure Mobile Services Serie wurde eine Windows Store App erstellt, welche Nachrichten in der Cloud speichert.
Bislang waren diese Nachrichten keinem Benutzer zugeordnet worden.
Dies soll sich heute ändern, indem die Benutzer via Microsoft Account authentifiziert werden...

App im Live Connect Developer Center registrieren

Damit sich die Benutzer der Windows Store App via Microsoft Account authentifizieren können, muss diese zuerst im Live Connect Developer Center registriert werden.

Dazu navigiert man zuerst auf die My Applications Seite des Live Connect Developer Centers.

Mit einem Klick auf den Create Application-Link wird die Registrierung gestartet:

Nachdem man den Namen der App sowie die primäre Sprache angegeben hat, klickt man auf "I accept":

Unter den API Settings findet man dann die Client ID und das Client Secret, die man im nächsten Schritt benötigt.

Außerdem muss die URL des entsprechenden Mobile Services als "Redirect Domain" eingetragen werden:

Änderungen bei den Mobile Services

Die gerade erhaltene Client ID, sowie das Client Secret, trägt man anschließend in den Identity Bereich des Mobile Services ein und klickt "Save":

Jetzt sind die Mobile Services bereit, um die Benutzer via Microsoft Account authentifizieren zu können.

Änderungen an der Windows Store App

Damit die Anwender der Windows Store App zur Eingabe ihrer Microsoft Account-Benutzerdaten aufgefordert werden, genügt eine Zeile Code:

await _mobileServiceClient.LoginAsync(
  MobileServiceAuthenticationProvider.MicrosoftAccount);

Um dabei auch mögliche Fehlermeldungen, die beispielsweise beim Abbrechen des Dialogs auftreten, abzufangen sieht die entsprechende Methode im ViewModel der "Let's Talk"-App wie folgt aus:

private async Task Authenticate()
{
  if (_mobileServiceClient.CurrentUser != null) return;

  var message = String.Empty;
  try
  {
    await _mobileServiceClient.LoginAsync(
      MobileServiceAuthenticationProvider.MicrosoftAccount);
  }
  catch (InvalidOperationException)
  {
    message = "login unsuccessful";
  }
  catch (Exception ex)
  {
    message = ex.Message;
  }
  if (!String.IsNullOrEmpty(message))
    await new MessageDialog(message, "Authenticate User").ShowAsync();
}

Für die Benutzer stellt sich das wie folgt dar:

Bei der ersten Anmeldung muss außerdem der Zugriff auf die Daten des Benutzers bestätigt werden:

Berechtigungen auf Tabellenebene anpassen

Nur angemeldete Benutzer sollen Nachrichten hinzufügen bzw. löschen können.

Um dies zu gewährleisten, müssen die Insert- und Delete-Rechte der Messages-Tabelle auf "Only Authenticated Users" gesetzt werden.

Außerdem sind in den "Let's Talk"-Apps Änderungen an den Nachrichten nicht zulässig, weshalb das Update-Recht nur für Skripte und Administratoren freigegeben wird:

Damit beim Hinzufügen einer Nachricht auch der Benutzer gespeichert wird, muss eine weitere Zeile im Insert-Skript hinzugefügt werden:

function insert(item, user, request) {
  if (!item.body || item.body.length < 2) {
    request.respond(statusCodes.BAD_REQUEST, 'The message text must be 2 or more characters long.');
    return;
  }

  item.createdAt = new Date();
  item.userId = user.userId;

  request.execute();
}

Durch das Dynamische-Schema-Feature der Mobile Services wird beim nächsten Speichervorgang die Messages-Tabelle um die UserID Spalte erweitert.

Auch das Löschen der Nachrichten soll nur dessen Besitzer erlaubt werden.

Dies kann durch folgendes Delete-Skript der Messages-Tabelle erreicht werden:

function del(id, user, request) {
  var messagesTable = tables.getTable('messages');

  messagesTable.where({
    id: id,
    userId: user.userId
  }).read({
    success: function(results) {
      if (results.length === 0) {
        request.respond(statusCodes.UNAUTHORIZED, 'You can only delete you own messages.');
      }
      else {
        request.execute();
      }
    }
  });
}

Dieses macht eine Lookup-Abfrage auf die Messages-Tabelle und wirft eine Fehlermeldung, wenn der Benutzer versucht eine fremde Nachricht zu löschen.

Wie geht es weiter?

Im nächsten Teil dieser Serie wird die Windows Store App mit einer Microsoft-Account-Authentifizierung via Live SDK erweitert, damit die Benutzer sich automatisch mit ihrem für die Windows Anmeldung genutztem Konto anmelden können.

Beispielanwendung:

Let's Talk - Windows Account Authentifizierung in der Windows Store App

Weitere Informationen:

Slides / Demos zu meinen dotnet Cologne 2013 Sessions #dnc13 #hypermedia #spa #aspnetwebapi

Alexander Zeitler — Sun, 05 May 2013 12:19:02 GMT

Bereits zum 5. Mal fand am vergangenen Freitag die dotnet Cologne in Köln statt. Über 400 Teilnehmer und die Orga haben die Veranstaltung wieder zu einem Highlight der .NET Community gemacht.

Ich hatte die Gelegenheit, zwei Sessions beizutragen:

Hypermedia mit der ASP.NET Web API

REST ist der wohl am häufigsten mißbrauchte Begriff der letzten Jahre. Viele REST-APIs stellen sich bei genauer Betrachtung als klassische CRUD-Services heraus, ohne ein Kernelement von REST zu berücksichtigen: Hypermedia. Der Vortrag zeigt die Umsetzung von Hypermedia APIs mit ASP.NET Web API.

Die Slides finden sich hier:

Hypermedia mit der ASP.NET Web API from Alexander Zeitler

Der Code kann hier heruntergeladen werden.

Single Page Applications – jenseits von “ToDo”

Mit dem ASP.NET and Web Tools 2012.2 Release hat Microsoft nun auch eine Projekt-Vorlage für Single Page Applications in Visual Studio 2012 platziert. Leider geht das Beispiel nicht über die klassische ToDo-App hinaus und auch sonst findet man wenig Dokumentation zum Aufbau von Single Page Applications, die komplexere Szenarien behandeln. In diesem Vortrag wird unter Verwendung individuell zusammengestellter JavaScript-Frameworks die Entwicklung großer Single Page Applications erklärt.

Die Slides finden sich hier.

dotnet Cologne 2013 - Slides und Links zu meinen Sessions

Sascha Dittmann — Sun, 05 May 2013 10:09:00 GMT

Am vergangenen Freitag öffnete die dotnet Cologne bereits zum fünften mal ihre Pforten.
Wie auch schon in den letzten Jahren strömten auch an diesem Tag wieder hunderte von Entwicklern die Räumlichkeiten des Komeds in Köln.
Die Slides bzw. Links zu meiner Microsoft HDInsight Session und der Windows Azure Mobile Services Session von Stefan Lange und mir findet ihr in diesem Blog Post...

Big Data mit Microsoft HDInsight für .NET Entwickler

Abstrakt

Wir leben in einem Datenzeitalter! Nach Schätzungen in 2006, betrug das weltweite "Datenuniversum" ca. 0.18 Zettabytes (10^21 Bytes bzw. 1 Mrd. Terrabyte). In 2011 hat sich dieses Volumen sogar verzehnfacht (1,8 Zettabytes). Somit wird in vielen Anwendungsszenarien das Thema Big Data und Big Processing immer wichtiger. Es fallen sehr viele Daten an, die von immer mehr Benutzern und Systemen konsumiert und ausgewertet werden wollen. Klassische relationale Datenbanksysteme, sowie Statistik- und Visualisierungstools, sind oft nicht in der Lage, derart große Datenmengen zu verarbeiten. Für Big Data kommt daher eine neue Art von Software zum Einsatz, die massiv parallel auf bis zu hunderten oder tausenden von Prozessoren bzw. Servern arbeitet, wie z.B. Microsoft HDInsight. Diese Session liefert einen Überblick über die Grundpfeiler des Frameworks hinter HDInsight und wie Analysen mit JavaScript und .NET Code durchgeführt werden können.

(Level 200)

Slides

SlideShare: dotnet Cologne 2013 - Microsoft HD Insight für .NET Entwickler

Weiterführende Links

Einführung in die Azure Mobile Services

Abstrakt

Die Mobile Services gehören zu den neuesten Azure Technologien und bieten Entwicklern ein solides und sicheres Backend für ihre mobilen Apps. Ob Datenbankzugriff, Authentifizierung, Server-seitige gescriptete Logik oder Notifications, alles kann bemerkenswert einfach konfiguriert und in der eigenen Anwendung genutzt werden. Stefan Lange zeigt wie elegant sich die Azure Mobile Services in Windows 8 und Windows Phone 8 einbinden lassen, aber auch wie man sie ganz unabhängig davon nutzen kann.

(Level 200)

Slides

Gemeinsam mit Stefan Lange habe ich die Windows Azure Mobile Services auf der dotnet Cologne 2013 vorgestellt:

SlideShare: dotnet Cologne 2013 - Windows Azure Mobile Services

Weiterführende Links

mite: Erfahrungen nach einem Monat

Fabian Deitelhoff — Sat, 04 May 2013 11:00:47 GMT

Ende März hatte ich einen Artikel über meine Suche nach einer guten Zeiterfassung geschrieben. Damals habe ich mich für mite entschieden, dass viele Funktionen in einer einfach zu bedienenden Web-Oberfläche anbietet. Nun ist etwas mehr als ein Monat vergangen und mein kostenloser Testmonat ist abgelaufen. Da steht natürlich die Frage im Raum, ob ich meinen [...]

Warum fragmentiert die binäre Serialisierung

Klaus Bock — Fri, 03 May 2013 15:49:00 GMT

... oder; die Krux mit den automatischen Größen von Streams.
Da in der heutigen Zeit, vor allem in der Welt von verwaltetem Code, kaum noch eigene proprietäre Dateiformate Anwendung finden, werden die Allerwenigsten auf dieses Problem stoßen. Auch die Tatsache, dass für beinahe jede Anforderung ein Framework oder eine Bibliothek vorhanden ist, trägt mit Sicherheit dazu bei, solche elementaren Probleme von der Bildfläche verschwinden zu lassen. Für eine ganze Reihe von Entwicklern hört der Gedanke an binäre Serialisierung auf, wenn sie ein Framework wie BSON oder Protocol Buffers zur Anwendung bringen können. Dies soll keine Kritik und schon gar keine negative sein. Ganz im Gegenteil. Diese Frameworks erleichtern die tägliche Arbeit in vielerlei Hinsicht. Verbergen leider aber auch die eigentliche Problematik der Serialisierung. Für mich gehört dieses Thema nach wie vor zu einem der interessantesten in der Softwareentwicklung. Jetzt aber zurück zum eigentlichen Thema.

Für ein aktuelles Projekt verwende ich ein eigenes binäres Dateiformat, in das Datenblöcke in serialisierter und komprimierter Form als byte-Arrays geschrieben werden. Während der Testphase auf einem Livesystem stellte ich fest, dass die Dateigröße überproportional zum Inhalt anwuchs. Zunächst maß ich dem Verhalten keine besondere Bedeutung bei, da ein ähnliches Verhalten auch bei Formaten wie etwa den Access Datenbankdateien oder den Dateien der Windows Registrierung ebenfalls auftritt. Insgesamt ließ mich das “Problem” aber nicht in Ruhe. Nachdem ich mir eine der Dateien im Hex-Format angesehen hatte, war schnell klar, was dem Problem zugrunde lag:
Zwischen den einzelnen Datenblöcken wurde immer eine ganze Menge an 0-Byte-Zeichen geschrieben.

Das Resultat war ersichtlich. Aber woher kam dieses Verhalten?
Wie bereits Eingangs erwähnt, werden die Datenblöcke nach dem serialisieren auch komprimiert. Dazu wird die Klasse DeflateStream der Frameworks verwendet. Diese Klasse komprimiert den Inhalt eines Stream in einen anderen. Genau da entstand das Problem.
Das Problem ist vielmehr eine Eigenart der DeflateStream Klasse in Verbindung mit einem MemoryStream. Das Verhalten lässt sich am einfachsten mit einem kleinen Beispiel verdeutlichen. Folgend wird eine Liste aus zufälligen Zeichenfolgen in ein Byte-Array serialisiert und anschließend komprimiert. Mit der Variablen numberOfEntries kann die Anzahl der Einträge in der Liste und dadurch indirekt die Länge des komprimierten Datenblocks gesteuert werden. In der Variablen realLength wird die Anzahl der tatsächlich verwertbaren Bytes im Array ausgegeben. Bei einer geringen Anzahl von Einträgen in der temporären Liste, ist der Wert von realLength immer deutlich kleiner als die Länge des erzeugten Arrays output. Erst ab etwa 130 Einträge in der temporären Liste tritt dieses Verhalten nicht mehr auf. Ab dieser Größe wird die Ausgabe ohne nachgestellte 0-Byte-Zeichen erzeugt.

var numberOfEntries = 10;
var chars = "abcdefghijklmnopqrstuvwxyz";
var tempList = new List<string>(numberOfEntries);
var random = new Random();
for (int i = 0; i < numberOfEntries; i++)
{
    var start = random.Next(0, chars.Length - 1);
    var length = random.Next(start + 1, chars.Length) - start;
    var entry = chars.Substring(start, length);
    tempList.Add(entry);
}
var buffer = Encoding.Default.GetBytes(string.Join("|", tempList));
byte[] output = null;
using (var instream = new MemoryStream(buffer))
{
    using (var outStream = new MemoryStream())
    {
        using (var compress = new DeflateStream(outStream, CompressionMode.Compress))
        {
            instream.CopyTo(compress);
        }
        output = outStream.GetBuffer();
    }
}
// Die Länge des Ausgabe-Arrays
// Unter 130 Einträgen wird fast immer eine Länge von 256 erzeugt.
var arrayLength = output.Length;
// Die tatsächliche Anzahl an verwertbaren Bytes im Array
var realLength = output.Count(b => b > byte.MinValue);

Im obigen Beispiel, wird im zweiten using-Block der MemoryStream für die Ausgabe initialisiert, der nach dem Verlassen des innersten using-Blocks die komprimierten Daten enthält. Initial wird hier ein leerer Stream mit Capacity und Length 0 erzeugt. Der DeflateStream kopiert seinen Inhalt in diesen Stream und legt dabei so lange eine Länge von 256 Bytes fest, bis diese Größe überschritten wird. Erst dann wird der Ausgabestream mit der korrekten Länge des Inhalts des DeflateStream erzeugt. Das bedeutet als Resultat für die, aus den Ergebnissen erzeugte, Datei:

Je mehr Datenblöcke aus Inhalten mit geringer Größe erzeugt werden, desto fragmentierter ist das Ergebnis.

Zur Lösung dieses “Problems”, oder besser unschönen Verhaltens, stehen jetzt zwei Ansatzpunkte zur Auswahl:

Am Anfang des Prozesses, in dem der Konstruktor des Ausgabestreams mit einer kleineren Kapazität initialisiert wird.
Am Ende des Prozesses, in dem die Ausgabe bearbeitet wird.

Den ersten Ansatzpunkt habe ich verworfen, da die Größe des komprimierten Inhalts nicht genau vorhergesagt werden kann. Auch beim Versuch der Initialisierung mit einer Kapazität die klein genug ist, wurde im Test oft genug die Ausgabe mit 256 Bytes im Array erzeugt.

Zur Umsetzung des zweiten Ansatzpunkts, habe ich mich für eine Erweiterungsmethode entschieden, die ähnlich wie die TrimEnd-Methode der String-Klasse, alle nachgestellten 0-Byte-Zeichen aus dem Ausgabe-Array entfernt.

internal static byte[] TrimEnd(this byte[] bytes)
{
    var startLength = bytes.GetLength(0);
    var startPos = startLength - 1;
    var trimPos = startPos;
    for (int i = startPos; i > -1; i--)
    {
        if (bytes[i] > byte.MinValue)
        {
            trimPos = i;
            break;
        }
    }
    if (trimPos == startPos)
    {
        return bytes;
    }
    var trimmedLength = trimPos + 1;
    var trimmed = new byte[trimmedLength];
    Array.Copy(bytes, trimmed, trimmedLength);
    return trimmed;
}

Wenn jetzt beim Abruf des Inhalts diese Erweiterungsmethode aufgerufen wird, ist das Ergebnis jedes mal wie erwartet. Das Problem der Fragmentierung innerhalb der Datei hat sich somit erledigt.

output = outStream.GetBuffer().TrimEnd();

Fazit:

Der bewusste Verzicht auf bestehende Frameworks und Bibliotheken ist oft mit einem, manchmal deutlichem, Mehraufwand verbunden. Besonders dann, wenn unvorhergesehene Probleme oder Eigenarten auftauchen.
Andererseits verschaffen mir gerade diese unvorhersehbaren Situationen einen tieferen Einblick in die jeweilige Materie und somit meist ein besseres Verständnis für das eigentliche Problem.
Wie ich bereits weiter oben gesagt habe: Frameworks für spezielle Anforderungen sind eine feine Sache und meist auch eine große Arbeitserleichterung.
Dennoch wird es immer wieder Entwickler geben die einfach aus Neugier, was ohne sie machbar ist, darauf verzichten.

Technorati-Tags: clr | c# | serialization | binary

Exclusives Video von meiner Hochzeit ;)

Oliver Scheer — Fri, 03 May 2013 09:40:04 GMT

So ungefähr war das auf meiner Hochzeit … NOT … ...read more...(read more)

Nachwuchs gesucht: MACH Karriere als Technologieberater (m/w)

Oliver Scheer — Fri, 03 May 2013 09:32:35 GMT

Microsoft Deutschland rekrutiert derzeit wieder Hochschulabsolventen für das Einstiegsprogramm MACH (Microsoft Academy for College Hires). Wir suchen zum 1. Oktober 2013 IT-begeisterte Absolventen der (Wirtschafts-)Informatik oder ähnlichen Fachrichtungen...(read more)

Windows Azure Mobile Services - Busy Indicator für Windows Store Apps

Sascha Dittmann — Fri, 03 May 2013 07:18:00 GMT

Nichts ist schlimmer für den Benutzer einer Anwendung bzw. App, als vor dem Gerät zu sitzen und nichts scheint zu passieren.
Deshalb wird heute die "Let's Talk" Windows Store App mit einem Busy Indicator erweitert.
Wer neu zu meiner WIndows Azure Mobile Services Serie hinzugekommen ist, sollte sich vorher jedoch ansehen wie der Mobile Service angelegt, die Windows Store App erstellt und eine serverseitige Eingabevalidierung implementiert worden ist...

Ein HttpMessageHandler für den Busy Indicator

Um sich in die Client-Server Kommunikation des MobileServiceClient-Objektes einklinken zu können, muss zuerst eine Klasse erstellt werden, die von der abstrakten Klasse HttpMessageHandler ableitet.

Genauer gesagt muss diese neue Klasse von der DelegatingHandler-Klasse ableiten, da sie in ihrer SendAsync-Methode wiederum SendAsync aufrufen muss.

Somit erreicht man den gewünschten Effekt, dass die Nachrichten nur durchgereicht und nicht endgültig verarbeitet werden.

Eine einfache Variante des Busy-Handlers könnte dann wie folgt aussehen:

public class BusyHandler : DelegatingHandler
{
  private int _callCount;
  private readonly Action<bool> _busyIndicator;

  public BusyHandler(Action<bool> busyIndicator)
  {
    _busyIndicator = busyIndicator;
  }

  protected override async Task<HttpResponseMessage> SendAsync(
    HttpRequestMessage request, CancellationToken cancellationToken)
  {
    // update the count by one in a single atomic operation. 
    // If we get a 1 back, we know we just went 'busy'
    var outgoingCount = Interlocked.Increment(ref _callCount);
    if (outgoingCount == 1)
    {
      _busyIndicator(true);
    }

    var response = await base.SendAsync(request, cancellationToken);

    // decrement the count by one in a single atomic operation.
    // If we get a 0 back, we know we just went 'idle'
    var incomingCount = Interlocked.Decrement(ref _callCount);
    if (incomingCount == 0)
    {
      _busyIndicator(false);
    }

    return response;
  }
}

Änderungen am ViewModel

Damit in der View der Busy Indicator ein- bzw. ausgeblendet werden kann, muss als nächstes das ViewModel entsprechend erweitert werden.

Dazu habe ich eine IsBusy-Eigenschaft im Interface hinzugefügt ...

public interface IMainPageViewModel
{
  ObservableCollection Messages { get; }
  String MessageText { get; set; }
  Message SelectedMessage { get; set; }

  Boolean IsBusy { get; }

  DelegateCommand SendMessageCommand { get; }
  DelegateCommand DeleteMessageCommand { get; }
  DelegateCommand RefreshCommand { get; }
}

... und diese entsprechend implementiert.

private Boolean _isBusy;
public Boolean IsBusy
{
  get { return _isBusy; }
  set { SetProperty(ref _isBusy, value); }
}

Danach kann der BusyHandler zur Kommunikationspipeline des MobileServiceClient-Objektes hinzugefügt werden.

Dazu stellt die MobileServiceClient-Klasse den entsprechenden Konstruktor zur Verfügung:

_mobileServiceClient = new MobileServiceClient(
  App.MobileServiceUrl,
  App.MobileServiceKey,
  new BusyHandler(busy => IsBusy = busy));

Änderungen an der View

Zu guter Letzt muss in der View nur noch der entsprechende XAML Code hinzugefügt und an die IsBusy-Eigenschaft des ViewModels gebunden werden:

<Border Grid.ColumnSpan="2" Grid.RowSpan="3" 
        Visibility="{Binding IsBusy, 
        Converter={StaticResource BooleanToVisibilityConverter}}">
  <ProgressRing IsActive="true" Style="{StaticResource ProgressRingStyle}" />
</Border>

Für lesbareren Code, und zur Wiederverwendbarkeit in weiteren Views, bietet sich außerdem an die Style-Einstellungen des ProgressRing-Controls auszulagern:

<Style x:Name="ProgressRingStyle"  TargetType="ProgressRing">
  <Setter Property="HorizontalAlignment" Value="Center" />
  <Setter Property="VerticalAlignment" Value="Center" />
  <Setter Property="Foreground" Value="{StaticResource AccentColor}" />
  <Setter Property="Width" Value="100" />
  <Setter Property="Height" Value="100" />
</Style>

Wie geht es weiter?

Im nächsten Teil dieser Serie wird die Windows Store App mit einer Microsoft-Account-Authentifizierung erweitert.
Außerdem werden die Benutzer nur noch ihre eigenen Nachrichten löschen können.

Beispielanwendung:

Let's Talk - Busy Indicator

Weitere Informationen:

dotnet-forum.de - Developer Blogs

RavenDb 2.0 on IIS with Windows Authentication returns a 401 Unauthorized #ravendb

SetWindowHookEx - cool oder nur Fingerübung?

Für alle Trekkies

Surface Pro in Deutschland verfübar ab dem 31.05.

TFS Incremental build und writeable files

All I wanted was a pyramid…

Bing mit Star Trek Easter Egg

Interessante Trainings zu Visual Studio 2012 in der Microsoft Virtual Academy

Gewinnen durch Vorläufigkeit

Windows Phone 8 Trainingskit

video2brain - Windows Store Apps mit XAML und C# – Das große Training + Geek-Gewinnspiel

IIS & Windows Authentication – Troubleshooting mit Negotiate & NTLM

dotnet Cologne 2013 – Windows Azure Mobile Services

TFS 2012 Lab Management mit Windows XP VMs

Json-Online-Tools: Viewer & Json2Csharp Generator

Coded UI Test unter Windows 8

Mehr verdienen durch Experiment

Windows Azure Mobile Services - Windows Account Authentifizierung für Windows Store Apps

App im Live Connect Developer Center registrieren

Änderungen bei den Mobile Services

Änderungen an der Windows Store App

Berechtigungen auf Tabellenebene anpassen

Wie geht es weiter?

Slides / Demos zu meinen dotnet Cologne 2013 Sessions #dnc13 #hypermedia #spa #aspnetwebapi

Hypermedia mit der ASP.NET Web API

Single Page Applications – jenseits von “ToDo”

dotnet Cologne 2013 - Slides und Links zu meinen Sessions

Big Data mit Microsoft HDInsight für .NET Entwickler

Abstrakt

Slides

Weiterführende Links

Einführung in die Azure Mobile Services

Abstrakt

Slides

Weiterführende Links

mite: Erfahrungen nach einem Monat

Related posts:

Warum fragmentiert die binäre Serialisierung

Fazit:

Exclusives Video von meiner Hochzeit ;)

Nachwuchs gesucht: MACH Karriere als Technologieberater (m/w)

Windows Azure Mobile Services - Busy Indicator für Windows Store Apps

Ein HttpMessageHandler für den Busy Indicator

Änderungen am ViewModel

Änderungen an der View

Wie geht es weiter?