Bei Microsoft Press ist heute das neue Buch von Steve Fox “Developing Microsoft SharePoint Applications Using Windows Azure” erschienen.

Das Buch zeigt die unterschiedlichsten Möglichkeiten auf, wie man SharePoint 2010 mit Windows Azure in Einklang bringen kann und somit optimale Anwendungsszenarien erstellt. Die Review des Buches hat Andrew Connell (SharePoint MVP) gemacht. Die Review von einem der wohl bekanntesten Menschen im SharePoint Umfeld fiel sehr positiv aus, wodurch man davon ausgehen kann, dass auch dieses Buch eine sinnvolle Investition ist.

Da ich aktuell noch mit „SharePoint 2010 Workflows in Action“ von Manning beschäftigt bin, reiht sich Steve Fox’s Buch direkt danach in die “To Read” Queue ein.

Was erwartet einen Leser in „Developing Microsoft SharePoint Applications Using Windows Azure”?

In den 10 Kapiteln des Buches geht es von der Einführung in die SharePoint und Azure Thematik über SQL Azure, Azure Blob Storage, BCS, BI hin zu Security relevanten Themen.

Hier die genaue Kapitelauflistung

• Chapter One: Welcome to SharePoint and Windows Azure
• Chapter Two: Getting Started with Windows Azure and SharePoint
• Chapter Three: Consuming SQL Azure Data in SharePoint
• Chapter Four: SQL Azure and Advanced Web Part Development
• Chapter Five: Using Windows Azure BLOB Storage in SharePoint Solutions
• Chapter Six: Integrating WCF Services and SharePoint
• Chapter Seven: Business Intelligence and SQL Azure
• Chapter Eight: Using the Windows Azure AppFabric Service Bus and SharePoint
• Chapter Nine: Advanced Uses of WCF Services in SharePoint and Office
• Chapter Ten: Securing Your SharePoint and Windows Azure Solutions

Ich bin schon gespannt auf meine Kopie und werde euch hier darüber berichten.

Viel Spass beim Lesen.

Die DNUG Braunschweig trifft sich am 15.06.2011 um 19:00 Uhr im Restaurant Zucker (Tagungsraum). Uns kommt Daniel Fisher mit einem Vortrag über ASP.NET MVC besuchen.

Abstract:
Die neue Plattform zum Entwickeln von Web-Anwendungen auf der .NET Plattform bringt viele neue und produktivitätssteigernde Features mit sich. Dabei bleibt es nicht aus, dass einige alte Konzepte über Bord geworfen werden. Die Lokalisierung von Web-Anwendungen wie sie zu *klassischen ASP.NET* Zeiten ablief ist eines davon. Daniel Fisher zeigt Ansätze und Lösungen aus der MVC-Praxis für den Alltag.

BIO:
Daniel entwickelt seit 1995 Software (seit 1999 auf der .NET Plattform) und verfügt über Projekterfahrung als Entwickler, Architekt, Projektleiter und Berater aus den Branchen Versicherung, Großhandel, Mobilfunk und Bankwesen. Er ist Leiter der .NET-Entwickler-User-Group Niederrhein (www.netug-niederrhein.de) und Vorstand der Just Community e.V. (www.justcommunity.de), dem Veranstalter des größten regionalen Community-Events für Software-Entwickler und IT-Professionals (www.nrwconf.de). Sie finden sein Blog unter www.lennybacon.com.

Wie immer ist die Veranstaltung kostenlos! Weitere Informationen zur DNUG Braunschweig können hier gefunden werden: http://www.dotnet-braunschweig.de

Wer Lösungen für Office 365 entwickeln möchte, sollte sich die aktuellste Version vom Office 365 Developer Training Kit herunterladen. Im Tarining Kit werden neben SharePoint Online auch die Möglichkeiten für Entwickler mit Exchange Online und Lync Online aufgezeigt.

Das Training Kit besteht wie immer aus

• Sildes
• Hand On Labs
• Demos

Unter http://www.microsoft.com/download/en/details.aspx?displaylang=en&id=14889 könnt Ihr euch das Office 365 Developer Training Kit kostenlos downloaden.

LINQ to SharePoint erlaubt es SharePoint Entwicklern auf den lokalen SharePoint unter Verwendung eines generierten LINQ Contextes streng typisiert auf die Daten in SharePoint zuzugreifen. Doch gerade im täglichen Geschäft werden hierbei immer wieder Fehler gemacht, die leider dazu führen, dass die Anwendungen welche auf LINQ to SharePoint basieren auf Produktivsystem nicht oder nicht korrekt funktionieren.

Aus diesem Grund habe ich einfach mal einen, meiner Meinung nach, sinnvollen Weg zur Verwendung von LINQ to SharePoint identifiziert, welchen ich hier erläutern möchte.

Die Probleme in vielen Projekten

Wenn man mit LINQ to SharePoint arbeiten möchte, muss man zunächst den DataContext erstellen, dieser Datacontext ist der zentrale Punkt (LinqProvider) für den Zugriff mittels LINQ auf SharePoint als Backend. Genau an diesem Punkt werden oftmals schon die ersten und gravierendsten Fehler gemacht.

Problem 1: Kontinuierliche Erstellung des DataContextes fehlt

Der LINQ to SharePoint DataContext sollte automatisiert erstellt werden, darüber hinaus sollte er vor dem eigentlichen Build Vorgang der custom Solution erstellt werden.

Lösung 1:

Der Aufruf von SPMetal.exe muss im PreBuild-Event des gewünschten SharePoint Projektes integriert sein.

“C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\bin\SPMetal.exe” /web:http://youtSPwebURL /code:TargetSourceFile.cs /language:cshar /namespace:TargetName.Space

Wie im Screenshot zu sehen ist, habe ich beim CodeParameter die MSBuild Variable $(ProjectDir) verwendet, welche gefolgt von einem Dateinamen dafür sorgt, das mein LINQ to SharePoint Context an der richtigen Stelle auf der Festplatte erstellt wird. Durch die Integration des SPMetal.exe aufrufes in das PreBuild-Event, kann sicher gestellt werden, dass die aktuelle Solution stets gegen die aktuellste Version des DataContextes kompiliert wird.

Problem 2: Der Scope des DataContext ist zu groß

In vielen Demos und Projekten wird immer der folgende SPMetal.exe Aufruf verwendet oder gezeigt

SPMetal.exe /web:http://youtSPwebURL /code:TargetSourceFile.cs /language:cshar /namespace:TargetName.Space

Hierbei wird der LINQ Context für sämtliche Listen erstellt, was im Umkehrschluss bedeutet, dass die erstellte Lösung meistens unnötige Angriffsflächen bietet. Durch den gezeigten Aufruf von SPMetal.exe werden auch für die Listen Proxy-Klassen erstellt, welche im Projekt- oder Produktscope gar keine Rolle spielen. Anwender mit entsprechenden Rechten auf der SharePoint Seite können nun durch Löschen von Spalten die Funktionalität des LINQ Contextes und somit auch unserer Anwendung beeinträchtigen bzw. gefährden.

Lösung 2:

An SPMetal.exe kann man mit dem Parameter parameters eine eigene XML Konfiguration mitgeben, so dass nur explizit angegebene Listen in den LINQ to SharePoint Kontext aufgenommen werden.

Der korrekte SPMetal Aufruf würde demnach wie folgt aussehen

SPMetal.exe” /web:http://youtSPwebURL /code:TargetSourceFile.cs /language:cshar /namespace:TargetName.Space /parameters: $(ProjectDir)MyCustomLinqConfiguration.xml

Auch an dieser Stelle wieder die Verwendung der $(ProjectDir) Variable von MSBuild, um die XML-Datei aus der aktuellen Projektstruktur zu verwenden.

Was alles im LINQ to SharePoint Parameters File definiert werden kann, kann man der MSDN entnehmen http://msdn.microsoft.com/en-us/library/ee535056.aspx

Problem 3: Vorhandene / manuell erstellte Listen

Auch wenn man die in den LINQ Context aufzunehmenden Listen einschränkt besteht natürlich immer noch die Gefahr, dass diese sich auf dem Staging- oder Developmentsystem vom Produktivsystem unterscheiden. Bei einer solchen Unterscheidung ist die korrekte Funktionsweise des LINQ to SharePoint Contextes ebenfalls nicht gewährleistet.

Lösung 3:

Um die LINQ to SharePoint Proxy-Klassen wirklich richtig zuverlässig zu erstellen, bieten sich hier allerdings bekannte Funktionalitäten aus dem SharePoint an. Zunächst sollten die benötigten Listen in der custom Solution erstellt werden (deklarativ oder programmatisch spielt an dieser Stelle keine Rolle)

Diese ContentType und Listendefinitionen müssen dann über ein separates Feature in SharePoint deployet werden.

Dieses „separate Feature“ kann man auch als Core-Feature bezeichnen. Durch eine Feature Dependency auf dem Feature welches die LINQ to SharePoint Lösung verteilt, muss dieses Core-Feature also als Feature Dependency eingetragen werden.

Optional kann das Core Feature an dieser Stelle dann noch als „Hidden-Feature“ ausgerollt werden. Hierbei ist allerdings zu beachten, dass das Hidden-Feature selbst keine Feature-Dependencies haben darf!

Fazit

Beachtet man meiner Meinung nach diese 3 Regeln, kann man mit LINQ to SharePoint schöne und robuste Solutions bauen, welche die Vorteile von LINQ to SharePoint gegenüber dem „Old-School-Way“ mitbringen.

Happy LINQ’in

Neben dem großen Release von Office 365 hat Microsoft auch einige ServicePacks veröffentlicht. Ab heute sind unter anderem die ServicePacks für

• Microsoft SharePoint Foundation 2010
• http://www.microsoft.com/downloads/details.aspx?FamilyId=0F56EBFB-183F-4F4D-9D41-DF1E5ACEB8%2093
• Microsoft SharePoint Server 2010
• http://www.microsoft.com/downloads/details.aspx?FamilyId=B9FCDC42-EEA4-4C08-9169-A9A73E55B8D4
• Microsoft Office 2010
• x64 - http://www.microsoft.com/downloads/details.aspx?FamilyId=E9F3C2D0-C321-4910-A4CE-B2F294B42D65
• x32 - http://www.microsoft.com/downloads/details.aspx?FamilyId=9D2E1282-8B69-418B-AFA0-9F61239EC8BE
• FAST Search Server
• http://www.microsoft.com/downloads/details.aspx?FamilyId=CC6A55F0-6986-4973-A55D-01DE517904D8
• Office WebApps
• Project Server 2010
• http://www.microsoft.com/downloads/details.aspx?FamilyId=6790E0B5-3C2A-473A-A3D0-F408D01CB71A
• Search Server 2010
• http://www.microsoft.com/downloads/details.aspx?FamilyId=EF5D7578-49F3-442A-8A25-CDCBD8B5F5F7
• SharePoint Designer 2010
• x64 - http://www.microsoft.com/downloads/details.aspx?FamilyId=F24FCD1E-B776-4C84-A2DD-CFD4417D7AE5
• x32 - http://www.microsoft.com/downloads/details.aspx?FamilyId=277C4FAD-BE9B-4F60-B7AE-76BEC51069BE

Die komplette Auflistung aller verfügbaren ServicePacks findet Ihr unter http://blogs.technet.com/b/office_sustained_engineering/archive/2011/06/28/announcing-office-2010-and-sharepoint-2010-service-pack-1-availability.aspx

Was ist im Service Pack 1

In SharePoint sind neben den bis heute veröffentlichten CUs folgende Verbesserungen angegeben

Microsoft SharePoint Foundation 2010 SP 1

• Improved support for Internet Explorer 9.
• Recycle bin: Lets you restore a site collection or a web that was deleted.
• Remote Backup Systems (RBS) and shallow copy can decrease downtime and increase efficiency by moving pointers to databases instead of moving databases.
• You can see which folders are taking up valuable space with the improved Storage Management feature in site settings.
• Support for Microsoft SQL Server 2011.

SharePoint Server 2010 SP 1

• Verbesserte Unterstützung für Internet Explorer 9.
• Papierkorb: Sie können eine gelöschte Websitesammlung oder Website wiederherstellen.
• Remote Backup Systems (RBS) und flaches Kopieren können die Ausfallzeiten verringern und die Effizienz steigern, indem die Zeiger auf die Datenbanken und nicht die Datenbanken selbst verschoben werden.
• Mithilfe der verbesserten Speicherverwaltungsfunktion in den Websiteeinstellungen können Sie sehen, welche Ordner wertvollen Speicherplatz belegen.
• Unterstützung für Microsoft SQL Server 2011
• Ein robusterer Search-Host-Verteilungsdienst verbessert Fehlerbehebung und Leistung während der Suchdurchforstung.
• Stellt Sicherungs- und Wiederherstellungsfunktionen zum Wiederherstellen gelöschter Websitesammlungen und Websites bereit.

Viel Spass beim Download und Update :P

Es ist soweit!

Office 365 hat heute offiziell den Betastatus verlassen und ist frei zugänglich. Mit Office 365 haben neben SharePoint 2010 auch Exchange 2010 und der Lync Server den Weg in den Cloud gefunden. Angereichert werden die bekannten Serverprodukte durch die neuen Office WebApps angereichert.

Die Office WebApps bieten die altbekannten Officeprogramme als Webanwendung an, so dass kein FatClient mehr benötigt wird. Darüber hinaus darf natürlich auch der WP7 Support nicht fehlen, der durch den bereits vorhandenen Office Hub realisiert wird.

Alles in Allem stellt Office 365 eine mehr als produktivitätssteigernde Plattform für eine breite Usergruppe an. Gerade der SharePoint bringt sich in Office 365 sehr gut ein und bietet die bekannten Features von der OnPremise Version nun auch in der Cloud. (Natürlich sind wir Entwickler limitiert auf Sandboxed Solutions) dennoch können wir damit sehr viele Anwendungsszenarien nun mit SharePoint in Office 365 (und somit in der Cloud :P) anbieten.

Auf www.Office365.de kann man sich einen Office 365 Account erstellen und sich einen Überblick über die unterschiedlichen Services verschaffen. Ich selbst setze Office365 schon seit langem im privaten Bereich ein, Office 365 bietet mir alle Möglichkeiten meine Aktivitäten in der Community zu verwalten und zu organisieren. Doch auch im Business wird Office365 seinen Weg finden, weil die hohen Anforderungen an die Infrastruktur nun nicht mehr von jedem Unternehmen selbst gestellt werden müssen.

Ein Test von Office 365 lohnt sich meiner Meinung nach auf jeden Fall, daher nichts wie ab auf die Office 365 Page und einen Account erstellen.

Viel Spaß mit Office 365

Ab heute gibt es das Service Pack 1 für MS Office und SharePoint 2010 zum Download:

• Microsoft SharePoint Foundation 2010
  • http://www.microsoft.com/downloads/details.aspx?FamilyId=0F56EBFB-183F-4F4D-9D41-DF1E5ACEB8%2093
• Microsoft SharePoint Server 2010
  • http://www.microsoft.com/downloads/details.aspx?FamilyId=B9FCDC42-EEA4-4C08-9169-A9A73E55B8D4
• Microsoft Office 2010
  • x64 - http://www.microsoft.com/downloads/details.aspx?FamilyId=E9F3C2D0-C321-4910-A4CE-B2F294B42D65
  • x32 - http://www.microsoft.com/downloads/details.aspx?FamilyId=9D2E1282-8B69-418B-AFA0-9F61239EC8BE
• FAST Search Server
  • http://www.microsoft.com/downloads/details.aspx?FamilyId=CC6A55F0-6986-4973-A55D-01DE517904D8
• Office WebApps
• Project Server 2010
  • http://www.microsoft.com/downloads/details.aspx?FamilyId=6790E0B5-3C2A-473A-A3D0-F408D01CB71A
• Search Server 2010
  • http://www.microsoft.com/downloads/details.aspx?FamilyId=EF5D7578-49F3-442A-8A25-CDCBD8B5F5F7
• SharePoint Designer 2010
  • x64 - http://www.microsoft.com/downloads/details.aspx?FamilyId=F24FCD1E-B776-4C84-A2DD-CFD4417D7AE5
  • x32 - http://www.microsoft.com/downloads/details.aspx?FamilyId=277C4FAD-BE9B-4F60-B7AE-76BEC51069BE

Alle Infos, was in den Service Pack enthalten sind, findet Ihr bei den Links. Außerdem ist heute Office 365 released wurden. Endlich! :-)

Wenn man eigene Lösungen auf SharePoint erstellt, steht man hin und wieder vor der Frage wo man die anwendungsweiten Einstellungen speichern soll. Grundsätzlich eignet sich das Propertybags des entsprechenden Webs dafür sehr gut. Wenn die eigene Lösung jedoch aus mehreren Komponenten besteht die auch auf dem Fram-Scope ausgerollt werden, so macht es mehr Sinn die Settings im Hierarchical Object Store von SharePoint abzuspeichern.

Der Hierarchical Object Store bietet eine entsprechende API um Objekte zu speichern, zu lesen oder zu löschen. Persistiert werden die Objekte in der SharePoint Configuration Database.

Die API des Hierarchical Object Stores befindet sich im Namespace Microsoft.SharePoint.Administration, durch einfaches ableiten einer Klasse von Microsoft.SharePoint.Administration.SPPersistedObject und bereitstellen der zu speichernden Einstellung als öffentliche Felder, ist bereits der Großteil erledigt. Die öffentlichen Felder müssen jedoch noch mit dem Persisted Attribut (ebenfalls aus Microsoft.SharePoint.Administration) versehen werden.

Neue Objektinstanzen speichern

Das eigentliche persistieren einer Objektinstanz ist denkbar einfach.

Als erstes wird eine neue Objektinstanz der Klasse MyDomainSettings erstellt. Hierbei ist es wichtig dass ein eindeutiger Identifier an den Konstruktor übergeben wird.

Der zweite Parameter wird dazu verwendet um im Hierachial Object Store (HOS) den Parent-(Konten) des zu speichernden Objektes zu finden. Die aktuelle SharePoint Farm Instanz ist das RootObjekt des HOS.

Nach dem Setzen der jeweiligen Einstellungen kann die neue Objektinstanz durch einen Aufruf der Methode Update() im HOS gespeichert werden.

Vorhandene Instanzen finden

Das Root Objekt des HOS – Die lokale SPFarm Instanz stellt mit GetObject die Methode bereit, welche genutzt werden kann, um vorhandene, persistierte Objektinstanzen zu finden.

Der Update Vorgang einer vorhandenen Instanz funktioniert analog zum Erstellen einer neuen Instanz durch einfaches setzen der Properties und aufrufen der Update Methode, daher habe ich mir die Implementierung an dieser Stelle gespart :D

Löschen von vorhandenen Instanzen

Beim Löschen einen vorhandenen Objeketinstanz kann man sich der geerbten Methode Delete betätigen, allerdings muss nach dem Call der Delete Methode noch die Methode Unprovision aufgerufen werden, damit die Fragmente aus der ConfigDatabase entfernt werden. Erst nach dem Call der Unprovision Methode gilt das Objekt als korrekt gelöscht.

Fazit

Der Hierarchical Object Store bietet eine komfortable und einfache Lösung Werte in der ConfigDatabase von SharePoint zu persistieren. Leider findet man den HOS nur in wenigen Projekten obwohl er doch einen täglichen Bedarf in Softwareprojekten bedienen kann.

This post is powered by www.Giza-Blog.de |
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

This post is powered by www.Giza-Blog.de |
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

A nice tool on codeplex to combine and minifier several JavaScript files:

Combres - WebForm & MVC Client-side Resource Combine Library – Home

• Open the Package Manager Console (Tools > Library Package Manager > Package Manager Console)
• In the command window:
  • If you work with ASP.NET MVC: enter Install-Package Combres.Mvc
  • If you work with ASP.NET WebForm: enter Install-Package Combres

• Delete the generated file AppStart_Combres.cs
• Remove the reference to the assembly WebActivator
• Open global.asax code-behind file
  • Import Combres namespace, i.e. using Combres;
  • Add this to the first line of either RegisterRoutes() or Application_Start(): RouteTable.Routes.AddCombresRoute("Combres");

• Open App_Data/Combres.xml (this should be auto-created when you install the Combres NuGet package)
• Add/remove resource sets, resources etc. as per your need. See this article for more information.

• Open any view page (e.g. master page) which need to reference JS/CSS resource sets defined in Combres.xml
• Add the followings:

<%= WebExtensions.CombresLink("siteCss") %>  
<%= WebExtensions.CombresLink("siteJs") %>

Ich wusste ja schon immer, dass ich viel zu viele E-Mails bekomme, aber das es soviele sind, dass mein “mitwachsender Posteingang” bei Hotmail sich schon beschwert?

SOFORTIGE BEACHTUNG ERFORDERLICH

Sehr geehrter Kunde,

Ihr Windows Live Hotmail®-Konto ist sehr schnell angewachsen.

Wenn es weiterhin mit dieser Geschwindigkeit wächst, können Sie in Zukunft keine Nachrichten empfangen. Hier finden Sie einige Vorschläge, mit deren Hilfe Sie Ihr Konto verwalten können.

1. Erstellen Sie ein Archiv - Erstellen Sie auf der Festplatte des PCs einen Ordner, in dem Sie große Anlagen speichern können. Löschen Sie diese nach dem Speichern aus dem Posteingang. Auf diese Weise gehen die Anlagen nicht verloren, und die Größe des Posteingangs wird entsprechend reduziert.
2. Lassen Sie Filter für sich arbeiten- Wussten Sie schon, dass Sie Ihr Hotmail-Konto so einrichten können, dass Junk-E-Mails sofort gelöscht werden? Wählen Sie "Optionen" aus, und klicken Sie dann auf "Filter und Berichte". Wählen Sie im Bereich "Löschen von Junk-E-Mails" die Option "Sofort" aus, um alle Junk-E-Mails sofort zu löschen. Klicken Sie anschließend einfach auf "Speichern".
3. Löschen Sie zahlreiche E-Mails gleichzeitig- Wechseln Sie zu den Ordnern "Junk" und "Leeren", und leeren Sie sie, indem Sie auf der Aktionsleiste auf die Schaltfläche "Leeren" klicken.

Wenn Sie weitere Fragen haben, lesen Sie das Hilfethema über den Hotmail-Speicher.

Mit freundlichen Grüßen

Das Windows Live Hotmail-Team

Ein wenig irritiert mich diese E-Mail jedoch schon: Im Gegensatz zu GMail, wo es eine maximale Größe des Postfaches gibt welche jedoch stetig wächst, soll Hotmail keine Obergrenze haben und sich ständig meinen Erfordernissen anpassen. Nun, das scheint jedoch auch nicht näher bezifferte Grenzen zu haben. Einerseits liegt zwar mein gesamtes Mailarchiv seit 2004 dort online, andererseits habe ich mir darüber nie Gedanken gemacht weil ja von dynamischen Wachstum die Rede war.

Wenn es also schon solche Grenzen gibt wäre es schön, wenn man sie auch irgendwo klar kommuniziert.

HTML5 has introduced a lot of new fantastic elements that will be helpful to build better web pages. But the specification also deprecates a few tags that you maybe used in your web pages. So keep them in mind and use  the more semantically correct tags or use CSS for styling.

Presentational tags that are deprecated:

• basefont
• big
• center
• font
• s
• strike
• tt
• u

Also the support for frames has been removed. That means that the following tags are gone:

• frame
• frameset
• noframes

A few other tags are replaced by better options:

• acronym replaced by abbr
• applet replaced by object
• dir replaced by ul

In addition to deprecated tags there are many HTML attributes that are no longer valid:

• align
• link, vlink, alink and text attributes on body tag
• bgcolor
• height, width
• scrolling on the frame element
• valign
• hspace, vspace
• cellpadding, cellspacing, border on the table tag

Deprecated HTML attributes are:

• target for links
• profile for head tag
• longdesc for img and iframe

If you plan on using HTML5 for your website, be sure to look at this elements and attributes to be compatible with the future and HTML5. You can use http://validator.w3.org to validate your page with the standards.

Ich freue mich, dass ich das zweite Mal beim .NET Information Day dabei bin. Dieser findet am 28.06.2011 in Darmstadt statt. Ein Tag lang wird über die Vielfältigkeit von .NET gesprochen. Die Themen sind von Windows Phone 7, Lightswitch, Multithreading, Windows Azures, Nuget, MEF, ASP.NET/MVC, Zukunftsaussichten HTML5/Windows 8 bis zur MS Office Entwicklung mit VSTO! Diese Veranstaltung richtet sich an Einsteiger, Fortgeschrittene, Profi, Hobbyisten und Studenten.

Was mich besonders freut ist, dass hinter der Veranstaltung MS Studenten und die DNUG Frankfurt stecken. Community informiert! :-)

Wir sehen uns da!

Es gibt häufiger die Situation, dass man die Url des Team Project Portals eines TeamProjects per API ermitteln möchte um beispielsweise im zugehörigen Portal Dokumente zu generieren oder abzulegen etc. Hier kann man natürlich versuchen sich die Url aus Server-URL, Project Collection Name und Project Name zusammenzubauen, also http://<servername>/sites/<ProjectCollection>/<TeamProject>. Problem ist, dass die Url frei konfiguriert werden kann und von diesem Default-Wert abweichen kann.

Mein Szenario ist, dass ich ausgehend von einem Work Item die Url des Projekt Portals ermitteln möchte um für das Work Item ein entsprechendes Dokument anzulegen. Das Projekt zum Work Item lässt sich einfach ermitteln mit myWorkItem.Project aber auf dem Projekt sucht man vergeblich nach einer Eigenschaft für das Portal. Der Zugriff darauf istt leider ein wenig komplizierter. Die einzige Möglichkeit die Prortal Url zu ermitteln geht über den TFS Catalog. Der Code sieht dann so aus:

Wir ermitteln zunächst den CatalogNode für die Project Collection unseres Work Items. Davon ausgehend ermitteln wir dann den Knoten für das Projekt mit Hilfe des Projektnamens den wir von dem Work Item lesen. Vom Projekt aus können wir nun den Project Portal Knoten ermitteln der die Url beinhaltet.

Every developer who is working with Claim Based Security knows about the LoginName problem. Within a ClaimBased environment the identifier of the underlying claims provider is set as prefix in front of the entire domain name.

So, in some situations you have to (or would like to) get just domain and username. Here comes the SPClaimProviderManager into play. By asking for the Local Instance you’re able to decode the LoginName, which in detail safely removes the Claims Identifier from the LoginName.

Here is a short sample of that.

using Microsoft.SharePoint.Administration.Claims;

public string GetPlainUserName(string fullUserName)

{

    if(!SPClaimProviderManager.IsEncodedClaim(fullUserName))

      return fullUserName;

    var claimsProviderManager = SPClaimProviderManager.Local;

    return claimsProviderManager.DecodeClaim(fullUserName).Value;

}

First I asked the IsEncodedClaim method whether the given LoginName is encoded or not. Only when the login Name is encoded I use the local instance to query the decoded LoginName .

It’s really easy to utilize the SPClaimProviderManager and ensure that only the plain LoginName is returned.

Nach meiner ersten Webcast Serie “Silverlight in Deep” ist ab heute meine zweite Webcast Serie gestartet. Diesmal handelt es sich allerdings nicht um Silverlight, sondern um ein weiteres spannendes Thema mit der neuen Workflow Foundation 4.

Überblick der Serie “Einführung in die Workflow Foundation 4”:

Teil 1 – Die ersten Schritte

Teil 2 – Hosting und Activities

Teil 3 – Bookmarks und Workflow Extensions

Teil 4 - Workflows persistieren

Teil 5 - WCF Workflow Services

http://www.microsoft.com/germany/msdn/webcasts/serien/MSDNWCS-1106-02.mspx

Die ersten Schritte

Die erste Folge dieser Einführungsserie zeigt den technischen Aufbau der neuen Workflow Foundation 4.0 (WF) und geht auf wichtige Architekturaspekte der komponentenorientierten Entwicklung ein. Dazu gibt Gregor Biswanger einen allgemeinen Überblick.

http://www.microsoft.com/germany/msdn/webcasts/library.aspx?id=1032487426

This post is powered by www.Giza-Blog.de |
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

In der letzten Woche habe ich Wictor Wilén’s Buch SharePoint 2010 WebParts in Action von Manning gelesen.

Das Buch zielt natürlich hauptsächlich auf SharePoint Entwicklung im WebPart Kontext, zeigt allerdings auch viele wichtige Aspekte der allgemeinen SharePoint 2010 Entwicklung wie zum Beispiel Performance Monitoring, Logging, Sandboxing und vieles mehr.

Ich war wirklich sehr positiv von Wictor’s Schreibstil überrascht. Es hat von Anfang bis Ende Spaß gemacht das Buch zu lesen, auch wenn ich die meisten Dinge schon kannte. Ich kann das Buch definitiv jedem SharePoint Entwickler empfehlen. Es sollte in keinem SharePoint Bücherregal fehlen!

Wer schon mal vorab einen Blick in das Buch werfen will, kann dies auf der Buchseite des Verlages gerne machen :)

Enjoy reading!

Wie ich bereits in den beiden früheren Artikeln BlogEngine.NET und 404 Fehler sowie Eine bessere 404 Fehlerbehandlung in Blogengine.NET beschrieben habe, gibt die 404-Fehlerbehandlung von BlogEngine.NET immer wieder Anlass zur Kritik. Auch in der aktuellen Version 2.0 hat sich daran kaum etwas geändert. Zwar wird per Standard in der web.config richtigerweise die Methode ResponseRewrite zur Weiterleitung auf die Fehlerseite angegeben, aber damit erschöpft es sich auch schon in einer sauberen Behandlung von 404-Fehlern.

Als gröbsten Fehler sehe ich hier den zurückgelieferten Statuscode 200 OK an, wenn die Fehlerseite error.aspx angezeigt wird. Für einen Benutzer mag das keine Rolle spielen, aber die Bots von Suchmaschinen sehen das ganz anders. Da wird die angezeigte Fehlerseite statt der falsch angeforderten Seite in den Index eingetragen. Für die Suchmaschinen ist demzufolge die eigentlich nicht vorhandene Seite sehr wohl vorhanden.
Dem kann leicht abgeholfen werden, in dem mit der Fehlerseite error404.aspx auch der Statuscode 404 ausgeliefert wird. Dazu einfach, am Ende der Methode Page_Load, den Statuscode 404 an die Eigenschaft StatusCode des Response-Objekts übergeben.

Page.Title += Server.HtmlEncode(" - " + "Seite nicht gefunden");
Response.StatusCode = (int)HttpStatusCode.NotFound;

Diese kleine Maßnahme zeigt sofort den gewünschten Effekt. Ohne 302-Weiterleitung wird sofort der Status 404 zurückgegeben.

Eine weitere, sehr unschöne, Tatsache stellt der Versuch der Verwendung des Wertes aspxerrorpath aus dem QueryString dar. Dieser Wert wird bei der Verwendung der ResponseWrite Methode von ASP.NET nicht mehr erzeugt. Somit wurde ein sehr schönes Feature der Seite error404.aspx, die Suche nach ähnlichen Seiten wie der angegebenen, komplett ausgehebelt.
Nun, mit einem kleinen Eingriff in die Fehlerseite error404.aspx lässt sich dieser Umstand wieder beheben wie folgender Screenshot zeigt. Dabei wird bei der, aus obigem Screenshot, falsch angeforderten Seite BlogEngine.NET Update auf Version 2.0.0.69 die richtige Seite BlogEngine.NET Update auf Version 2.0.0.66 vorgeschlagen.

Da, wie bereits oben angesprochen, der Eintrag aspxerrorpath im QueryString nicht mehr zur Verfügung steht, muss der Pfad der falsch angeforderten Seite auf andere Weise ermittelt werden. Am besten eignet sich hierfür die Eigenschaft Message der zuletzt geworfenen Ausnahme. Da ASP.NET auf die Fehlerseite eines 404-Fehlers umgeleitet hat, sollte auch ein solcher von der Methode GetLastError des Server-Objekts der aktuellen Seite zurückgegeben werden. Jetzt muss nur noch der Pfad der nicht gefundenen Seite aus der Fehlernachricht extrahiert werden und der Ablauf kann erfolgen wie bisher. Um den Pfad der falsch angeforderten Seite für die gesamte Klasse zur Verfügung zu stellen, speichere ich diesen in einer klassenweiten Variablen.
Um die Änderungen ersichtlicher zu gestalten, habe ich den ursprünglichen Code nur auskommentiert. Als erstes wird die Methode Page_Load angepasst:

/// <summary>
/// Hält den Pfad der falsch angeforderten Seite
/// </summary>
/// <remarks>n/a</remarks>
private string errorPath;

protected void Page_Load(object sender, EventArgs e)
{
    this.errorPath = this.Request.QueryString["aspxerrorpath"];
    var ex = this.Server.GetLastError();

    if (string.IsNullOrEmpty(this.errorPath) && ex != null)
    {
        var index = ex.Message.IndexOf("/post/");
        var temp = ex.Message.Substring(index);
        this.errorPath = temp.Substring(0, temp.IndexOf(" "));
    }

    //if (Request.QueryString["aspxerrorpath"] != null
    //  && Request.QueryString["aspxerrorpath"].Contains("/post/"))
    if (!string.IsNullOrEmpty(this.errorPath) && this.errorPath.Contains("/post/"))
    {
        DirectHitSearch();
        divDirectHit.Visible = true;
    }
    else if (Request.UrlReferrer == null)
    {
        divDirectHit.Visible = true;
    }
    else if (Request.UrlReferrer.Host == Request.Url.Host)
    {
        divInternalReferrer.Visible = true;
    }
    else if (GetSearchKey() != string.Empty)
    {
        SearchTerm = GetSearchTerm(GetSearchKey());
        BindSearchResult();
        divSearchEngine.Visible = true;
    }
    else if (Request.UrlReferrer != null)
    {
        divExternalReferrer.Visible = true;
    }

    Page.Title += Server.HtmlEncode(" - " + "Seite nicht gefunden");
    Response.StatusCode = (int)HttpStatusCode.NotFound;
}

Damit mögliche passende Seiten vorgeschlagen werden können, muss auch die Methode DirectHitSearch eine kleine Änderung erfahren:

private void DirectHitSearch()
{
    string from = this.errorPath; //Request.QueryString["aspxerrorpath"];
    int index = from.LastIndexOf("/") + 1;
    string title = from.Substring(index)
        .Replace(".aspx", string.Empty).Replace("-", " ");

    List<IPublishable> items = Search.Hits(title, false);
    if (items.Count > 0)
    {
        LiteralControl result = new LiteralControl(
            string.Format(
                "<li><a href=\"{0}\">{1}</a></li>",
                items[0].RelativeLink.ToString(),
                items[0].Title));
        phSearchResult.Controls.Add(result);
    }
}

Fazit:

Dies war bestimmt nicht die letzte Anpassung von Fehlerseiten unter BlogEngine.NET.
Für Heute oder Morgen war ursprünglich der Release Kandidat für BlogEngine.NET 2.5 angekündigt. Da im Moment das Repository auf CodePlex beschädigt ist, wird sich die Veröffentlichung ein wenig verzögern.
BlogEngine.NET hat sich seit der Veröffentlichung der Version 2.0 sehr zum Positiven verändert. Es wurde und wird viel für eine breitere Akzeptanz getan. Doch solange sich solche “Feature” im Code verbergen, wird sich an der breiten Meinung: “nur für .NET Bastler” nicht viel ändern.

This post is powered by www.Giza-Blog.de |
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

Microsoft hat unter dem Titel “Web Standards Update for Microsoft Visual Studio 2010 SP1” in der Visual Studio Gallery ein Update für Visual Studio 2010 SP1 veröffentlicht, das Visual Studio und Visual Web Developer Express 2010 SP1 um folgende Features erweitert:

HTML5

IntelliSense und Validierung für folgende HTML5 Features:

• Video & related tags
• Audio & related tag
• New input types like email, url, date etc
• Drag & Drop support
• Accessibility standard WAI-ARIA
• Microdata
• Schema.org & more SEO friendly goodness

Browser APIs

IntelliSense und Validierung für folgende Browser-APIs:

Geo-Location – Beispiel: IE9 test drive demo.

Local Storage – Beispiel: HTML5 Demo Site

CSS3

IntelliSense und Validierung für folgende CSS3 Module (inkl. –ms,  –webkit und –moz):

Weitere Details gibts auch bei Scott Hanselman: Announcing the Web Standards Update - HTML5 Support for the Visual Studio 2010 Editor

Die unter BlogEngine.NET verwendeten Extensions, zum Erweitern des Funktionsumfangs, bieten keine der üblichen Möglichkeiten um die Textausgabe dieser Erweiterungen zu lokalisieren. Diese Erweiterungen sind im Normalfall Klassen, die mit dem Extension-Attribut versehen und im App_Code-Ordner einer BlogEngine Installation im Unterordner Extensions abgelegt werden. Eine klassenbezogene Lokalisierung ist im .NET Framework nicht vorgesehen.
BlogEngine bietet lediglich die Methode Translate der Utils-Klasse um Zeichenfolgen mit Hilfe der globalen Ressourcen zu übersetzen. Um diese Option zu nutzen, müssen alle zu verwendenden Zeichenfolgen in den globalen Ressourcen der Webanwendung vorhanden sein.
Also auch kein gangbarer Weg, da der Aufwand bei Aktualisierungen der globalen Ressourcen einfach zu groß währe.

Ich entschied mich für die Verwendung von statischen Klassen als geschachtelte Typen innerhalb meiner Erweiterungen. Eine anwendungsweite Lösung erschient mir nicht praktikabel, da gerade Erweiterungen oft einzeln verteilt und verwendet werden. Wenn jetzt noch jedes mal eine zusätzliche Assembly mit verteilt werden soll, kann die einfache Handhabung der Erweiterungen schnell unübersichtlich und unnötig kompliziert werden.

In meinem Ansatz mache ich mir die Tatsache zu nutze, dass in den Einstellungen des Blog jederzeit die verwendete Spracheinstellung abrufbar ist. Von der ausgegebene Einstellung, z.B.: de-DE, verwende ich lediglich das Sprachschema. Auf die regionalen Unterschiede zwischen de-DE und de-AT habe ich bewusst verzichtet, da ich nur Zeichenfolgen darstellen will.
So kann in einem switch/case-Block, entsprechend der eingestellten Sprache, die jeweils zugehörige Zeichenfolge ermittelt werden.
Da die geschachtelte Klasse als statisch deklariert ist, können die enthaltenen Eigenschaften, wie von der Resource-Klasse gewohnt, einfach direkt verwendet werden.

/// <summary>
/// Konvertiert die Style-Attribute von Html-Images in
/// eine entsprechende CSS-Klasse.
/// </summary>
/// <remarks>n/a</remarks>
[Extension(
    "Converts the style attributes of Html-Images to the corresponding CSS class.",
    "1.5.0.0",
    "<a href=\"http://blog.klaus-b.net/\">klaus_b</a>")]
public class ConvertStyleToCss
{
    // Hier andere Member der Klasse
    #region Methods
    private static void InitialiceSettings()
    {
        var settings = new ExtensionSettings("ConvertStyleToCss") { IsScalar = true };
        settings.AddParameter(
            "leftImg",
            LocalResources.LeftImg,
            50,
            true,
            false,
            ParameterType.String);
        settings.AddValue("leftImg", "leftImg");
        settings.AddParameter(
            "rightImg",
            LocalResources.RightImg,
            50,
            true,
            false,
            ParameterType.String);
        settings.AddValue("rightImg", "rightImg");
        settings.AddParameter(
            "centerImg",
            LocalResources.CenterImg,
            50,
            true,
            false,
            ParameterType.String);
        settings.AddValue("centerImg", "centerImg");
        settings.AddParameter(
            "cleanWlwDivs",
            LocalResources.CleanWlwDivs,
            4,
            false,
            false,
            ParameterType.Boolean);
        settings.AddValue("cleanWlwDivs", false);
        // TODO: Hilfe erzeugen und einfügen
        ConvertStyleToCss.setting = ExtensionManager.InitSettings(
            "ConvertStyleToCss",
            settings);
    }
    #endregion Methods
    #region Nested Types
    /// <summary>
    /// Stellt lokalisierte Zeichenfolgen als Ressourcen bereit.
    /// </summary>
    /// <remarks>Wird nur von der übergeordneten Klasse verwendet.</remarks>
    private static class LocalResources
    {
        #region Fields
        /// <summary>
        /// Hält die eingestellte Kultur des Blogs.
        /// </summary>
        /// <remarks>n/a</remarks>
        private static readonly string blogCulture = BlogSettings.Instance.Culture;
        /// <summary>
        /// Hält die zu verwendende Sprache des Blogs.
        /// </summary>
        /// <remarks>n/a</remarks>
        private static readonly string culture = blogCulture.Substring(0, 2);
        /// <summary>
        /// Hält den zu verwendenden Hilfetext.
        /// </summary>
        /// <remarks>n/a</remarks>
        private static string helpText;
        #endregion Fields
        #region Properties
        internal static string CenterImg
        {
            get
            {
                switch (culture)
                {
                    case "de":
                        return "Die CSS-Klasse für zentrierte Bilder:";
                    default:
                        return "CSS class for centered images:";
                }
            }
        }
        internal static string CleanWlwDivs
        {
            get
            {
                switch (culture)
                {
                    case "de":
                        return "WLW DIVs bereinigen:";
                    default:
                        return "Clean WLW DIVS:";
                }
            }
        }
        internal static string HelpText
        {
            get
            {
                if (string.IsNullOrEmpty(helpText))
                {
                    switch (culture)
                    {
                        case "de":
                            helpText = CreateGermanHelpText();
                            break;
                        default:
                            helpText = CreateEnglishHelpText();
                            break;
                    }
                }
                return helpText;
            }
        }
        internal static string LeftImg
        {
            get
            {
                switch (culture)
                {
                    case "de":
                        return "Die CSS-Klasse für links ausgerichtete Bilder:";
                    default:
                        return "CSS class for left aligned images:";
                }
            }
        }
        internal static string RightImg
        {
            get
            {
                switch (culture)
                {
                    case "de":
                        return "Die CSS-Klasse für rechts ausgerichtete Bilder:";
                    default:
                        return "CSS class for right aligned images:";
                }
            }
        }
        #endregion Properties
        #region Methods
        private static string CreateEnglishHelpText()
        {
            var sb = new StringBuilder();
            // TODO: create english help text
            return sb.ToString();
        }
        private static string CreateGermanHelpText()
        {
            var sb = new StringBuilder();
            // TODO: deutschen Hilfetext erzeugen
            return sb.ToString();
        }
        #endregion Methods
    }
    #endregion Nested Types
}

Im Moment habe ich die switch/case-Blöcke so gestaltet, dass bei allen anderen Sprachen außer Deutsch, ein englischer Text ausgegeben wird. Da ich die Konfigurationsoberfläche meiner Erweiterungen gerne in der Sprache meines Blog darstelle, denke ich eine gangbare Lösung für Anwender meiner Erweiterungen gefunden zu haben, die andere Sprachen bevorzugen.

Fazit:

Die Lokalisierung von Oberflächen, Meldungen und anderen Textausgaben sollte eigentlich schon lange den Kinderschuhen entwachsen sein. Leider muss ich immer wieder feststellen, dass dem nicht so ist. Entweder liegt dieser Umstand an den jeweiligen Entwicklern die es nicht für nötig erachten ihre Anwendungen zu lokalisieren, oder aber die entsprechenden Technologien erscheinen zu kompliziert um in jeder Anwendung einfach verwendet werden zu können.

This post is powered by www.Giza-Blog.de |
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

Seit letztem November darf ich mich in Silverlight rein arbeiten und seit Februar produktiv eine vorhandene verteilte Anwendung auf Silverlight migrieren.

Das ist mit ein Grund, wieso es hier in meinem Blog in Sachen ASP.NET (und generell) etwas ruhiger geworden ist. Der zweite Grund ist, dass ich seit April stolz zweifacher Vater bin und die Familie einen noch größeren Stellenwert einnimmt als sie es bisher schon getan hat :-)

Wieder zurück zu Silverlight: Das zweite Steckenpferd ist das Windows Phone 7, bzw. die Entwicklung von Anwendungen für das WP7. Aus diesem Grund habe ich mich dazu entschlossen auch etwas über Silverlight und WP7 zu schreiben. Allerdings werde ich das nicht hier in diesem Blog tun, sonder in Englischer Sprache in einem separaten Blog, das mir vom englischsprachigen DotnetKicks-Team zur Verfügung gestellt wurde: http://blogs.dotnetkicks.com/juergengutsch

Das zum Teil schlechte English ist zu entschuldigen, aber dieser Blog soll auch dazu dienen mehr Routine in mein schriftliches Englisch zu bringen. Ist also in erster Linie als Ablage und als Plattform zur Weiterentwicklung für mich persönlich gedacht.

Wer dennoch Interesse an den Themen hat, ist herzlich eingeladen mit zu lesen :-)

PS:
Wo wir doch gerade beim WP7 waren. Pünktlich zur See# Party habe ich auch meine erste Anwendung passend zur Konferenz veröffentlicht. Mehr dazu im letzten Post

Auch zur See# Party 2011 gibt es einiges Neues zu erzählen:

Die Anmeldung ist offen

Wer sich also Günstig informieren möchte, viele Top-Sprecher erleben möchte und abwechslungsreiche Beiträgen lauschen möchte, sollte sich umgehend anmelden. Dank unseren Sponsoren gibt es auch wieder viele tolle Gewinne, die am Ende der Veranstaltung unter allen Teilnehmern verlost werden.

Direkt zur Anmeldung: http://www.seesharpparty.de/anmeldung

.NET-Coding-Dojo

Auch dieses Mal wird es wieder ein .NET-Coding-Dojo geben, das am Abend stattfindet und von Golo Roden und David Tielke moderiert wird. Auch das ist nur unseren Sponsoren zu verdanken, denn auch Abend will gegessen und getrunken werden. Freut euch also auf einen unterhaltsamen und Leerreichen Abend auf der See# Party 2011.

Die Windows Phone 7 App zur See# Party

Wer die Agenda auf dem Windows Phone 7 ansehen möchte und wer seine eigene Agenda auf einem Blick haben möchte, kann sich die See# Party auf sein Gerät holen.

Ladet euch die App auf euer Phone und seit immer auf dem aktuellen Stand. Mehr zur WP7-App kann man auf der zugehörigen Webseite erfahren.

Ein kleiner Auszug aus unseren Sponsoren

This post is powered by www.Giza-Blog.de |
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

Peter Amendt sagte einmal: „Wirkliche Umwälzungen beginnen damit, dass nicht wir den Stein umwälzen, sondern der Stein uns.“ In dieser Metapher ist die .NET-Community der metaphorische Stein: Websites die für die Community gemacht wurden, wie auch dotnet Kicks, wollen nicht die Community nach ihren Vorstellungen und Wünschen formen, sondern sich denen der Community anpassen. Klar ist natürlich auch, dass man es nie allen damit recht machen kann. Doch genau aus diesem Grund wollen wir die Community – Euch! – in unsere Überlegungen und Entscheidungen mit einbeziehen.

Bei unserer heutigen Umfrage geht es um das Thema „Internationalisierung“: Als wir vor etwas über zwei Jahren diese Community-Seite gegründet haben, wollten wir die vielerorts verstreuten deutschsprachigen Artikel betreffend dem .NET-Framework sammeln und zur Verfügung stellen. Ganz unabhängig von der Thematik, ob Entwickler / Programmierer alle der englischen Sprache mächtig sind – oder es vielleicht sein sollten? – wollten wir eine deutschsprachige Alternative für die im englischen Sprachraum massenhaft verfügbaren Seiten bereitstellen.

Uns ist jetzt in letzter Zeit vermehrt aufgefallen, dass neben deutschsprachigen Artikeln vermehrt englische Beiträge vorgeschlagen werden; nicht nur englischsprachige Artikel in vornehmlich deutschen Blogs sondern auch ausschließlich englische Blogs. Dadurch gehen die deutschsprachigen Artikel teilweise unter. Unsere heutige Frage an unsere Community lautet daher:

Wie sollen nicht-deutschsprachige Artikel auf dotnet-kicks.de behandelt werden?

• Alle Artikel dürfen eingestellt werden, man muss sie ja nicht kicken

• Nur deutschsprachige Artikel (keine maschinelle Übersetzung) dürfen eingestellt werden

Sagt uns eure Meinung zu dem Thema in den Kommentaren und gebt eure Stimme bei der Umfrage ab, damit wir dotnet Kicks weiter nach euren Wünschen anpassen können!

Am 07 Juni 2011 ging das erste deutschsprachige BlogEngine.NET Community Portal online.
Betreiber und Verantwortlicher der Webseite ist Hans-Peter Schelian. Als Moderatoren stehen ihm Roland Schumacher aka GENiALi und meine Wenigkeit zur Seite.

Die Idee, oder besser der Entschluss das Portal zu eröffnen, entstand in einem Twitter-Gespräch zwischen Hans-Peter und mir, das in etwa so ablief:

SchelianHP: Kennst du eine #BlogEngine Community außer der auf #CodePlex?
klaus_b0: Nein, aber wenn du eine findest gib mir bitte Bescheid
SchelianHP: Da gibt es wirklich nichts
klaus_b0: Hättest du Interesse eine eigene Seite aufzuziehen?
SchelianHP: Wäre eine Option, habe schon mal ein anderes Forum hochgezogen…
klaus_b0: Ich helfe dir gerne moderieren, administrieren udgl.
SchelianHP: Das habe ich gehofft. Oder soll ich sagen, das hoffe ich doch. Das kriegen wir…
klaus-b0: Wenn das Forum konkret wird, Plattform, Bereiche udgl., schick mir einfach ne DM.

Es folgten noch ein paar Mails hin und her. Darin beschlossen wir auch GENiALi zu fragen, ob er Interesse hätte mit an Board zu kommen. Roland erschien mir eine gute Wahl, da er einer der wenigen deutschsprachigen Entwickler ist die sich mit BlogEngine.NET befassen und er auch schon die ein oder andere Anpassung an der Codebasis vorgenommen hat. Roland sagte zu und so stand das Basisteam fest.
Hans-Peter registrierte die Domäne dotnetblogengine.de, in Anlehnung an den Original Domänennamen von Mads Kristensen dem Gründer des Open Source Projekts, und stellte den Webserver zur Verfügung. Als Plattform für die Community-Seite wurde DotNetNuke gewählt, da Hans-Peter aus dieser Richtung kommt und einiges an Erfahrung mit der Plattform mitbringt. Mir war es egal welche Plattform verwendet wird. Hauptsache .NET basierend und für Anpassungen Zugang zum Quellcode.

Den Mittelpunkt des Portals wird ziemlich sicher das enthaltene Forum darstellen. In diesem Forum sollen die gängigsten Themen rund um BlogEngine.NET behandelt werden. Dabei ist der Schwerpunkt nicht auf Entwickler gerichtet, sondern auf den Endanwender. Egal ob Probleme bei der Installation auftreten, Themes, Widgets oder Erweiterungen angepasst werden sollen.
Entwickler die sich schon jetzt oder erst zukünftig mit BlogEngine.NET befassen wollen, sind natürlich herzlich Willkommen.

Eine FAQ befindet sich gerade in Arbeit. In ihr werden die häufigsten Fragen zur BlogEngine zusammengetragen und beantwortet. Wenn ihr schon jetzt Fragen zur BlogEngine habt die euch unter den Nägeln brennen, scheut euch nicht sie im Forum zu stellen. Wenn ihr noch kein Mitgliederkonte eingerichtet habt, hier geht’s direkt zur Registrierung.

Als dringlichstes Ziel haben wir uns gesetzt, BlogEngine.NET als Blog-System bekannter und attraktiver zu machen. Mit Eröffnung der BlogEngine.NET Gallery ist von Seiten der BlogEngine Entwickler ein Schritt in die richtige Richtung getan. Die Gallery füllt sich stetig mit neuen Inhalten. Die einfache Installation der Themen, Widgets und Erweiterungen direkt in der Verwaltung eines Blog sollte uns in unserem Vorhaben unterstützen.

Ein weiterer wichtiger Punkt den wir in Angriff nehmen, ist die Unterstützung bei der Portierung von bestehenden Blogs aus anderen System. Hier sehen wir noch dringenden Handlungsbedarf.
Das bloße Übertragen der bestehenden Artikel und Kommentare via BlogML ist noch keine erfolgreiche Portierung. Bestehende Verknüpfungen dürfen nicht verloren gehen, sondern müssen auf die neue Linkstruktur weitergeleitet werden. Hier ist noch viel Arbeit nötig.

Oft wird die schlechte Lokalisierung von BlogEngine Installationen mit Recht angeprangert. Auch hier soll Abhilfe geschaffen werden.
In Sachen SEO ist die Engine nicht das was sie leisten könnte, obwohl mit kleinen Änderungen schon viel erreicht werden kann.
Die Leistung von BlogEngine basierenden Blogs lässt auch oft zu wünschen übrig. Auch hier kann geholfen werden.

Wir sind uns noch nicht einig ob wir eine, für den deutschen Sprachraum, überarbeitete und dahingehend angepasste Version zur Verfügung stellen sollen. Die fortlaufenden Änderungen der originalen Version würden natürlich eingepflegt.
Bevor wir uns jedoch einen Haufen Arbeit auf die Schultern laden, könntet ihr uns einfach mitteilen ob überhaupt Interesse eurerseits besteht. Wenn ja, was stellt ihr euch vor?
Besucht uns auf unserem Portal und teilt uns eure Meinung mit.

“Today, more than 250 million documents are shared through SkyDrive, making it one of the most popular ways to upload, view, edit or share documents on the web. Again, we worked to connect our services to the applications and devices you use every day. You can save your Office documents right to SkyDrive from Office 2010 on your PC and Office for Mac 2011, or you can upload documents from your web browser. Once documents are uploaded, SkyDrive works seamlessly with the Office Web Apps for accessing, editing and sharing docs in your browser or in the desktop client. And, thanks to SkyDrive, OneNote works seamlessly across your PC, phone (OneNote Mobile for Windows Phone and OneNote Mobile for iPhone) and web browser (the OneNote Web App).”

Don’t wait for your cloud - use Hotmail and SkyDrive today on your PC, Mac, or Phone

A new blog post in Silverlight Phone Performance team blog about new posibilities of decoding images in a listbox in a background thread per xaml definition with the new property CreateOptions.

For more details see: Off-thread decoding of images on Mango, how it impacts your application ? - Silverlight for Windows Phone Performance team blog - Site Home - MSDN Blogs

This post is powered by www.Giza-Blog.de |
Visit:  Giza-Blog.de Facebook-Page | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

In letzter Zeit sind mit in den Google Webmaster-Tools vermehrt Warnungen zu doppelten Titeln und doppelter Beschreibung aufgefallen. Die Ursache ist im Verhalten von BlogEngine.NET begründet, dass die URL zu einem Artikel sowohl mit angegebenem Datum als auch ohne dieses akzeptiert wird. Demzufolge wird für beide URLs, sowohl mit als auch ohne Datum, der selbe Inhalte zurückgegeben.

Um BlogEngine.NET dieses Verhalten auszutreiben, ist nur ein kleiner Eingriff in die Methode RewritePost der Klasse UrlRewrite im Namensraum BlogEngine.Core.Web.HttpModules nötig.

if (post == null)
{
    return;
}
// HACK: um double content mit URLs ohne Datum zu vermeiden.
if (!haveDate && !url.Contains("/FEED/"))
{
    context.Response.RedirectPermanent(
		post.AbsoluteLink.ToString(),
		true);
    return;
}
context.RewritePath(
    url.Contains("/FEED/")
        ? string.Format(
			"syndication.axd?post={0}{1}",
			post.Id,
			GetQueryString(context))
        : string.Format(
			"{0}post.aspx?id={1}{2}",
			Utils.ApplicationRelativeWebRoot,
			post.Id,
			GetQueryString(context)),
    false);

Nach der Überprüfung, ob ein passender Artikel gefunden wurde, wird mit der Variablen haveDate überprüft ob kein Datum im URL vorhanden ist und auch kein Feed angefordert wurde. Sind beide Bedingungen erfüllt, wird mittels 301 auf den URL mit Datum umgeleitet. Das Vorkommen von double Content, zwecks URL mit und ohne Datum, sollte sich mit dieser Maßnahme erledigt haben.

Fazit:

Kleine Maßnahme, große Wirkung.
Traurig nur, dass man überhaupt erst zu solchen Maßnahmen greifen muss. Die Entwickler von BlogEngine.NET scheinen noch immer nicht verstehen, dass zu einem Blog-System mehr gehört als nur Artikel und Kommentare zu verarbeiten.

Hi,

I’m going to write the posts about FluentSPRibbon in plain English because I think my new framework is important across the German boundaries :)

Every SharePoint developer who is building Ribbon based solutions know about the problem. You have to write tons of XML to form the entire ribbon on an ApplicationPage for example. So somewhere in your code you have to put all this xml. And this approach – in my opinion – has some disadvantages.

The XML is

• weekly typed
• not checked at compile time
• not automatically tested
• not as readable as Plain C# Code

So somewhere in your MyApplicationPage.cs you’ll find something like this

<Tabs Id="FluentRibbon.TabsContainer">

    <Tab Id="FluentRibbon.FluentRibbonTab1" 

         Title="Hello World Tab!" 

         Sequence="1001" 

         Description="see http://www.dotnet-rocks.de">

         <Groups Id="FluentRibbon.FluentRibbonTab1.GroupsContainer">

                 <Group Id="FluentRibbon.FluentRibbonTab1.ActionsGroup" 

                        Title="$Resources: MyResourceFile, Key" 

                        Sequence="10" 

                        Description="These are my actions">

                   <Controls Id="FluentRibbon.FluentRibbonTab1.ActionsGroup.ControlsContainer">

                             <Button Id="FluentRibbon.FluentRibbonTab1.ActionsGroup.MyButton1" 

                                     LabelText="Click me!" />

                   </Controls>

                 </Group>

                 <Group Id="FluentRibbon.FluentRibbonTab1.WorkflowActions" 

                        Title="My Workflow Actions" 

                        Sequence="20" 

                        Description="Master your Workflows by using Ribbon Elements">

                       <Controls Id="FluentRibbon.FluentRibbonTab1.WorkflowActions.ControlsContainer">

                                 <Button Id="FluentRibbon.FluentRibbonTab1.WorkflowActions.Button2" 

                                         TemplateAlias="1" />

                      </Controls>

                 </Group>

                 <Group Id="FluentRibbon.FluentRibbonTab1.ViewSettingsGroup" 

                        Title="Customize your view" 

                        Sequence="30" 

                        Description="Customize the current view for your needs">

                       <Controls Id="FluentRibbon.FluentRibbonTab1.ViewSettingsGroup.ControlsContainer" />

                   </Group>

      </Groups>

    </Tab>

    <Tab Id="FluentRibbon.FluentRibbonTab2" 

         Title="FluentRibbon rocks" 

         Sequence="1002" 

         Description=".NET Rocks Fluent SPRibbon API">

        <Groups Id="FluentRibbon.FluentRibbonTab2.GroupsContainer" />

    </Tab>

</Tabs>

For better readability I’ve removed lot of the commonly used properties on most elements. I like Ribbon UI but the customization API is really bad.

But wait. I’ve a solution for that issue. I’m currently writing on FluentSPRibbon!

FluentSPRibbon

FluentSPRibbon is a dsl (Domain specific language) for building SharePoint Ribbon customizations in a better, a more comfortable way. It offers tons of great features for you as a SharePoint Developer. You’ve got no of the disadvantages that the default xml way offers to you.

So FluentSPRibbon offers

• strongly Typed API
• automatic ID creation
• compile TimeCheck
• a fully tested Framework
• a fluent C# API
• automatic Resource building (for MUI)
• automatic URI generation for Images (you can define a global imagefolder and the Framework will build the URLs automatically
• XSD validation
• many more of course

How does it looks like?

Somewhere within your ApplicationPage:

As you can see you have a strongly typed API for build a SharePoint Ribbon. This is just the simplest way to build a ribbon. It’s still very loud, but the API has capabilities to reduce the amount of code you have to write. For example there is an overload Set method which accepts an IDictionary<PropertyEnum,Value> to reduce the lines of code. As shown in figure 2.

There is also a static class called RibbonSettings where you can define a ResourceFileIdentifier. By setting the ResourceFileIdentifier the FluentSPRibbon will automatically convert all properties of any RibbonElement that is visible in the SharePoint UI to an ResourceLink. There is also an ImageFolder property on the RibbonSettings class, by setting this property the framework will automatically build up a valid path to any ImageProperty on any RibbonElement.

In figure 3 these properties are used.

For example: The API will generate the following output

<Tabs Id="FluentRibbon.TabsContainer">

    <Tab Id="FluentRibbon.FluentRibbonTab1" 

         Title="$Resources:MyResourceFile, Tab1Title" 

         Sequence="1001" 

         Description="$Resources:MyResourceFile, Tab1Description">

      <Groups Id="FluentRibbon.FluentRibbonTab1.GroupsContainer">

        <Group Id="FluentRibbon.FluentRibbonTab1.ActionsGroup" 

               Title="$Resources:MyResourceFile, Group1Title" 

               Sequence="10" 

               Description="$Resources:MyResourceFile, Group1Description">

          <Controls Id="FluentRibbon.FluentRibbonTab1.ActionsGroup.ControlsContainer">

            <Button Id="FluentRibbon.FluentRibbonTab1.ActionsGroup.MyButton1" 

                    Image32by32="/_layouts/FluentSPRibbon/Images/CoolIcon.png" 

                    LabelText="$Resources:MyResourceFile, MyButton1LabelText" />

          </Controls>

        </Group>

        <Group Id="FluentRibbon.FluentRibbonTab1.WorkflowActions" 

               Title="$Resources:MyResourceFile, Group2Title" 

               Sequence="20" 

               Description="$Resources:MyResourceFile, Group2Description">

          <Controls Id="FluentRibbon.FluentRibbonTab1.WorkflowActions.ControlsContainer">

            <Button Id="FluentRibbon.FluentRibbonTab1.WorkflowActions.Button2" 

                    LabelText="$Resources:MyResourceFile, Button2LabelText" />

          </Controls>

        </Group>

        <Group Id="FluentRibbon.FluentRibbonTab1.ViewSettingsGroup" 

               Title="$Resources:MyResourceFile, Group3Title" 

               Sequence="30" 

               Description="$Resources:MyResourceFile, Group3Description">

          <Controls Id="FluentRibbon.FluentRibbonTab1.ViewSettingsGroup.ControlsContainer" />

        </Group>

      </Groups>

    </Tab>

    <Tab Id="FluentRibbon.FluentRibbonTab2" 

         Title="$Resources:MyResourceFile, Tab2Title" 

         Sequence="1002" 

         Description="$Resources:MyResourceFile, Tab2Description">

      <Groups Id="FluentRibbon.FluentRibbonTab2.GroupsContainer">

        <Group Id="FluentRibbon.FluentRibbonTab2.Group4711" 

                Title="$Resources:MyResourceFile, Group4711Title">

          <Controls Id="FluentRibbon.FluentRibbonTab2.Group4711.ControlsContainer">

            <TextBox Id="FluentRibbon.FluentRibbonTab2.Group4711.MyTextBox" 

                    ShowAsLabel="TRUE" 

                    Width="100px" />

          </Controls>

        </Group>

      </Groups>

    </Tab>

  </Tabs>

What you’ll get right now oob is

• Strings are translated to ResourceLinks
• Image Links are redirected to the correct folder
• Ids are build automatically
• Non visible items such as the Controls container are build automatically

There are many more features that FluentSPRibbon offers. Within the next weeks I’ll write about them and show more examples on that topic.

Declarative Ribbon Customizations

On the other side we have declarative Ribbon customizations which are commonly realized by providing an Elements.xml file. For these kinds of customization I first thought about T4 Templates. But the big disadvantage is, that T4 offers no IntelliSense. :/

Till now I don’t know what could be the best solution for that kind of ribbon customizations.. but I’m sure that you can give me some advices. Can’t you?

Beta Testers

I’m lookin forward to hit milestone later this month. So I’m lookin for beta testers. Are you doing Ribbon Customizations in SharePoint? Feel free to contact me by email thorsten.hans@gmail.com and I’ll send you the beta build as early as possible.

Codeplex

The FluentSPRibbon will be available on CodePlex for free!

Die DNUG Braunschweig trifft sich am 15.06.2011 um 19:00 Uhr im Restaurant Zucker (Tagungsraum). Uns kommt der MVP Golo Roden mit einem Vortrag über ADF besuchen.

Scrum, XP & Co – bestehende agile Methoden bedienen jeweils verschiedene Zielgruppen und Aspekte der Softwareentwicklung, doch eine einzelne agile Methode genügt in der Praxis häufig nicht. Was also fehlt, ist ein umfassendes Rahmenwerk, das die erfolgreichen Elemente der bestehenden agilen Methoden vereint, das jedoch – wenn erforderlich – auch eigene Pfade einschlägt.
Das Agile Development Framework (ADF) tritt an, dieses Problem zu lösen, indem es Individuen, Teams und Unternehmen während des gesamten Entwicklungsprozesses von qualitativ hochwertiger Software unterstützt, unter Berücksichtigung der einzelnen Rollen und deren jeweiligen Interessen.
Golo Roden stellt ADF und dessen Konzepte in einem kompakten Überblick vor, zeigt an Hand von praktischen Beispielen den Verlauf des Prozesses von ADF, und beschreibt Migrationspfade von Scrum und XP.

Bio:
Golo Roden ist freiberuflicher Wissensvermittler und Technologieberater für .NET, Codequalität und agile Methoden. Zu diesen Themen berät er Firmen bei der Evaluierung, Erforschung und Verwendung geeigneter Technologien und Methoden. Darüber hinaus ist er journalistisch für Fachzeitschriften und als Referent und Content Manager für Konferenzen tätig. Für sein qualitativ hochwertiges Engagement in der Community wurde Golo von Microsoft als Most Valuable Professional (MVP) für C# ausgezeichnet.

Ich sitze gerade im Zug zurück und lasse die IT & DevConnections Konferenz Revue passieren. Zum ersten Mal (jedenfalls wo ich das wahrgenommen habe) waren viele Sprecher von der Microsoft Corp. bei einer Konferenz zu erleben. Genau diese Mischung habe ich immer bei anderen Konferenzen vermisst, einfach einmal (teilweise) Deep Dive Infos aus der MS Corp. zu bekommen. Ein weiterer netter Nebeneffekt war es, dass ich viele Buchautoren live erleben konnte. Ich sag nur Wrox Verlag (dicke rote gute Bücher).

Ein besonderes Highlight für mich war natürlich die Keynote von “the legend of the red polo” Scott Guthrie. Scott, der jetzt beim Auzres Team arbeitet, hat uns die Cloudsicht von Microsoft erklärt, recht interessant, aber Neues war leider nichts dabei.

Natürlich waren auch viele aus der Community anwesend, so dass sich die spontane Abendveranstaltung in Karlsruhe feucht fröhlich gestaltete. Danke nochmals an die Stadtführer. ;-)

Mein Konferenzfazit fällt positiv aus und ich hoffe, dass wir nun regelmäßig in Deutschland so ein Sprecheraufgebot aus der MS Corp. bekommen können.

Gerade wenn man mit MSBuild ClickOnce Pakete bearbeitet (aufbrechen und erneut signiert) muss man darauf aufpassen, dass man die Parameter korrekt an die mage.exe  übergibt.

Ich verwende normalerweise in Projekten eine solche Ordnerstruktur

• bin –> Binaries
• bld –> Build Files
• doc –> Dokumentationen
• pkg –> ClickOnce Paket
• src –> Source Files

Hierbei kann es zu Problemen kommen, wenn man davon ausgeht, dass ein Buildfile (im Ordner bld) aus dem Ordner bld heraus aufgerufen wird

c:\dev\bld\msbuild.exe sample_bld.msbuild

Falls man innerhalb des BuildFiles dann zum Beispiel die Ordnerpfade wie folgt zusammenbaut

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="4.0" 

         InitialTargets="Init" 

         DefaultTargets="Build" 

         xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<PropertyGroup>

    <src Condition="'$(src)' ==''">$(MSBuildStartupDirectory)\..\src\</src>

    <pkg Condition="'$(pkg)' ==''">$(MSBuildStartupDirectory)\..\pkg\</pkg>

    <bin Condition="'$(bin)' ==''">$(MSBuildStartupDirectory)\..\bin\</bin>

    <doc Condition="'$(doc)' ==''">$(MSBuildStartupDirectory)\..\doc\</doc>

</PropertyGroup>

<Target Name="Init">

    <Message Text="$(src)"/>

    <Message Text="$(bin)"/>

    <Message Text="$(pkg)"/>

    <Message Text="$(doc)"/>

</Target>

</Project>

Entstehen folgende Werte

Genau mit diesen Werten entsteht dann ein Problem mit der mage.exe. Mage kann den Teil “\..\” nicht interpretieren. Leider bekommt man bei der Ausführung der mage.exe mit einem solchen Pfad keine Fehlermeldung. Erst bei der Installation der eigentlichen Anwendung oder beim Update bekommt man dementsprechende Fehler angezeigt, weil im Application-Manifest ein falscher Pfad zum Deployment-Manifest hinterlegt wird.

Doch mit ein wenig Geschick kann man dieses Problem einfach in den Griff bekommen.

<?xml version="1.0" encoding="utf-8"?>

<Project ToolsVersion="4.0" 

    InitialTargets="InitDirectories" 

    DefaultTargets="Build" 

    xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

<PropertyGroup>

    <src Condition="'$(src)' ==''">src\</src>

    <pkg Condition="'$(pkg)' ==''">pkg\</pkg>

    <bin Condition="'$(bin)' ==''">bin\</bin>

    <doc Condition="'$(doc)' ==''">doc\</doc>

</PropertyGroup>

<Target Name="InitDirectories">

    <CreateItem Include="$(MSBuildStartupDirectory)\..\">

        <Output ItemName="root" TaskParameter="Include"/>

    </CreateItem>

    <PropertyGroup>

        <src>@(root->'%(FullPath)')$(src)</src>

        <bin>@(root->'%(FullPath)')$(bin)</bin>

        <pkg>@(root->'%(FullPath)')$(pkg)</pkg>

        <doc>@(root->'%(FullPath)')$(doc)</doc>

    </PropertyGroup>

    <Message Text="$(src)"/>

    <Message Text="$(bin)"/>

    <Message Text="$(pkg)"/>

    <Message Text="$(doc)"/>

</Target>

</Project>

Mit dieser Variante erhält man folgende Ergebnisse

Übergibt man diese dann an mage.exe dann wird das ClickOnce Paket auch korrekt verarbeitet und kann wie gewohnt verwendet werden.

Die Professional Developer’s Conference 2011 heißt //build. Diesen Termin unbedingt vormerken: 13.- 16. September 2011, in Anaheim, Ca. Es gibt spannende Neuigkeiten! Einen Vorgeschmack gibt es hier. Die Registrierung ist offen!

PS: Die //Build wird die PDC nicht ersetzen. Es handelt sich um eine neue Konferenz.

Anfang der Woche fand in Nürnberg die erste .NET DevCon statt. Rund 250 Besucher fanden sich zur Premiere der neuen Konferenzreihe ein und sorgten zusammen mit dem ContentBoard, den Orgas und den Speakern dafür, dass es ein grandioses Event wurde.

Meinen Part bei der .NET DevCon bildeten zwei Sessions.

Data Please, Mr.SharePoint

Exploring MVVM in Silverlight

Neben meinen Sessions habe ich leider nicht viel sehen können weil ich am 2. Tag wieder direkt abreisen musste. Dennoch gab es ein paar Highlights die ich kurz hervorheben möchte.

Coding Dojo

Das Coding Dojo wurde von Ilker veranstaltet und war ein voller Erfolg. Sogar noch Tage nach der Konferenz wird bei Twitter über das Coding Dojo gesprochen (siehe Hashtag #dndc11).

Das Networking

Das Networking war für meinen Eindruck sehr gut. In der lockeren Atmosphäre bildeten sich schnell Gruppen in denen über diverse Fachgebiete diskutiert wurde, so dass man im Rahmen der Abendveranstaltung sehr gut neue Kontakte knüpfen und alte Kontakte pflegen konnte.

Die Sessions

Wie bereits erwähnt habe ich nicht viele Sessions besucht. Lediglich die Session von Golo Roden zum Thema „FogBugz und Kiln“ habe ich mir als Verfächter der beiden Produkte natürlich angeschaut. Interessant war für mich die Tatsache, dass fast 90% aller Besucher der Session auf TFS setzen. Diese 90% waren natürlich vom Leistungsspektrum der FogCreek Suite geflasht :D

Am zweiten Tag habe ich noch die Session „WPF vs Silverlight vs HTML5“ angeschaut und muss sagen dass es schon sehr lustig ist was aktuell in Sachen HTML5 abgeht. Gerade die Unterstützung einiger Browser (in den neusten Versionen) ist der echte Hammer… http://www.html5test.com kann euch das bestätigen :)

Mein Fazit

Die .NET DevCon war ein sehr cooles Event, welches hoffentlich eine Neuauflage bekommt und dann auch wieder meine Dienste als Sprecher in Anspruch nimmt. Schulnote 1 fürs gesamte Team!

Bereits vor meinem Urlaub fand in Nürnberg der 2. .NET Day Franken statt. Bereits der erste .NET Day Franken war meiner Meinung nach ein großer Erfolg und das gesamte Orga Team konnte die Messlatte im Jahr 2011 noch einige Stufen höher setzen.

Mehr Besucher, bessere Organisation, mehr Aussteller, mehr Themen … in jedem Bereich wurde zugelegt und der Community für kleines Geld ein großes Event geboten. Nicht zuletzt die Location ist einfach super, auch das Catering war auf höchster Ebene.

Ich selbst habe mit einem SharePoint Development Vortrag hoffentlich mein bestes dazu beigetragen dass die Veranstaltung für die Besucher eines der Highlights in 2011 bleiben wird.

Daher hoffe ich dass wir auch im Jahre 2012 wieder einen .NET Day Franken in Deutschland haben werden, bei dem ich auch als Sprecher wieder mitwirken darf.

Vor einigen Tagen wurde meine erste Windows Phone 7 App “Brainstorming” auf dem Marketplace veröffentlicht.

Mit Brainstorming können Sie Ihren Gedanken freien Lauf lassen und diese als Mind-Map (Business Mapping) festhalten. Somit können Sie Ihre Ideen einfach und schnell handhaben und präzise strukturieren. Durch die einfachen Änderungsmöglichkeiten wird die Zusammenarbeit in der Gruppe gefördert und die Kreativität gesteigert. Durch unterschiedliche Formatierungen können Gedanken besser gewichtet werden.

In der Testversion können Sie maximal 2 Projekte speichern und das Mind-Map nicht als Bild anlegen. 

Features: 
- Priorisierung von Notes 
- Freie Farbauswahl für Notes
- Bilder für Notes hinzufügen
- URL-Support für Notes
- Multi-Touch-Support
- Mind-Map als Bild speichern
- Mind-Map per E-Mail senden

Video

Screenshots

Feature- & Bug-liste

Sie haben einen Fehler gefunden? oder einen Feature Wunsch? Einfach Bug oder Feature-Wunsch auf Google Moderator posten und abstimmen lassen. Die Einreichung mit den höchsten votes, wird bevorzugt behandelt.

> WP7 - Brainstorming App - Wish & Bug list

Facebook-Gruppe: WP7 - Brainstorming App

In Facebook hab ich extra eine Brainstorming App Gruppe eröffnet. Hier könnt ihr jederzeit weitere Informationen zu Updates erhalten.

http://www.facebook.com/home.php?sk=group_222587804437502&ap=1

Download

Mit BlogEngine.NET ab Version 2.0.0.62 ist die volle Unterstützung für Themes enthalten, die den Razor-Syntax verwenden wollen. Das bedeutet spätestens ab jetzt ist ASP.NET in der Version 4 angesagt, wie auch die Änderungen an den unterschiedlichen web.config Dateien unschwer erraten lassen. Neu ist auch die Unterstützung für das IIS Rewrite Modul. Die verwendete jQuery-Version wurde auf Version 1.5.2 aktualisiert. Neu hinzugekommen ist die Unterstützung mehrere Blogs unter einer Installation. Ebenfalls neu ist die Möglichkeit, die Angabe von Webseiten in den Kommentaren zu verbieten.

Bevor man aber die vielen neuen Feature nutzen kann, ist erst einmal ein Datenbankupdate fällig. Das SQL-Script für dieses Datenbankupdate trägt bereits die Bezeichnung From2.0To2.5. Mit diesem Update werden folgende Änderungen vorgenommen:

• Diverse Fremdschlüssel entfernt.
• In die Tabelle be_Users eine neue Spalte BlogID eingefügt.
• In die Tabelle be_UserRoles eine neue Spalte Role eingefügt.
• In die Tabelle be_StopWords eine neue Spalte BlogID eingefügt.
• In die Tabelle be_Settings die neuen Spalten SettingRowId und BlogID eingefügt.
• In die Tabelle be_Roles eine neue Spalte BlogID eingefügt.
• In die Tabelle be_Rights die neuen Spalten RightRowId und BlogID eingefügt.
• In die Tabelle be_RightRoles die neuen Spalten RightRoleRowId und BlogID eingefügt.
• In der Tabelle be_Referrers die neuen Spalten ReferrerRowId und BlogID eingefügt.
• In der Tabelle be_Profiles eine neue Spalte BlogID eingefügt.
• In der Tabelle be_Posts die neuen Spalten PostRowID und BlogID eingefügt.
• In der Tabelle be_PostTag eine neue Spalte BlogID eingefügt.
• In der Tabelle be_PostNotify eine neue Spalte BlogID eingefügt.
• In der Tabelle be_PostComment die neuen Spalten PostCommentRowID und BlogID eingefügt.
• In der Tabelle be_PingService eine neue Spalte BlogID eingefügt.
• In der Tabelle be_Pages die neuen Spalten PageRowID und BlogID eingefügt.
• In der Tabelle be_DataStoreSettings die neuen Spalten DataStoreSettingRowId und BlogId eingefügt.
• In der Tabelle be_Categories die neuen Spalten CategoryRowID und BlogID eingefügt.
• Eine neue Tabelle be_Blogs erstellt.
• Diverse neue Indizes erstellt.

Wer sich unter BlogEngine.NET mit einem eigenem Razor-Theme versuchen möchte, findet im Ordner themes mit Garland-Revisited bereits eine nette Vorlage. Wer bereits mit einem eigenem Theme arbeitet, kann davon einen Screenshot anfertigen und diesen im PNG-Format in das Verzeichnis des jeweiligen Themas unter dem Namen theme.png mit einer Breite von 480 Pixel ablegen. In der Blogverwaltung wird dieser Screenshot als Vorschau in der Themenauswahl angezeigt, Das ist kein Muss, aber ein nettes Gimmick.

Die Suche nach verfügbaren Themen für BlogEngine.NET wurde durch eine eigene Gallery stark vereinfacht. In den Einstellungen zu den Themen einfach auf den Link Gallery klicken und eine Auswahl an verfügbaren Themen wird direkt in der Einstellungsseite angezeigt. Sollte ein Thema gefallen, einfach auf Install klicken und Dank der Verwendung von NuGet wird das gewählte Thema auf dem Server installiert.

Ähnlich einfach wurde die Installation verfügbarer Erweiterungen und Widgets.
Im Dashboard prangt einem jetzt sofort eine Auswahl verfügbarer Erweiterungen und Widgets entgegen.

Hinter dem Dienst, sowohl für die Themen als auch für die Widgets und Erweiterungen, steht die blogenginge.net gallery. Wer seine Erweiterungen, Widgets oder Themen zur Verfügung stellen will, kann sie in der Gallery veröffentlichen.

Wer seinen Besuchern wie bisher erlauben will, ihre Webseiten in den Kommentaren anzugeben, sollte nicht vergessen unter Einstellungen/Kommentare den Hacken bei
Enable Website in Comments
zu setzen.

Diese Einstellung ist standardmäßig deaktiviert. Die bisher eingetragenen Verknüpfungen zu Webseiten bleiben von dieser Einstellung unberührt, aber bei allen neuen Kommentaren wird die Verknüpfung zur Webseite nicht gespeichert, wenn diese Option nicht gesetzt wird.

Trotz der vielen Neuerungen sind viele, schon ältere, Fehler nicht gefixt. So funktioniert z.B.: die Übersichtsliste im Archiv noch immer nicht. Hier müsste nur der Anker korrekt gesetzt werden.

Auch neue Fehler sind hinzugekommen.
Wer ein Fehler-Logging aktiv hat, dem wird folgende Fehlermeldung auffallen:

Error loading compiled extensions from assembly BlogEngine.Core, Version=2.0.0.66, Culture=neutral, PublicKeyToken=fed3cbd6fd4e62d0: Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.

Diese Fehlermeldung ist etwas irreführen, denn sie bezieht sich nur im weiteren Sinn auf einen Fehler beim Laden der Erweiterungen. Vielmehr wird hier ein Problem mit der Zugriffssicherheit abgeleiteter Typen bemängelt, welches erst bei Verwendung der Assembly Blogengine.Core unter der .NET Version 4 auftritt. Im einzelnen sind alle Klassen im Namensraum BlogEngine.Core.Compilation.Design betroffen. Hier schafft das setzten des Attribut SecurityRules mit dem Wert Level1 der SecurityRuleSet-Enumeration auf die Assembly Abhilfe. Dazu einfach in der AssemblyInfo.cs folgende Zeile einfügen:

[assembly: SecurityRules(SecurityRuleSet.Level1)]

Von da an, werden die Sicherheitsregeln wieder wie unter .NET Version 2 auf die Assembly angewendet.

Ein weiterer, aus meiner Sicht, Fehler ist der etwas gedankenlose Umgang mit einem ungeprüften Ergebnis einer String.IndexOf Abfrage in der Methode RewriteDefault der Klasse UrlRewrite. Da wird im else-Block ungeprüft das Ergebnis an eine String.SubString Methode übergeben. Wenn hier die überprüfte Zeichenfolge default.aspx nicht gefunden wird, wird der Wert –1 an die String.SubString Methode übergeben, was in einer IndexOutOfRangeException endet. Hier hilft als Hack, bis zum Fix, ein Ternär-Operator:

else
{
    string newUrl = url.Replace("Default.aspx", "default.aspx");  // fixes a casing oddity on Mono
    // HACK: ternary operator um eine IndexOutOfRangeExcption zu vermeiden
    int defaultStart = url.IndexOf("default.aspx") == -1 ? 0 : url.IndexOf("default.aspx");
    newUrl = Utils.ApplicationRelativeWebRoot + url.Substring(defaultStart);
    context.RewritePath(newUrl);
}

FAZIT:

Die BlogEngine mausert sich immer mehr zu einer richtigen Blog-Anwendung.
Vielen Anwenderwünschen wird langsam Rechnung getragen, wie etwa die einfachere Installation von Themen, Widgets oder Erweiterung. Ich will hoffen, dass sich durch Eröffnung der blogengine.net gallery auch die Anzahl ansprechender Themen langsam erhöht. Dies war bisher immer einer der Hauptargumente um die BlogEngine.NET nicht zu verwenden.

Highlights in Visual Studio vNext kurz als deutsches Video erklärt – 30 Minuten die sich lohnen!

Einen kurzen Überblick über die bisher angekündigten Highlights in Visual Studio vNext – der nächsten Version von Visual Studio – gibt ALM Architekt und Visual Studio-Experte Christian Binder in seinem 30 Minuten dauernden Webcast. Hier bekommen Sie einen Ausblick auf einige der neuen Funktionen von Visual Studio vNext.

Schwerpunkte:

• Requirements Storyboarding
• Sprint Planning & Durchführung
• Entwicklerproduktivität abrunden
• Stakeholder-Feedback
• IntelliTrace in Production
• System Center-Integration
• TFS on Azure

Alle bisherigen und zukünftigen Beiträge zu Visual Studio vNext finden Sie immer aktuell unter diesem Link.

Von artiso gibt es jetzt auch Planning Poker® Karten. Planning Poker® ist eine sehr gute Möglichkeit, im Team Komplexitätsschätzungen für Anforderungen vorzunehmen. Dies ist insbesondere bei agilen Methoden eine sehr gute Vorgehensweise. Am Beispiel von Scrum möchte ich kurz erläutern, wie so eine Planning Poker Runde abläuft:>>

Der PO trifft sich mit dem Team für ein Estimation. Der PO stellt dem Team eine User Story vor und das Team stell so lange Fragen bis es schätzfähig ist.Dann zieht jeder Teilnehmner eine Karte, hält diese aber zunächst verdeckt um die anderen Teilnehmer bei ihrer Schätzung nicht zu beeinflussen. Alle decken ihre Schätzung gleichzeitig auf. Der Teilnehmer mit der höchsten und mit der niedrigsten Schätzung begründen nun ihre Schätzung. Dabei werden Argumente ausgetauscht warum die Komplexität so hoch bzw. so niedrig ist. Die anderen Teilnehmer können sich natürlich an der Diskussion beteiligen. Unter den neuen Diskussionsaspekten findet dann eine neue Schätzrunde statt. Hat das Team eine Näherung erziehlt, dann wir die häufigste Nennung als Wert für die Schätzung übernommen.

Eine häufige Diskussion ist, ob nur das Team schätzt oder der PO auch eine Schätzung abgibt. Ich bevorzuge es, wenn der PO mitschätzt. Da wir mit Story Points relative Komplexitäten schätzen, sond Bedenken meist unbegründet, dass der PO die Schätzung “drücken” möchte. Aber bei Abweichungen der Abschätzung von PO und Team werden oftmals durch die Diskussion Missverständnisse oder unterschiedliches Verständnis der Anforderung aufgedeckt.

Der Vorteil von Planning Poker® liegt nun nicht nur darin, genauere Schätzungen zu erhalten, sondern man vermeidet die Situation dass bei solchen Schätzrunden wenige aktiv die Schätzung beeinflussen und die anderen passiv dabei sitzen und nur die Vorschläge abnicken.

Die Karten von artiso besitzen noch eine Besonderheit. Hier gibt es zwei Skalen. Mit den Werten auf den weißen Flächen mit der Reihung ?,0,½,1,2,3,5,8,13,20,40,100,∞ werden Story Points geschätzt. Die andere Seite mit den Werten ?,½,1,2,3,4,6,8,10,12,16,20,25 kann dazu genutzt werden, Aufwände in Stunden nach dem selben Vorgehen zu schätzen.

Unter den Lesern meines Blogs verlose ich 5 Sets zu je 8 Decks. Einfach Mail an tschissler (at) artiso.com schicken, die ersten 5 Einsedungen erhalten die Karten umgehend per Post zugeschickt.

In meinem letzten Post hab ich eine kleine Einführung in das Thema RSS-Feeds mit .NET erzeugen gegeben. Nun sind aber nicht alle Inhalte, die man per RSS-Feed übertragen möchte in den Standard-Elementen unterzubringen, die die RSS-Spezifikation definiert. Typische Beispiele dafür sind zusätzliche Geodaten oder Daten zu Medieninhalten in Podcasts. Um auch dieser Anforderung gerecht zu werden, bieten die beiden vorgestellten Klassen SyndicationFeed und SyndicationItem noch die Möglichkeit eigene Attribute oder eigene Elemente zu definieren. Wie das geht, soll an einem kleinen Beispiel gezeigt werden:

Eigene Elemente zum Item hinzufügen

Möchte man einfach nur zusätzliche Elemente zu den Items hinzufügen, kommt man recht schnell ans Ziel. Schlüssel sind die ElementExtensions. Im Beispiel werden jedem Item noch die Elemente Latitude und Longitude zur Definition einer Geokoordinate hinzugefügt.

var item = new SyndicationItem
{
    Id = "http://myfeeds/2011/06/" + i,
    Title = SyndicationContent.CreatePlaintextContent("Wichtige Mitteilung"),
};

item.ElementExtensions.Add("Latitude", null, 34.2543);
item.ElementExtensions.Add("Longitude", null, 14.2545);

Das Resultat ist, dass wie gewünscht das Item-Element über die definierten Sub-Elemente verfügt.

<item>
    <guid isPermaLink="false">http://myfeeds/2011/06/0</guid>
    <title>Wichtige Mitteilung</title>
    <Latitude>34.2543</Latitude>
    <Longitude>14.2545</Longitude>
</item>

Den gleichen Weg kann man dann auch beim Einlesen der Daten wieder verwenden: In der Auflistung ElementExtensions befinden sich die hinzugefügten Elemente mit den jeweiligen Namen und Inhalten. Mit Hilfe der generischen Methode GetObject kann man dann auf die Inhalte zugreifen.

var feed2 = SyndicationFeed.Load(reader);
foreach (var item in feed2.Items)
{
    var latitudeElementExtension = item
        .ElementExtensions
        .Single(e => e.OuterName == "Latitude");
    var latitude = latitudeElementExtension.GetObject<double>();
}

Analog zu den ElementExtensions gibt es die AttributeExtensions, die (wie sollte es anders sein) keine Elemente sondern Attribute erzeugen.

Eigene komplexe Objekte zum Item hinzufügen

ElementExtensions erlauben nicht nur das Hinzufügen primitiver Datentypen sondern auch komplexer Objekte - Bedingung: Sie müssen xml-serialisierbar sein und es muss ein passender XML-Serializer existieren oder es muss sich um einen DataContract handeln. In meinem Fall definiere ich mir nun eine neue Klasse GeoCoordinate, die sich als Location serialisiert.

[XmlRoot("Location", Namespace = "http://ns.uniquesoftware.de/location")]
[Serializable]
public class GeoCoordinate
{
public GeoCoordinate()
{
}

 public GeoCoordinate(double lat, double lon)
 {
     Latitude = lat;
     Longitude = lon;
 }

 [XmlElement("Latitude")]
 public double Latitude { get; set; }
 [XmlElement("Longitude")]
 public double Longitude { get; set; }
}

Im Anschluss definiere ich wie vorhin auch eine ElementExtension und füge dieser der Auflistung des Elements hinzu.

var item = new SyndicationItem
{
    Id = "http://myfeeds/2011/06/" + i,
    Title = SyndicationContent.CreatePlaintextContent("Wichtige Mitteilung"),
};
item.ElementExtensions.Add(
    new GeoCoordinate(34.2543, 14.2545), 
    new XmlSerializer(typeof(GeoCoordinate)));

Das resultierende XML im Feed beinhaltet nun wie erwartet die eben definierten Tags, die über die definierten Namespaces verfügen.

<item>   
    <guid isPermaLink="false">http://myfeeds/2011/06/0</guid>
    <title>Wichtige Mitteilung</title>
    <Location 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns="http://ns.uniquesoftware.de/location">
        <Latitude>34.2543</Latitude>
        <Longitude>14.2545</Longitude>
    </Location>
</item>

Eigene Namespaces verwenden

Häufig trifft man auf Konstrukte, in denen der Namespace nicht explizit jedes Mal wieder als Attribut im Element definiert wird, sondern wo nur noch eine Namespace-Referenz existiert. Nichts einfacher als das: Dazu fügt man einfach die XML-Namespace-Deklaration der AttributeExtensions-Auflistung des SyndicationFeed-Objektes hinzu. Im folgenden Beispiel habe ich dafür den Namespace "my" deklariert.

// create new syndication feed 
var feed = new SyndicationFeed(
    "Mein Blog Feed",
    "Wissenwertes über ASP.NET, WPF und Silverlight",
    new Uri("http://feeds.feedburner.com/discoveringmicrosofttechnologies"))
    {
        Language = "de-DE",
        Copyright = new TextSyndicationContent("Unique Software"),
        Generator = "Unique Software News Generator"
    };
feed.AttributeExtensions.Add(
    new XmlQualifiedName("my", "http://www.w3.org/2000/xmlns/"), 
    "http://ns.uniquesoftware.de/location");

Der Effekt ist, dass nun der Namespace im XML-Element channel definiert und dann automatisch eine Namespace-Referenz aufgebaut wird.

<item>
    <guid isPermaLink="false">http://myfeeds/2011/06/0</guid>
    <title>Wichtige Mitteilung</title>
    <my:Location>
        <my:Latitude>34.2543</my:Latitude>
        <my:Longitude>14.2545</my:Longitude>
    </my:Location>
</item>

Zusammenfassung

ElementExtensions und AttributeExtensions sind eine gute Möglichkeit, RSS-Feeds flexibel auf die eigenen Bedürfnisse anzupassen und mit Hilfe des Objektmodells typsicher auf die Objekte beinhalteten Objekte zuzugreifen. Besonders bei XML-Strukturen, die nur noch sehr entfernt etwas mit dem ursprünglichen Feed-Objektmodell zu tun haben, wird es wohl immer wieder eine Abwägung von Aufwand und Nutzen sein, ob man ElementExtensions und die Syndication-Objekte verwendet oder ob man die XML-Struktur "schnell eben selbst" per Linq-To-Xml zusammenbaut. Ich persönlich finde die sich bietenden Möglichkeiten wieder recht umfangreich und finde es schade, dass die Klassen so ein unbeachtetes Dasein fristen. 

Englische Version

// create new syndication feed  
var feed = new SyndicationFeed("Mein Blog Feed",
 "Wissenwertes über ASP.NET, WPF und Silverlight",
 new Uri("http://feeds.feedburner.com/discoveringmicrosofttechnologies"))
  {
     Language = "de-DE",
     Copyright = new TextSyndicationContent("Unique Software"),
     Generator = "Unique Software News Generator"
  };

// create syndication items which should be delivered
var items = new List<SyndicationItem>();
for (var i = 0; i < 5; i++)
{ 
 var item = new SyndicationItem
     {
         Id = "http://myfeeds/2011/06/" +  i,
         PublishDate = DateTime.Now,
         Title = SyndicationContent
             .CreatePlaintextContent("Wichtige Mitteilung"),
         Content = SyndicationContent
             .CreateHtmlContent("Meine wichtige Nachricht an alle Leser"),
         Summary = SyndicationContent
             .CreatePlaintextContent("Zusammenfassung meiner Mitteilung")
     };
     items.Add(item);
}
feed.Items = items;

var builder = new StringBuilder();
using (var writer = XmlWriter.Create(builder))
{
 feed.SaveAsRss20(writer);
 writer.Flush();
 writer.Close();
}
var xml = builder.ToString();

Englische Version

Wie jeder andere Entwickler auch möchte natürlich auch der WP7-Entwickler gerne wissen, wie oft seine geschriebenen Anwendungen verwendet werden, von wem und von wo. Denn nur wer den Markt kennt, kann auch zielgerichtet für ihn entwickeln! Microsoft selber bietet hier nur eine sehr rudimentäre Statistik im App-Hub an, die zudem auch nur zeitversetzt angezeigt wird. Die dort einsehbaren Nutzerzahlen sind bereits rund eine Woche alt und bilden zudem außer der Info “Free-App”, “Test-Version” oder “Gekauft” nur noch das Land in dem es heruntergeladen wurde ab. Wer mehr wissen möchte, oder auch einfach nur schneller, der muss folglich zu einer 3rd-Party Lösung greifen. Ein paar der wichtigsten sind:

• PreEmptive Solutions Runtime Intelligence Service (RIS)
• Google Analytics
• mtiks

PreEmptive Solutions RIS

Dank einer Vereinbarung zwischen dem Hersteller PreEmptive Solutions und Microsoft steht das Analyse-Tool derzeit allen registrierten WP7-Entwicklern kostenlos zur Verfügung. Zunächst zeitlich beschränkt bis zum 31. März 2011 wurde zwischenzeitlich die Vereinbarung unbefristet verlängert. Sollte der Service nicht mehr kostenlos zur Verfügung stehen, werden die Entwickler 60 Tage vorher darüber in Kenntnis gesetzt. Dann jedoch würden selbst in der kleinsten “Starter”-Lizenz bereits 300$ / Monat fällig bei einer Beschränkung auf maximal zwei Application IDs (eine pro App). Man muss also darauf hoffen, dass sich Microsoft und Preemptive Solutions noch lange gut vertragen.

Runtime Intelligence for Windows Phone 7

Google Analytics

Wer bereits eine Website mit Googles Analytics überwacht, kennt die Oberfläche und die zur Verfügung stehenden Werkzeuge vermutlich nur zu gut. Da liegt die Frage natürlich nahe, ob man nicht auch Infos seiner WP7-Apps hier verwalten kann. Und tatsächlich: René Schulte hat einen Artikel beschrieben, wie er genau das mit Hilfe des Silverlight Analytics Frameworks bewerkstelligt hat. Der Vorteil hier ist sicherlich die bekannte Oberfläche. Auch ist Google Analytics kostenlos und wird es auch mit an Sicherheit grenzender Wahrhscheinlichkeit dauerhaft bleiben. Der von René gewählte Ansatz ist ganz gut, für mich persönlich war er aber etwas zuviel Bastelei.

Googles Analysedienst ist natürlich nicht für native Mobile-Apps ausgelegt. Man hat hier aber selbstverständlich viele Freiheiten um die benötigte Informationen in beliebiger Form zusammen zu stellen und dann zu senden. Da das Silverlight Analytics Framework verwendet wird, ist das Protokollieren der Daten theoretisch natürlich nicht nur mit Google Analytics möglich, sondern auch mit anderen unterstützten Services, derzeit:

• Google Analytics
• Nedstat
• Service Oriented Analytics
• WebAnalysis.NET
• Webtrends

Tracking Sales Statistics with the Silverlight Analytics Framework for WP7
Microsoft Silverlight Analytics Framework

mtiks

Interessanterweise ist dieser Anbieter offenbar recht unbekannt, zumindest habe ich nur wenige Infos gefunden und die meisten mit denen ich über das Thema sprach kannten mtiks gar nicht, daher gebe ich hier ein paar ausführlichere Informationen. Der Dienst ist für die reine Analyse kostenlos, und soll es auch bleiben. Lediglich für einige Zusatzdienste kann man bei Bedarf monatlich so genannte “Premium-Pakete” kaufen. Derzeit gibt es für Windows Phone 7 nur das Zusatzpaket “WP7 Exceptions”, mit dessen Hilfe man protokollierte Fehler in der Weboberfläche einsehen und analysieren kann. Das Feature ist derzeit noch in der Beta-Phase und solange auch kostenlos verwendbar.

Die Oberfläche ist eher schlicht gehalten und stellenweise läuft es manchmal auch nicht ganz rund. So kann man zwar beliebig viele Anwendungen anlegen und auch umbenennen, jedoch habe ich bisher keine Möglichkeit gefunden eine Anwendung auch wieder zu löschen. Man kann für die Anzeige der Zeiten die eigene Zeitzone wohl einstellen, jedoch reagiert diese Option bei mir nicht. Beides sind aber jetzt keine wirklich schwerwiegenden Probleme, wenn auch gelegentlich ein wenig nervig. Das Einbinden des SDK geht mit wenigen Codezeilen in der App.xaml.cs schnell von der Hand, inklusive dem Protkollieren von unbehandelten Exceptions. Möchte man keine benutzerdefinierten Daten protokollieren, kann man nach dem ersten Starten der Anwendung die Ergebnisse in der Weboberfläche in Echtzeit verfolgen. Einige der abfragbaren Informationen sind:

• Total Sessions
• Total Unique Devices
• Sessions by App Version
• User Loyalty
• Sessions by Device Groups
• Sessions by Device Models
• Sessions by Countries
• Sessions by OS Version

Zusätzlich lassen sich beliebige zusätzliche Events protokollieren. Die hierdurch gesammelten Daten können sowohl grafisch als auch tabellarisch im Web angesehen oder als CSV exportiert werden. Neben dem reinen Auftreten eines Events lassen sich auch noch eigene Eigenschaften und Werte protokollieren.

Lässt man aufgetretene Exceptions mitprotokollieren und hat das Zusatzpaket “WP7 Exceptions” gebucht, erhält man auch eine grafische Auswertung, wieviele Ausnahmen wann aufgetreten sind. Auch kann man in einer tabellarischen Auflistung sehen, welche Art von Fehler wie oft auftrat. Auch die Details einzelner Fehler lassen sich abrufen sofern sie denn von der eigenen App übermittelt wurden.

mtiks
Bilder-Galerie mtiks-Dashboard (App: XDA Wallpaper)

Persönliches Fazit

Da mir die Situation bei PreEmptive Solutions zu unsicher ist (bleibt es nun kostenfrei oder wird man eines Tages, wenn eine Umstellung für die Entwickler erst mal zu komplex wird, bluten müssen?) fiel deren Lösung für mich von Anfang an weg. Der Ansatz mit dem Silverlight Analytics Framework wäre noch interessant, allerdings erst wenn auch “Piwik” unterstützt wird. Aber das mag auch nur meine persönliche, subjektive Abneigung gegen Google sein.

Seit nunmehr einem halben Jahr arbeite ich mit mtiks und seit dem wurde die Weboberfläche und das SDK stetig weiter entwickelt. Selbst wenn es noch nicht überall ganz rund aussieht verspricht die andauernde Entwicklung doch viel Gutes. Die sehr schnelle und einfache Implementierung in das eigene Projekt gefällt mir dabei ebenso gut wie das Einsehen der Daten in Echtzeit. Werden neben den schon recht umfangreichen Statiken noch app-spezifische Daten benötigt lassen diese sich auch problemlos mit einer Zeile Code schnell einbinden und ebenso bequem wie die Default-Daten auswerten.

Wer ohne viel Aufwand noch nach einer Analyse-Möglichkeit für seine Windows Phone 7 App sucht, sollte sich mal mtiks näher ansehen. Die jeweils aktuelle Version des SDK ist im übrigen auch über NuGet verfügbar.

Erich Gamma war Distinguished Engineer in der Rational Software Abteilung der IBM Software Group mit Sitz in Zürich, wo er am Projekt Jazz / Rational Team Concert arbeitete. Zuvor leitete er die Entwicklung der Eclipse IDE. Erich wird ab August in Zürich die Leitung eines neuen Visual Studio Labs übernehmen.  Weitere Informationen gibt’s auf Jason Zanders blog. Herzlich willkommen !!!

Die .NET DevCon 2011 fand am 6. Und 7. Juni in Nürnberg statt. Der Veranstalter war die Neue Mediengesellschaft Ulm mbH, die unter anderem Herausgeber der .NET Fachzeitschrift dotnetpro ist. Von der Neuen Mediengesellschaft Ulm gab es bis jetzt nur die Prio Konferenz. Die Prio hat im Gegensatz zur DevCon einen Themenschwerpunt, wie zum Beispiel verteilte Architektur oder Cross Plattform Development.
Bei der DevCon waren die Themen bunt gemischt. Es gab zum Beispiel Vorträge aus dem Bereich Architektur, Soft Skills, SharePoint, Codequalität, Visual Studio oder GUI.
Was komplett fehlte, waren Themen aus den Bereichen Webentwicklung und Mobile Development. Dafür gibt es zwei eigene Konferenzen, die Web DevCon, welche im Oktober in Hamburg stattfinden wird und die Mobile DevCon, die nur einen Tag dauert und in drei verschiedenen Städten stattfindet.

Zurück zur DevCon 2011 und meinen Eindrücken von der Konferenz:

Erster Tag

Die Konferenz begann für mich mit einem Vortrag von Thomas Mentzel, er sprach über Design Patterns.
Jeder der hin und wieder seinen Blog liest, weiß, dass Patterns sein Steckenpferd sind. Er zeigte anhand eines gemauerten Torbogens, dass es Patterns schon vor 2000 Jahren gab und dass diese sich bis heute weiterentwickelt haben. Die Kernaussage seines Vortrages war, dass man nicht nur Patterns kennen und anwenden sollte, sondern dass Patterns auch ständig weiterentwickelt werden müssen, in dem zum Beispiel neue Sprachfeatures genutzt werden.

Constantin Klein, besser bekannt unter dem Namen Kostja, brachte Licht ins Dunkle in Sachen SQL Server Versionen. Er stelle alle Versionen vor und besprach die Unterschiede. Am meisten waren Infos zur Compact Edition gefragt, die erst seit der .NET Version 4 in ASP.NET Webseiten eingesetzt werden kann. Ein sehr gelungener Vortrag! Leider war er nicht gut besucht.

Am Abend des ersten Tages sprach Golo Roden über FogBugs & Kiln, eine verteilte Source-Code-Verwaltung mit einem schicken Webinterface. Die Source-Code-Verwaltung basiert auf Mercurial.
Golo war der Meinung, dass FogBugs & Kiln eine gute Alternative zu einigen Features aus dem TFS sind. Golo ließ in seinem Vortrag kein gutes Haar am TFS, die Kritikpunkte waren unteranderem die Trägheit und die fehlende Offlinefähigkeit des TFS.
Interessant fand ich, dass das anwesende Publikum ihm zustimmte und das keiner Partei für den TFS ergriffen hat.

Der erste Tag wurde mit einer Open Night beendet. Vor dem Essen referierte Faisal Jilani (Project Manager bei Microsoft aus Redmond) über die MSDN und das Hilfe System im Visual Studio.

Ab 21 Uhr gab es ein Coding Dojo vom Erfinder des Dojos: Ilker Cetinkaya.
21 Uhr fand ich etwas zu spät, so dass ich nicht teilgenommen habe.

Zweiter Tag

Den zweiten Tag begann ich mit dem Vortrag „Von der Idee zum Modell“ von Jan Fellien. Nach etwas Theorie zum Thema Modellierung zeigte er sehr anschaulich, dass viele Probleme im Softwareentwicklungsprozess vermieden werden können, wenn eine Dokumentation in Form eines Modells erstellt wird. Er demonstrierte,  wie ein solches Modell in kurzer Zeit und ohne großen Aufwand erstellt werden kann.

Der nächste Vortrag, auf den ich eingehen möchte, ist der Vortrag von Roland Weigelt. Ich wusste von Roland, dass er diesen Vortrag in den letzten Jahren schon mehrfach gehalten hatte und dass er den Vortrag bei jedem Mal weiter verfeinert hatte. Meine so geschürten hohen Erwartungen sollten nicht enttäuscht werden.
Der Vortrag richtete sich an Entwickler, die in der Regel nicht designen können. Das Ziel des Vortrages war es nicht, aus einem Bock einen Gärtner zu machen, sondern den Entwicklern zu zeigen, dass es nur ein kleiner Schritt ist, um aus einer grauenvollen GUI eine ansprechende und solide wirkende Benutzeroberfläche zu machen. Er nannte einige Regeln und Kochrezepte die sicher jeder nachvollziehen konnte.
Rolands Vortrag hatte mit über 300 Folien, meiner Meinung nach, die höchste Informationsdichte an diesem Tag. Er musste seinen Vortrag direkt nach dem leckeren und reichhaltigen Mittagessen halten. Bedingt durch das so genannte Suppenkoma hatte er leider nicht immer die volle Aufmerksamkeit aller Zuhörer.

Im Gegensatz zu Rolands Vortrag hatte Roberto Bez nur sehr wenige Zuhörer, was ich nicht ganz nachvollziehen kann.
Im Abstract wurde versprochen, dass er zeigt, wie die Razor View Engine aus ASP.NET MVC 3 auskoppelt und als leistungsfähige Template Engine zur Erzeugung von HTML-Dateien oder Reports eingesetzt werden kann.

Genau dies hat Roberto Schritt für Schritt vorgeführt. Es war interessant zu beobachten, wie er ein Konsolenprogramm entwickelt hat, das mit Hilfe von Razor Serienbriefe oder HTML Emails generieren konnte. Im Gegensatz zu T4 konnte dabei auf die hässlichen, spitzen, gelben Klammern verzichtet werden.

Mein letzter Vortrag, war ein Vortrag in dem die Firma Centron eine Beta Version ihrer Private-Cloud namens CCloud vorgestellt hat. Centron versteht im Moment unter einer Private-Cloud einen virtuellen Server, bei dem man den RAM oder den Festplattenspeicherplatz per Schieberegler einstellen kann und nur die tatsächlich verbrauchte Leistung zahlen muss.

Fazit

Dieses Mal möchte ich gern auf mein persönliches Fazit verzichten und einige Tweets zitieren, die zum Hashtag der Konferenz getwittert wurden:

• #dndc11 ist vorbei. Bin schon zuhause angekommen. Schön wars. (@minibrain81)
• perfekte organisation, gute vorträge, gerne wieder #Dndc11 (@SKTime888)
• #dndc11 is almost over now. Good talks, nice people, well organized. Thanks everybody! Two sessions left, than heading back to #austria (@dtanzer)
• Tschüss Nürnberg. Tschüss @dotnetdevcon. Bis zum nächsten Jahr! #Dndc11 (@MrMoratti)
• Coole Veranstaltung - Hat sich gelohnt! #dndc11 (@chrinner)
• zurück vom #dndc11 - war erkenntnisreich und spannend zugleich. danke an alle teilnehmer und die organisatoren. jetzt erstmal verarbeiten (@ilkerde)
• Back at home - war eine tolle veranstaltung - viele coole leute und super organisation. Hope for another one! #dndc11 (@RobertoBez)

Fotos und Grafiken: Neue Mediengesellschaft Ulm mbH

Im April haben wir die aktuellen Trainings zu SharePoint 2010 angekündigt und es freut mich, dass für das Briefing in Köln noch freie Plätze zur Verfügung stehen. Das Entwickler Camp in Unterschleißheim ist dagegen bereits ausgebucht und Anmeldungen führen leider nur noch auf die Warteliste.

Was erwartet Sie im Briefing?

Briefing zu neuen Geschäftspotentialen für Entscheider am 20.06.2011 in Köln

• Potenziale für Partner durch SharePoint 2010 und Office 365
• Integration von SharePoint in Partnerlösungen
  • Grundlagen, Vertrieb und Integration mit Visio
• Integrationsszenarien SharePoint inhouse und Office 365 – Vorteile für Kunden
• Technische Abgrenzung: wo macht SharePoint in Partnerlösungen Sinn?
• SharePoint 2010 – eine durchgehende Entwicklerstory für Partner
  • Welches Know-How Ihre Entwickler aufbauen sollten
  • VS 2010, Sandboxed Solutions, Developer Dashboard, Office Integration/Entwicklung

Zum Briefing anmelden...

With Silverlight 5 beta there is an issue concerning the usage of the Silverlight Toolkit controls. For some of them (in my sample the MenuItem) you get a compile error

“The type or namespace name 'ContextMenu' does not exist in the namespace 'System.Windows.Controls' (are you missing an assembly reference?)”

Oops?! If you use intellisense to select the MenuItem control it exists. So definitively a bug in Silverlight 5. After a quick search a found also a hint in Microsoft Connect: Silverlight Forum: SL5 NumericUpDown control compile error | Microsoft Connect

XAML which produce the error:

<StackPanel>

    <ListBox x:Name="ListBoxTest">

        <toolkit:ContextMenuService.ContextMenu>

            <toolkit:ContextMenu x:Name="contextMenu1">

                <toolkit:MenuItem Header="Test"></toolkit:MenuItem>

            </toolkit:ContextMenu>

        </toolkit:ContextMenuService.ContextMenu>

        <ListBoxItem Content="Listitem 1"></ListBoxItem>

        <ListBoxItem Content="Listitem 2"></ListBoxItem>

    </ListBox>

</StackPanel>

Workaround by setting the Menuitems with code behind:

New XAML:

<StackPanel>

    <ListBox x:Name="ListBoxTest">

        <toolkit:ContextMenuService.ContextMenu>

            <toolkit:ContextMenu x:Name="contextMenu1">

                <!--<toolkit:MenuItem Header="Test"></toolkit:MenuItem>-->

            </toolkit:ContextMenu>

        </toolkit:ContextMenuService.ContextMenu>

        <ListBoxItem Content="Listitem 1"></ListBoxItem>

        <ListBoxItem Content="Listitem 2"></ListBoxItem>

    </ListBox>

</StackPanel>

Code:

public MainPage()

{

    InitializeComponent();

    var menuitem = new MenuItem() { Header = "My Menu" };

    //menuitem.Click += new RoutedEventHandler(menuitem_Click);

    contextMenu1.Items.Add(menuitem);

}

One of the unique features of the platform Windows Phone is the existence of a start page with tiles. Some of the tiles could be “live tiles” with some informations about the state of the Windows Phone app. For instance, a social network app could use the live tile to displays the number of unseen posts. The developer of a Windows Phone app can in the current version change the background image (local or remote image), title of the app and a counter (range 0-99) via Push Notifications.

Changes in Mango

With the new Mango release of Windows Phone we have the following changes:

• Possible creation of secondary tiles with deep linking to a URI within your application (with parameters)
• Access to your tiles with usage of ShellTile.ActiveTiles
• Manipulate the tile appearance directly without push notifications with the StandardTileData class
• Each tile now have a back page, which could have a image (remote or local), a separate title and a content text
• In combination with the new background agent you can now schedule local tile updates
• With the ShellTileSchedule class you can define that your tile image should be updated in the specified interval

Secondary live tiles

Adding a secondary tile to the start screen is done with the help of the ShellTile class. The StandardTileData class is used by tile creation or the tile update to hold the tile data.

// Check the existence of the new pinned tile

var shellTile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("PartnerID=4711"));

if (shellTile != null)

{

    return;

}

// Create the tile data with some proeprties

var tileData = new StandardTileData

    {

        BackgroundImage = new Uri("Red.jpg", UriKind.Relative),

        Title = "Secondary Tile",

        Count = 12,

        BackTitle = "Back page",

        BackContent = "This is the back page",

        BackBackgroundImage = new Uri("Blue.jpg", UriKind.Relative)

    };

// create the tile at the start screen

ShellTile.Create(new Uri("/MainPage.xaml?PartnerID=4711", UriKind.Relative), tileData);

The pictures used for the live tile must be in PNG or JPG format and have the size of 173x173 pixels PNG or JPG. The properties of the files in the solution have to be set to Content and “copy if newer”. The BackgroundImage or BackBackgroundImage could also be web URLs, than the UriKind Absolute should be used.

Deep Linking

If you use a secondary tile with a other Uri than “/” the NavigationService automatically navigates to the given page. In the NavigatedTo-Event you can access via QueryString to the parameters of the tile (in this case “PartnerID=4711”).

protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)

{

    base.OnNavigatedTo(e);

    if (NavigationContext.QueryString.ContainsKey("PartnerId"))

    {

        // do something here

    }

}

Updates the tiles

To access a tile the ActiveTiles prooperty of the ShellTile class will be used.

To find the primary tile and update the back content property:

var tileToFind = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString() == "/");

if (tileToFind != null)

{

    var newTileData = new StandardTileData

        {

            BackContent = "Changes for the back"

        };

    tileToFind.Update(newTileData);

}

To find a secondary tile and make some updates:

Find a tile with a specific parameter or all with a deep link to a page (for example details.xaml"):

// Find the tile we want to update.

var tileToFind = ShellTile.ActiveTiles.FirstOrDefault

    (x => x.NavigationUri.ToString().Contains("PartnerID=4711"));

// If tile was found, then update the Title

if (tileToFind != null)

{

    var newTileData = new StandardTileData

    {

        Title = textBoxTitle.Text

    };

    tileToFind.Update(newTileData);

}

Delete a pinned tile

Delete a secondary or main tile:

var tileFound = ShellTile.ActiveTiles

    .FirstOrDefault(tile => tile.NavigationUri.ToString().Contains("Details"));

if (tileFound != null)

{

    tileFound.Delete();

}

Background worker

With the new concept of Mango to run scheduled background agents you can easily create a local update service for tiles.

Start the background agent with help of the ScheduledActionService class. In my sample I use a PeriodicTask which will be scheduled every 30 minutes to check for updates of the live tiles. More details about scheduled tasks you can find here: Scheduled Tasks Overview for Windows Phone

(1) Add a new SchedulerAgent project to your solution

(2) Start a new PeriodicTask by using the ScheduledActionService

private static void StartPeriodicAgent()

{

    var periodicTask = new PeriodicTask("PeriodicAgent")

        {

            // The description is required. This is the string that the user

            // will see in the background services Settings page on the device.

            Description = "Periodic task for updating the tile"

        };

    // If the agent is already registered with the system,

    // call the StopPeriodicAgent helper method.

    if (ScheduledActionService.Find(periodicTask.Name) != null)

    {

        StopPeriodicAgent();

    }

    ScheduledActionService.Add(periodicTask);

}

private static void StopPeriodicAgent()

{

    ScheduledActionService.Remove("PeriodicAgent");

}

(3) At the Invoke Event of the ScheduledTaskAgent update the tile:

           if (task is PeriodicTask)

           {

               var tileToFind = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString() == "/");

               if (tileToFind != null)

               {

                   var rand=new Random(0);

                   var newTileData = new StandardTileData 

                   { 

                       Count = rand.Next(0,99)

                   };

                   Debug.WriteLine("Updated " + DateTime.Now.ToShortTimeString());

                   tileToFind.Update(newTileData);

               }

           }

The user have in Windows phone settings page a list of the current running background agents and can stop them.

Ich muss zugeben, inzwischen hasse ich den Begriff Cloud. Inzwischen ist es ein Buzz Word, dass jeder in den Mund nímmt. Das ist wie damals mit .NET. Auf einmal muss alles in der Cloud sein, notfalls macht man diese dann einfach privat. Aber was bedeutet das überhaupt? Und welche Rolle spielen hierbei die Begriffe SaaS, IaaS und PaaS? Wo paßt Windows Azure hinein?

Also vielleicht zuerst zu SaaS – Software as a Service. Software wird auf einer Web-Plattform zur Verfügung gestellt. Kostenlos oder im Mietmodell über monatliche Abrechnung. Im einfachsten Fall ist das eine Web-Applikation. Beispiele sind Google Apps, SalesForec Sales Cloud oder Microsoft Office Web Apps bzw. CRM Online, also Applikationen, mit denen Dokumente erstellt oder Daten erfaßt und bearbeitet werden können. Die Ablage der Dokumente oder Daten liegt oftmals ebenfalls in der Cloud.

Als Infrastructure as a Service (IaaS) bezeichnet man die Möglichkeit, eigene Virtuelle Maschinen in einem zentralen Rechenzentrum zu hosten. Man nimmt i.d.R. eine vorgefertigte VM mit dem Betriebssystem seiner Wahl (der Dienstleister unterstützt normalerweise nur bestimmt Versionen), installiert seine Services oder Anwendungen und betreibt das Ganze in einem zentralen Rechenzentrum. Für Updates der Virtuellen Maschinen ist der Betreiber (also Sie) zuständig. Das Paradebeispiel hierfür ist Amazon mit EC2 (Elastic Compute Cloud ).
Der Unterschied zum klassischen Hoster ist die Verfügbarkeit von globalen Services, wie Storage, Message Queues, relationales Datenbankservices und ähnlichem sowie Mechanismen zum automatischen Skalieren (bei Bedarf werden neue Instanzen meiner VM automatisch hochgefahren [Elastic BeansTalk bei Amazon]).

Zu Guter Letzt PaaS – Platform as a Service. Hier ist der Abstraktionsgrad höher als bei IaaS, weil es eine Art Betriebssystem über den vielen einzelnen PCs/Blades gibt und die einzelnen virtualisierten Betriebssysteminstanzen verwaltet. Der Entwickler schreibt seine Software also gegen ein Cloud-Betriebssystem und kümmert sich dort eigentlich nur um die Rollen, in die seine Services/Anwendungen fallen (Web, Worker). Das Cloud-Betriebssystem kümmert sich um die Ausführung der Anwendung nach den vorgegebenen Eckdaten oder Regeln. Load Balancing, OS-Servicing (Patches, Updates), Desaster Recovery, Fail Over, etc. wird durch die Cloud Platform durchgeführt. Desweiteren stehen Komponenten wie Storage (no-SQL like, wie Tables, Blobs und Queues) zur Verfügung. Manche Anbieter, wie Microsoft, bietet ebenfalls eine relationale Datenbank in der Cloud. PaaS hat immer auch Komponenten von IaaS enthalten, allerdings gekapselt und meist nicht direkt erreich- oder konfigurierbar.

David Chappell hat dazu einmal eine sehr aussagekräftige Matrix gezeigt, welcher Anbieter mit welchen Services in welcher Rubrik zuhause ist:

Ein typischer Vertreter für PaaS ist Microsoft Windows Azure. Es werden von Windows Azure auch weitere Komponenten für den Entwickler von Software geboten, die die Kommunikation zwischen dem eigenen Rechenzentrum und den Cloud Services regelt (Azure Connect, Service Bus) oder für Sicherheit und Zugriffsrechte (Access Control Service) bzw. Caching (Caching Services) zuständig sind. Nicht zu vergessen, die Tools für den Software LifeCycle: mit Visual Studio und .NET sind Sie dabei. Aber auch PHP, Ruby, Java, Eclipse, C++ u.a. werden unterstützt.

Je weiter man also die Abstraktion voran treibt, um so mehr fallen die Betriebskosten.

Einen guten allgemeinen Überblick über Windows Azure bieten folgende gut 7 Minuten Video:

Welche Szenarien sind für Windows Azure prädestiniert? Das sind Anwendungen, die

• massive skalieren sollen
• hochverfügbar sind
• eine variable Last aufweisen
• eine kurze oder unvorhersehbare Lebenszeit haben
• Daten parallel verarbeiten
• die Realisierung der Ideen von StartUps (fail fast/scale fast) darstellen
• schnell verteilt bzw. zur Verfügung stehen müssen

Das sind einige, sicher aber nicht alle Szenarien für eine Cloud Plattform.

Read some intressting facts from the Windows Phone Performance team blog about performance improvments for the ListBox and ScrollViewer with Mango for Windows Phone: Listbox – ScrollViewer performance improvement for Mango and how it impacts your existing application? - Silverlight for Windows Phone Performance team blog - Site Home - MSDN Blogs

With Mango for Windows Phone we have some cool changes for the system tray control. SystemTray is a DependencyObject and because Mango is now running on SL4, DependencyObject can be data bound. The other feature for the System Tray coming with Mango is a ProgressIndicator which can used to display progress on async operations.

More details and sample code about the new ProgressIndicator in the System Tray you can find here: System Tray Progress Indicator - Jaime Rodriguez - Site Home - MSDN Blogs

Data Binding of ProgressIndicator

Sample for programmatically data binding of the ProgressIndicator in the Loaded-Event of the page:

this.Loaded += ( x, y ) => 

    {

        var progressIndicator = SystemTray.ProgressIndicator;

        if (progressIndicator != null)

        {

            return;

        }

        progressIndicator = new ProgressIndicator();

        SystemTray.SetProgressIndicator(this, progressIndicator);

        var binding = new Binding("IsChecked") { Source = this.ProgressIndicatorIsVisible };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.IsVisibleProperty, binding); 

        binding = new Binding("IsChecked") { Source = this.ProgressIndicatorIsIndeterminate };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.IsIndeterminateProperty, binding); 

        binding = new Binding("Text") { Source = this.ProgressIndicatorText };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.TextProperty, binding);

        binding = new Binding("Value") { Source = this.ProgressIndicatorValueSlider };

        BindingOperations.SetBinding(progressIndicator, ProgressIndicator.ValueProperty, binding);

    } ;              

Updated: Data Binding over declaration

Many thanks to a colleague, who give me the tip that data binding for SystemTray is also possible with XAML declaration.

See sample here: http://danielvaughan.org/post/Binding-the-WP7-ProgressIndicator-in-XAML.aspx

In einem aktuellen Projekt machte mich NDepend auf einen übermäßigen Gebrauch von Boxing und Unboxing aufmerksam. Hauptsächlich wurde dabei eine Klasse angemeckert, welche die Einstellungen aus der web.config für eine Anwendung verfügbar macht, die keinen Zugriff auf die hostende Webanwendung hat. In besagter Klasse wurden diverse Einstellungswerte verschiedenen Typs in einer Object Collection gehalten und beim Abruf aus dieser in den entsprechenden Wertetyp gecastet. Also jede Menge Boxing- und Unboxing-Vorgänge. Bei der Recherche zu dem Thema, warum man Boxing und Unboxing denn vermeiden solle, stieß ich immer wieder auf die Aussage: Boxing/Unboxing ist sehr rechenintensiv und kann sich daher negativ auf die Gesamtleistung einer Anwendung auswirken.
In der MSDN heißt es unter anderem im Artikel Leistung (C# und Visual Basic) im Absatz über Boxing und Unboxing:

Wenn ein Wertetyp mittels Boxing konvertiert wird, muss ein völlig neues Objekt erstellt werden.Dies kann bis zu 20-mal länger dauern als eine einfache Zuweisung eines Verweises.

Das war es Wert näher untersucht zu werden.
Für den Anfang beschränkte ich meinen Versuch auf die Primitiven. Der Einfachheit halber verwende ich hier Int32-Werte, welche in ein Array vom Typ Object geschrieben werden. Anschließend werden die Werte aus diesem Object-Array mit verschiedenen Methoden in ein Array vom Typ Int32 geschrieben und die Ergebnisse verglichen. Das Object-Array wird immer mit 1 Millionen Werten von 0 aufsteigend gefüllt.

Als erstes habe ich ein einfaches Boxing verwendet um das Object-Array mit Int32-Werten zu füllen. Anschließend werden via Unboxing die Werte aus dem Object-Array in das Int32-Array übertragen.

namespace BoxingUnboxingTest
{
    using System;
    using System.Diagnostics;
    using System.Globalization;

    class Program
    {
        private static object[] container;
        private static int[] result;
        private const int MaxItems = 1000000;

        static void Main(string[] args)
        {
            container = new object[MaxItems];
            result = new int[MaxItems];
            var sw = new Stopwatch();
            sw.Start();

            FillArrayWithInt();
            sw.Stop();
            var timeToFill = sw.ElapsedMilliseconds;
            sw.Start();
            FillResult(false, false);
            sw.Stop();
            var timeToTransfer = sw.ElapsedMilliseconds - timeToFill;
            var totalTime = sw.ElapsedMilliseconds;
        }

        private static void FillArrayWithInt()
        {
            for (int i = 0; i < MaxItems; i++)
            {
                container[i] = i;
            }
        }

        private static void FillResult(bool useParse, bool useConvert)
        {
            if (useParse)
            {
                for (int i = 0; i < MaxItems; i++)
                {
                    result[i] = int.Parse(container[i].ToString(), CultureInfo.InvariantCulture);
                }

                return;
            }

            if (useConvert)
            {
                for (int i = 0; i < MaxItems; i++)
                {
                    result[i] = Convert.ToInt32(container[i], CultureInfo.InvariantCulture);
                }

                return;
            }

            for (int i = 0; i < MaxItems; i++)
            {
                result[i] = (int)container[i];
            }
        }
    }
}

Das Ergebnis war erst einmal verblüffend. Ich erwartete, auf Grund der vielen boxing/unboxing Operationen ein katastrophales Ergebnis. Statt dessen wurde mir ein sehr flottes Resultat angezeigt: Für das Füllen des Object-Array, das Boxing, wurden im Schnitt 50 Millisekunden benötigt. Für das Umkopieren der Werte in das Int32-Array mittels Unboxing lediglich 15 Millisekunden im Mittel.

Da ich ja vom Boxing/Unboxing weg sollte, probierte ich als nächstes eine Version mit der Convert-Klasse in der ich das boxing in das Object-Array beibehielt, das unboxing mit einer Überladung der ToInt32-Methode ersetzte. Das Ergebnis war ernüchternd. Anstatt schneller zu werden, ich hatte ja auf das böse unboxing verzichtet, benötigte diese Variante satte 1250 Millisekunden im Mittel.

Die Verwendung der Methode int.Parse war, mit 1850 Millisekunden im Mittel, die langsamste Variante.

Als nächstes startete ich den gleichen Versuch mit Werten des Typs DateTime. Auch hier begann ich mit dem Boxing/Unboxing und füllte das Object-Array wieder mit 1 Millionen Werten. Das Füllen des Array dauerte diesmal rund 1500 Millisekunden im Mittel. Das Umkopieren via Unboxing benötigte etwa 15 Millisekunden. Das Unboxing von DateTime-Werten geht also genauso schnell wie das Unboxing von einfachen Int32-Werten.

Als nächstes testete ich das Verhalten mit der Convert-Klasse in dem ich die ToDateTime Methode verwendete und dieser die Werte als Typ Object übergab. Auch hier wieder das gleiche Ergebnis wie bei den Int32-Werten: etwa 1250 Millisekunden im Mittel.

Auch bei DateTime-Objekten benötigte die Parse-Methode DateTime.Parse mit rund 4000 Millisekunden am längsten.

Erstes Zwischenfazit:
Für den reinen Transport von öfter wechselnden Werten verschiedenen Typs in einem Container mit einer Auflistung vom Typ Object, ist die Verwendung von Boxing/Unboxing die erste Wahl.
Ich konnte keine Methode finden, welche die Aufgabe schneller und einfacher erledigt.

Aber damit ist das Thema noch nicht ausgereizt. Boxing/Unboxing wird auch innerhalb des Framework in den verschiedensten Methoden, für den Benutzer oft vollkommen transparent, verwendet. Ein typischer Vertreter dieser Art ist die oft verwendete Methode String.Format mit ihren diversen Überladungen.
In folgendem Beispiel werden die beiden Integer Werte in ein Object geboxt und anschließend die Methode Object.ToString aufgerufen.

var output = string.Format(
    CultureInfo.InvariantCulture,
    "Dies ist Wert Nr.{0} von {1} Werten insgesamt.",
    5,
    100);

Um hier das Boxing zu vermeiden könnte anstatt der Integer Werte, die jeweilige Darstellung als Zeichenfolge an die Methode übergeben werden:

var output = string.Format(
    CultureInfo.InvariantCulture,
    "Dies ist Wert Nr.{0} von {1} Werten insgesamt.",
    5.ToString(CultureInfo.InvariantCulture),
    100.ToString(CultureInfo.InvariantCulture));

Da die Methode int.ToString ein Member der int Struktur ist, wird hier kein Boxing benötigt. Ob dieses Vorgehen einen Vorteil gegenüber der direkten Angabe der Integer Werte darstellt, gilt es zu ermitteln.

Als erstes habe ich ein Array vom Typ string mit 1 Millionen Werten mit der Methode string.Format gefüllt, in dem ich den jeweiligen Wert zwischen 0 und 999999 als Integer Wert an die Methode übergeben habe. Dieses Verfahren benötigte im Schnitt 3700 Millisekunden.

Die Angabe der Zeichenfolge mit Hilfe der int.ToString Methode gegenüber der direkten Angabe der Integer Werte brachte auch dieses mal keine Verbesserung der Leistung. Diese Variante benötigte zur Erstellung der 1 Millionen Werte etwa 5000 Millisekunden im Mittel.

Zweites Zwischenfazit:
Für Zahlenwerte jeglicher Art scheint die Verwendung von Boxing/Unboxing die schnellste und effizienteste Art zu sein, die jeweiligen Werte zwischen verschiedenen Objekten zu übertragen oder als formatierte Zeichenfolge darzustellen.

Als letzten Versuch möchte ich mich einer anderen Art der Wertetypen zuwenden, dem enum. Enumerationen sind oft ein heißes Diskussionsthema: Die einen lieben und die anderen hassen sie. Manche bezeichnen sie gar als böse. Diese Diskussion soll hier außen vor bleiben. Ich betrachte sie für diesen Versuch als das was sie sind: Ein weiterer Wertetyp.

Für diesen Versuch verwende ich wieder die Methode string.Format um eine formatierte Zeichenfolge darzustellen, in der der Wert einer Enumeration verwendet wird.
Bei der Zeichenfolgendarstellung einer Enumeration mit den Mitteln des Framework, wird immer ein Boxing durchgeführt. Egal ob in der Methode string.Format oder mit der ToString Methode einer Enumeration. Ein Blick in den IL-Code des folgenden Beispiel zeigt dieses Verhalten sehr schön. Zuerst der Code in C#:

static void Main(string[] args)
{
    var output = TestEnum.Entry8.ToString();
}

Und anschließend der erzeugte IL-Code:

.method private hidebysig static 
	void Main (
		string[] args
	) cil managed 
{
	// Method begins at RVA 0x2050
	// Code size 14 (0xe)
	.maxstack 1
	.entrypoint
	.locals init (
		[0] string output
	)
	IL_0000: nop
	IL_0001: ldc.i4.8
	IL_0002: box BoxingUnboxingTest.TestEnum
	IL_0007: callvirt instance string [mscorlib]System.Object::ToString()
	IL_000c: stloc.0
	IL_000d: ret
} // end of method Program::Main

In Zeile 15 und 16 ist gut zu sehen, wie zuerst der Wert der Enumeration in ein Object geboxt und anschließend die Methode Object.ToString aufgerufen wird.
Zum füllen eine Array vom Typ String mit 1 Millionen Werte benötigte die Methode string.Format mit dem Boxing im Schnitt etwa 13800 Millisekunden.

Im das Boxing zu vermeiden, habe ich mich für eine Erweiterungsmethode entschieden, welche in einem switch/case-Block die Zeichenfolgendarstellung des angegebenen Wertes der Enumeration zurückgibt:

internal static string GetName(this TestEnum value)
{
    switch (value)
    {
        case TestEnum.Entry1:
            return "Entry1";
        case TestEnum.Entry2:
            return "Entry2";
        case TestEnum.Entry3:
            return "Entry3";
        case TestEnum.Entry4:
            return "Entry4";
        case TestEnum.Entry5:
            return "Entry5";
        case TestEnum.Entry6:
            return "Entry6";
        case TestEnum.Entry7:
            return "Entry7";
        case TestEnum.Entry8:
            return "Entry8";
        case TestEnum.Entry9:
            return "Entry9";
        default:
            return "None";
    }
}

Wenn nun das vorangegangene Beispiel mit dieser Erweiterungsmethode wiederholt wird, sollte das Boxing aus dem IL-Code verschwunden sein.

.method private hidebysig static 
	void Main (
		string[] args
	) cil managed 
{
	// Method begins at RVA 0x2050
	// Code size 9 (0x9)
	.maxstack 1
	.entrypoint
	.locals init (
		[0] string output
	)
	IL_0000: nop
	IL_0001: ldc.i4.8
	IL_0002: call string BoxingUnboxingTest.Extensions::GetName(valuetype BoxingUnboxingTest.TestEnum)
	IL_0007: stloc.0
	IL_0008: ret
} // end of method Program::Main

Im Gegensatz zum vorherigen IL-Code Beispiel wird in Zeile 15 kein Boxing mehr durchgeführt, sondern statt dessen die Erweiterungsmethode aufgerufen die ja den erwarteten String zurückgibt.

Ist die Vermeidung des Boxings dieses mal messbar?
Ja, ist es. Die Variante unter Verwendung der Erweiterungsmethode benötigte rund 9270 Millisekunden. Sie ist rund ein Drittel schneller als die Vorherige Variante in der Boxing verwendet wird.

Fazit:

In den meisten Fällen, zumindest wenn Primitiven oder Zahlenwerte verwendet werden, braucht auf das Boxing und Unboxing keine besondere Rücksicht genommen werden.
Doch bereits bei der Verwendung von Werten aus Enumerationen ändert sich das Bild. Hier sollte im Einzelfall geprüft werden, wie sich der erzielte Nutzen im Verhältnis zum Aufwand verhält. Bei deutlich komplexeren Strukturen sind Tools wie etwa NDepend sehr hilfreich um festzustellen, ob und wo eventuell Boxing oder Unboxing verwendet wird,

Für mich ist das Boxing und Unboxing nun nicht mehr so böse, wie es oft dargestellt wird.
Natürlich können in verschiedenen Situationen Leitungseinbußen durch das Boxing oder Unboxing entstehen. Aber deshalb dieses überaus hilfreiche Compiler Feature per se als böse zu bezeichnen, schießt doch etwas über das Ziel hinaus.

With the Mango update of Windows Phone to Windows Phone 7 many things will be changed. One of them is a better support for mutitasking behaviour of your application. This package consists of new background tasks (a will report about this later) and a new state in the executing model of Windows Phone.

The new state

Until Mango, an Windows Phone app will be tombstoned (=process will be killed), if the user leaves the app with the start menu button and call another application. With Mango Microsoft now introduce a new state for an application: “Dormant”. If there is enough memory left, the Windows Phone OS let the process of your app in memory until a other application process will kick it out. The user can than use the new function “Press and hold the back button for two seconds” to open the Mango fast switch application screen to return to one the dorming apps.

Is it really new?

But this state for your application is not really new. Because today with Windows Phone application development for version 7.0, you have to consider this state also. If you have a long running deactivation process, for example because of serialization, it could be that the user returns quicker back to your application than the deactivation is finished. In that case you have to handle the same behaviour that your old process is still running.

How to handle the revival

To distinguish between a activating of your app after tombstoning or revival you can use the IsApplicationInstancePreserved property of the ActivatedEventArgs in the Activated event of your app in that way:

private void ApplicationActivated(object sender, ActivatedEventArgs e)

{

    if (e.IsApplicationInstancePreserved)

    {

        ApplicationDataStatus = "application instance preserved.";

        return;

    }

    if (PhoneApplicationService.Current.State.ContainsKey("ApplicationDataObject"))

    {

        ApplicationDataStatus = "data from preserved state.";

        ApplicationDataObject = PhoneApplicationService.Current.State["ApplicationDataObject"] as string;

    }

}

Because in the case of application revival after the dormant state the constructors of your pages are not run through, you can define a bool variable which indicates in the NavigatedTo-Event if your application was tombstoned or not. It is not a good idea to create a static class with a starting state, which is set during the activating event, because the NavigatedTo of your page could be called earlier than the activated event (in case of long running deactivation, for example).

So best practice is to define a private member IsNewPageInstance, which is set to true within the page constructor.

bool isNewPageInstance = false;

// Constructor

public MainPage()

{

    InitializeComponent();

    this.isNewPageInstance = true;

}

In the NavigatedTo-Event we know now, if we have to restore our page state:

private void ApplicationActivated(object sender, ActivatedEventArgs e)

{

    if (e.IsApplicationInstancePreserved)

    {

        ApplicationDataStatus = "application instance preserved.";

        return;

    }

    if (PhoneApplicationService.Current.State.ContainsKey("ApplicationDataObject"))

    {

        ApplicationDataStatus = "data from preserved state.";

        ApplicationDataObject = PhoneApplicationService.Current.State["ApplicationDataObject"] as string;

    }

}

Testing of Tombstoning with the emulator

Another greeat new feature of the new Mango Windows Phone tools is that you can force the debugger to produce a tombstoning behaviour. The achieve this, you have to check a checkbox in the project properties of the debugging area.

Conclusion

With the new state “dormant” and the fast switching ability of the Windows Phone OS for the Mango version in combination with the new backgound tasks Microsoft give us the tools of trade to emulate a better multitasking appearance. This behaviour is now similiar to other mobile plattforms and still assure a good battery life time. For me, a great step in the right direction.

This post is powered by www.Giza-Blog.de |
Visit:  Giza-Blog.de Facebook-Page | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2011 Kay Giza. All rights reserved. Legal

Windows 8 bekommt eine neue Shell, sie wird als Standard-Shell anstelle des klassischen Windows Explorer zu Einsatz kommen. Die Shell ist dass neue Start-Menu, sofern es der Rechner zulässt. Ob man den Windows Explorer als Start-Shell festlegen kann ist derzeit nicht bekannt. Kann mir aber die eine oder andere Gruppenrichtlinie dazu vorstellen.

Bedienung

Neben der Optimierung auf Touch Bedienung werden die dort ausgeführten Anwendungen im Vollbildmodus betrieben und sollen sich wohl dem Metro-Design verschreiben. Doch auch die Tastatur und Maussteuerung ist möglich. Die Oberfläche kommt ohne Hardwaretasten aus, es besteht für die Hersteller jedoch die Möglich Funktionen wie “Start”, “Suchen” etc. auf Hardwaretasten zu legen.

Durch den Vollbild-Modus ist der Focus auf eine Anwendung gegeben. Dies ist in der heutigen Zeit des Informationsüberflusses auch gar nicht mal so übel. Zusätzlich hat man die Möglichkeit auch eine zweite in einem 1/4 des Bildschirm einzublenden. Dies jedoch nur wenn man einen Widescreen Bildschirm hat. Somit ist zu erwarten dass sich Tablets mit Windows 8 zum Großteil im 16:9 (bzw. 16:10) Format geben wird. Heutige Monitore und und Laptops sind auch fasst nur noch so zu bekommen.

Nicht immer zwei Anwendungen

Hat man nur einen 4:3 Bildschirm, so fällt die Möglichkeit der zweiten Anwendung weg. Durch Windows als Grundlage ist jedoch echtes Multitasking vorhanden und eine Anwendung kann im Hintergrund weiterlaufen. Jedoch sollte man sich als Entwickler der Anwendung drüber nachdenken wie man im Hintergrund entweder nichts, oder nur sehr wenig machen kann um z.B. beim Einsatz auf einem Tablet das Akku zu schonen.

Back to the Roots

Unterschreitet man eine gewisse Auflösung (z.B. bei kleinen Netbooks) steht das Metro-Vollbild-UI nicht zu Verfügung und es wird nur der Windows-Explorer als Start-Shell genommen. Dies macht für mich aktuell nicht wirklich Sinn.

Der klassische Windows Explorer bindet sich in die neue Start-Shell als Vollbildanwendung ein, darauf laufen die ganzen Anwendungen die nicht für die neue Shell gedacht sind und natürlich alle “alten” Anwendungen. Aktuell ist dies der Windows Explorer wie unter Windows 7 mit ein paar kleineren Anpassungen. Eine Ribbon-Bar und der klick auf den Start-Bubble führt zurück zur neuen Start-Shell. Wir werden sehe ob sich da noch etwas weiter beweget.

Alles in allen gefällt mir das Konzept für Tablets, es ist nicht so Start wie das iOS auf dem iPad, jedoch nicht ganz so flexibel wie bei Android 3.x Tablets.  Wie es sich als Start-Menü mit Maus- und Tastatur macht wird man erfahren müssen.

Begeisterung durch Entwicklung mit HTML5, JavaScript

Will man sich in die Start-Shell Integrieren, so bedient man sich HTML5 und JavaScript. Diesen Schritt finde ich hervorragend. Microsoft hätte keine bessere Wahl treffen können als die Erweiterung und Entwicklung mit HTML5 und JavaScript zuzulassen. Ich hoffe dass im gleichen Schritt beim Internet Explorer 10 ein entsprechendes Erweiterungsmodel kommt.

Wohin ein einfach zugängliches Erweiterungsmodell führen kann zeigt uns das Ökosystem rund um Firefox und Chrome. Erweiterungen ohne Ende in jeglicher Prägung. Natürlich auch in jeglicher Qualität. Auf dem Internet Explorer ist dies eher stiefmütterlich, schwierig und erfordert eine Entwicklungsumgebung. Bei Chrome und Firefox ist dies durch JavaScript, HTML und XML viel einfacher.

Wie das App-Model für die neue Start-Shell genau aussieht, welche Möglichkeiten es genau gibt wird sich zeigen. Ich erwarte mir davon einen erheblichen Gewinn für Windows 8. Da eben so auch nicht die “üblichen” Entwickler sich einbringen können,  da die Einstiegshürden viel geringer sind. Viele gute Ideen scheitern einfach daran dass sie keiner Umsetzt.

Ob es ein weiteres Model für die Entwicklung dafür gibt ist bis jetzt nicht bekannt, ich gehe davon aus dass sich wenigstens mit eigenen Vollbild-Anwendungen in die Start-Shell einklinken kann.

In Aktion

Alles in allem ein riesen Schritt, auch in die richtige Richtung.

Jetzt war es endlich soweit: Auf der D9 - All Things Digital-Konferenz wurde zum ersten Mal enthüllt, was uns alle mit Windows 8 erwartet.

Hier einige Schlagzeilen:

• komplett neue, dynamische Shell (Explorer) im Metro-Design (Windows Phone 7 sehr ähnlich, und das mit Absicht)
• schnelle und super flüssige Touch-Bedienung (aber auch – ohne Kompromisse - mit Maus und Tastatur bedienbar)
• natürliches Umschalten zwischen laufenden Anwendungen per Wischbewegung
• volle Kompatibilität mit bisherigen Windows-Anwendungen, die im Windows 7-Stil gezeigt werden
• der Internet Explorer 10 nutzt wirklich jedes Pixel an vorhandenem Platz

Man muss es selbst sehen, um einen Eindruck davon zu bekommen. Das offizielle Microsoft Video zum Windows 8 Sneak Peek ist hier zu finden.

Home Screen mit interaktiven Kacheln (Tiles), die wichtige Informationen aus den dahinter stehenden Applikationen zeigen:

Internet Explorer 10, hier im Eingabemodus:

… und im Full Screen Mode (Standard):

Eingabe per Touch-Keyboard:

umschaltbar auf ein Slate-Keyboard für die Bedienung mit zwei Daumen:

Side by side: Windows 8-optimierte Apps und herkömmliche Anwendungen, wie Excel

touch-optimierter FileBrowser:

Fazit:

Windows 8 wird für Touch-Bedienung optimiert sein, läßt sich aber auch ganz “normal” bedienen. Per HMTL 5 können Web Apps direkt mit den Live Tiles des Startbildschirms kommunizieren, ohne dass diese im Vordergrund sein muss. 

In diesem sehr ausführlichen und interessanten Video zeigt Microsoft VP Mike Angiulo auf der Computex 2011 die ersten Highlights von Windows 8

Die offizielle Pressemitteilung findet sich hier.

But that’s not all we have to say …

Den nächsten Termin unbedingt vormerken: 13.- 16. September 2011, die Konferenz für Windows 8 [// Build Windows] von Microsoft in Anaheim, Ca. Die Registrierung ist offen!

Tja, da wurde am 2. Juni in der Nacht Windows 8 auf der D9-Konferenz vorgestellt.

Neuer Startbildschirm, per Touch (sowie Maus- und Tastatur) steuerbar. Alles fließt und wechselt schnell, das Paradigma ist Vollbild und Metro Design. Steven Sinofsky erklärte dass man dafür in HTML5 und JavaScript entwickeln wird und dafür eine API zu Verfügung steht um auch “richtige” Anwendungen in HTML5/JS zu machen.

Einige .NET Entwickler sehen direkt ihre Felle wegschwimmen. 10 Jahre .NET, 3 Jahre Silverlight/WPF einfach wegschmeißen. Nun muss man in HTML5/JS die Anwendung entwickeln damit sie gut aussieht, so deren Meinung.

Doch wissen tuen sie es nicht, ich auch nicht. Jedoch gehe ich nicht vom schlimmsten aus, dass man nur noch in JavaScript entwickeln kann. So dämlich kann Microsoft gar nicht sein. Wenn man wie die Gerüchtelage derzeit ist vom Windows 8 Release in Q2 2012 ausgeht wäre es von der BUILD-Konferenz bis zum Release gerade mal maximal 9 Monate in der Entwickler Zeit haben was dafür zu machen. Und die Entwickler zu vergraulen in dem man ihnen HTML5/JS vorsetzt halte ich gelinde gesagt für Humbug.

Ja, das Startmenü wird man in HTML5/JS erweitern und ansprechen müssen, auch wird es in HTML5/JS möglich sein Anwendungen schreiben. Aber dies wird sicher nicht der einzige Weg sein.

Es spricht nichts dagegen dass man Anwendungen in Silverlight/OOB schreibt, man kann Anwendungen auch in WPF, WinForms, Win32/MFC schreiben. Es ist halt ein Windows. Alles was jetzt läuft wird auch dann laufen. Und Microsoft wird den Entwicklern zumindest in Sliverlight und WPF Controls zu Verfügung stellen die dem Metro-Look entsprechen. Dies machen sie heute schon in Windows Phone 7. Da hat man auch zwei Systeme, einmal das Native Windows Phone UI und Silverlight mit eigenen Controls. Win32/MFC wird man den ThirdParty Herstellern überlassen.

Das neue Startmenü ist meines Erachtens nicht nur ein einfacher UI Aufsatz. Es ist der zentrale Container, dieser Container beinhaltet alle Anwendungen, jeweils im Vollbild zum umschalten. Der jetzige Windows Desktop ist auch nur eine Anwendung in diesem Container. Dies zeigt sich daran dass er genauso wie die neuen Anwendungen ins System fließt. Man kann ihn genauso ein- und ausblenden, umschalten wie die neuen Anwendungen. Auch das teilen der des Bildschirms ist mit ihm ebenso möglich. Auf diesem Desktop werden alle normalen Anwendungen laufen.

Ich gehe davon aus dass man seine nicht JavaScript Anwendungen den Look & Feel der neuen Anwendungen verpassen kann, in der von sich bevorzugten und von Microsoft unterstützen Plattform (.NET, Silverlight und Win32). Und man wird der Anwendung per Manifest oder Code mitgeben können dass sie sich doch ebenso in den Startmenü Container integrieren soll wie der Windows Desktop, jedoch nicht auf diesem sondern einen eigenen Screen. Dann kann man genauso zwischen allen Anwendungen umschalten wie man es dann von Windows 8 gewohnt ist. Mehr ist es nicht.

Bleibt nur die Sache mit den Live-Tiles, da denke ich dass man diese mit HTML5/JS machen muss, da wird man nicht drum herum kommen. So muss man nur mit seiner Anwendung kommunizieren und die gewünschten Informationen darstellen. Und so ein kleines Live-Tile in HTML5 zu machen wird keinen Entwickler vor eine großer Herausforderung stellen.

So, nur mal meine 2 Cents.

One of the cool new features of the Windows Phone 7 Mango release (Windows Phone 7.5) is the posibility to use turn by turn navigation with voice guidance. This feature of Windows Phone Mango is integrated in the standard Bing Maps application and can use by developers from their own Windows Phone apps by the BingMapsDirectionsTask.

In my sample I have added two GeoCoordinate objects. One with my home place and the other with my working place at SDX AG. With the common concept of Windows Phone for interaction by using a Launcher or Chooser task you can then create a BingMapsDirectionsTask instance, set the locations as LabeledMapLocation to the start respectively end property of the BingMapsDirectionsTask and call the Show()-Method.

After this your application put in the background and the standard Bing Maps application will be called. Now you can use the standard turn by turn navigation features with voice guidance.

Conclusion

The new BingMapsDirectionsTask and turn-by-turn navigation features of the Bing Maps application of Windows Phone is a very cool function which will enable developers to build a new kind of Windows Phone applications. Furthermore all applications like “Where is my next bank or letter box” now can give the user the ability to give navigating instructions to this place.

Sample Code

private readonly GeoCoordinate destination;

private readonly GeoCoordinate target;

// Constructor

public MainPage()

{

    InitializeComponent();

    destination = new GeoCoordinate(49.907903, 8.510628); // Home

    target = new GeoCoordinate(50.139836, 8.742199); // SDX AG

}

private void NavigateButtonClick(object sender, RoutedEventArgs e)

{

    var bingMapsDirectionsTask = new BingMapsDirectionsTask();

    var destinationLocation = new LabeledMapLocation(

        "Home",

        destination);

    var targetLocation = new LabeledMapLocation(

        "SDX AG",

        target);

    bingMapsDirectionsTask.Start = destinationLocation;

    bingMapsDirectionsTask.End = targetLocation;

    bingMapsDirectionsTask.Show();

}

Vor gut zwei Monaten habe ich hier im Blog über meine Erfahrungen mit Windows Web Servern von Hetzner berichtet. Auf Grund der schlechten Erfahrungen hatte ich meine zwei Webserver bei Hetzner gekündigt und bin zu Strato gewechselt.

Das Angebot

Strato hat im Moment folgendes sehr attraktives Angebot:

• Windows 2008 R2 Hyper-V Web Server
• 4 GB Ram
• 200 GB HDD
• 4 Kern Prozessor

Bestellung

Die Bestellung des Servers war im Handumdrehen geschehen, allerdings dauerte es 1,5 Tage, bis der Server bereitgestellt wurde. Hetzner war mit wenigen Stunden deutlich schneller, obwohl es sich bei Hetzner um echte Hardware handelte und nicht um eine virtuelle Maschine wie bei Strato.
Als kleinen Nachteil sehe ich, dass pro Server nur eine IP Adresse bestellt werden kann.

Software

Auf dem Server war wie angegeben, Windows 2008 R2 Web Edition installiert, allerdings in Deutsch. Gerade bei der Konfiguration des IIS ist die deutsche Übersetzung schon sehr gewöhnungsbedürftig. Ich möchte meinen App-Pool gern recyceln und nicht wiederverwenden :-)
Auf dem Server war ebenfalls ein SQL Server 2008 R2 Express installiert, was natürlich keine schlechte Idee ist. Sonst war keine störende Software wie zum Beispiel Plesk installiert.
Über die Strato-Weboberfläche ist es möglich, einen Neustart im Rescue-Mode zu veranlassen. Dann startet der Server mit einer Windows PE Installation. In dieser Umgebung hat man Zugriff auf seine Festplatten und kann so ggf. Daten sichern oder wiederherstellen.

Leistung und Stabilität

Die Performance des Servers würde ich als gut bezeichnen, wobei man deutlich merkt, dass man auf einer virtuellen Maschine ist und nicht auf einer echten Hardware. Da der Windows Server stark auf Hintergrunddienste optimiert ist, ist nur die Windowsoberfläche etwas träge. Der IIS und der SQL Server laufen stets flüssig.
Der Server hatte in den zwei Monaten keinen Ausfall, die Error Logs sind absolut sauber.

Support

Bei einem Webserver ist der Support fast noch wichtiger als die Leistung oder der Preis.
Leider kann Strato hier ganz und gar nicht überzeugen. Eine Antwort auf eine Emailanfrage dauert in der Regel 1,5 Tage. Das darf einfach nicht sein. Mit etwas Geduld ist aber telefonisch immer jemand zu erreichen, echte Hilfe bei Problemen ist aber auch per Telefon nicht zu erwarten. Bei einem Problem mit der Windows Firewall sagte mir ein Supportmitarbeiter nur: „Mit Linux wäre das sicher nicht passiert, da würde ich mich auch auskennen. Sie müssen eben alles neu installieren.” - Da ist man erst mal sprachlos.

Mein Tipp: Wer sich einen V-Server bei Strato mieten möchte, sollte sich doppelt und dreifach durch Backups und Alternativen zur Remote-Desktop-Verbindung absichern. Im Ernstfall braucht man keine Hilfe erwarten.

Backupmöglichkeit

Gibt es nicht! Strato bietet zu den V-Servern keine Backupmöglichkeit an, obwohl sie mit dem Produkt „HiDrive” einen ganz brauchbaren Online Speicher im Programm haben.
Stratos Zielgruppe für das HiDrive scheinen im Moment nur Consumer zu sein.

Fazit

Legt man Wert auf Support oder Flexibilität ist man mit Strato V-Servern schlecht beraten, jedoch bekommt man für wenig Geld einen leistungsfähigen und gut ausgestatteten virtuellen Server.

Logo und Fotos: Strato