.
Anmeldung | Registrieren | Hilfe

.NET-Blogs Archiv Februar 2010

MSDN TV - Ausgabe 26.02.2010: Interview mit den Community Programm Managerinnen Dorothea Henke und Katrin Letzel

28.02.2010 12:23:43 | Kay Giza

Mit dem Engagement der Microsoft Community beschäftigt sich Moderator Jan Schenk in der aktuellen Folge von „MSDN TV“. Zu Gast hat er mit Dorothea Henke und Katrin Letzel dabei zwei Microsoft-Verantwortliche, die sich im Rahmen des MVP-Programms und der Initiative CLIP um die Betreuung und Unterstützung von On- und Offline-Communities sowie von unabhängigen Experten kümmern. In den Kurznachrichten vorab: Aktuelles zum ... [... lesen Sie den vollständig Blogeintrag auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Kostenloser MSDN TechTalk im Maerz: SharePoint 2010

28.02.2010 12:09:48 | Kay Giza

Mit alten Vorurteilen in Sachen „SharePoint“ aufräumen will MSDN-Experte Tom Wendel bei der nächsten Runde der kostenlosen TechTalk-Veranstaltungen, die Ende März 2010 in Berlin, Hamburg, Karlsruhe, Köln und München stattfinden. Dabei stellt er nicht nur den Funktionsumfang des neuen SharePoint 2010 vor, sondern zeigt auch, welche vielfältigen Möglichkeiten die Anwendung aus Entwicklersicht bietet. Gleich anmelden und kostenlosen Platz sichern! Nicht erst mit seiner neuesten... [... mehr in diesem Blogeintrag auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Browserwahl: Web-Browser-Auswahlfenster von Microsoft

28.02.2010 11:51:02 | Kay Giza

Aufgepasst! Basierend auf der Vereinbarung mit der Europäischen Kommission (EU) vom Dezember 2009 können Anwender des Microsoft Betriebssystem Windows in 32 europäischen Ländern in Kürze über einen neuen Auswahlmechanismus, genannt "Browserwahl", "Browserauswahl" oder englisch "Browser Choice", für einen Internetbrowser ihrer Wahl entscheiden. Microsoft muss Kunden, die aktuell Internet Explorer als Standardbrowser verwenden, darüber informieren, dass auch andere Webbrowser zur Nutzung zur Verfügung stehen. D.h. man kann sich über die derzeit aktuellsten Web-Browser informieren und einen Browser als Standard setzen. Meine persönlich Meinung und Empfehlung ist... [... lesen Sie in diesem ausführlichen Blogeintrag auf Giza-Blog.de die Hintergründe, Details, sehen Sie sich Screenshots an und lesen Sie die am häufigsten gestellten Fragen und deren Antworten]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Zugriff auf Listeninhalte mit LINQ to SharePoint

27.02.2010 20:06:00 | Martin Hey

In der in diesem Jahr erscheinenden Version bietet SharePoint mit der Assembly Microsoft.SharePoint.Linq.dll (zu finden im Ordner 14\ISAPI) die Möglichkeit, recht einfach Listeninhalte abzufragen. Wenn man sich etwas näher damit beschäftigt, kann man sehr viele Parallelelen zu LINQ to Objects und Linq to SQL entdecken.

Erster Schritt ist, eine Referenz auf die genannte Assembly hinzuzufügen. Ab diesem Zeitpunkt steht der Namespace Microsoft.SharePoint.Linq zur Verfügung. Dieser beinhaltet die Klasse DataContext, über die ähnlich wie bei LINQ to SQL auf die Inhalte zugegriffen werden kann. Die Initialisierung des Kontexts ist recht einfach – hierzu wird einfach im Konstruktor des Objekts die Url der zu verwendenden Site übergeben.

Vor dem Erfolg steht aber ein wenig Arbeit, denn der Zugriff ist typsicher und so müssen für die verwendeten Inhaltstypen Klassen angelegt werden, damit klar ist, welche Property sich in welchem Listenfeld abbildet und wie darauf zugegriffen werden muss. Diese kann man selbst schreiben, oder man nutzt dafür ein Tool ;). Auch hier zeigen sich wieder Parallelen zu bereits Bekanntem: Mit Hilfe des Tools SPMetal (zu finden im Ordner 14\BIN) können die Klassen auf Basis einer bestehenden Site automatisch erstellt werden.

Ab diesem Zeitpunkt ist es recht einfach, wie das folgende Beispiel zeigt:

DataContext data = new DataContext("http://mysite/");

EntityList<Page> wikiPages = data.GetList<Page>("Pages");
var filteredPages = from wikiPage in wikiPages
where wikiPage.Name == "product-presentation.aspx"
select wikiPage;

foreach (var filteredPage in filteredPages)
{
Console.WriteLine(filteredPage.Path);
}

Wenn man der Dokumentation Glauben schenken darf, wird bei der Ausführung versucht, so viel wie möglich in CAML zu übersetzen und direkt und damit schnell auszuführen und der Rest wird dann mit Hilfe von LINQ to Objects im Speicher ausgeführt. Allerdings muss ich dazusagen, dass SharePoint 2010 noch nicht final ist und sich sowohl an den Schnittstellen als auch an der Doku noch einiges tun kann.

Nachlese zum Treffen der .NET Usergroup Dresden am 24.02.2010

27.02.2010 19:50:00 | Martin Hey

Vergangenen Mittwoch war es wieder einmal soweit und es fand ein Treffen der .NET Usergroup Dresden statt. Wie bereits angekündigt, hatten wir dieses Mal Alexander Groß zu Gast, der uns ein aktuelles Projekt zeigte. Fachlich ging es dabei um ein Gebiet mit dem sich wohl die Wenigsten schon beschäftigt haben. Aber das war ja auch nicht das was uns hauptsächlich interessierte.
Im Gegensatz zu den meisten anderen Treffen, die hauptsächlich darauf ausgerichtet sind, dass anhand von Slides ein bestimmtes Themengebiet rübergebracht wird, ging es dieses Mal eher um "Diskussion am lebenden Objekt" von der beide Seiten etwas haben. Und so ging es auch nach einer kurzen Einleitung und Vorstellung des fachlichen Hintergrunds in tiefe und interessante Diskussionen. Alexander zeigte, wie durch AutoMapper Objekte der Business-Logik zu Views transformiert werden können, wie er Castle Windsor einsetzt, um Abhängigkeiten von Objekten in Tests aufzulösen, wie mit Hilfe von Rake dynamische Konfigurationen aus Templates erzeugt werden können und wie letztenendes die Applikation mit Hilfe von MSDeploy auf das produktive System kommt.
Zusammenfassend haben wohl alle den ein oder anderen Anstupser bekommen, um in ihren eigenen Projekten auch mal über den Tellerrand zu schauen und auch Alex konnte ein wenig Feedback zu seiner Implementierung bekommen.

API-Design vom Feinsten

27.02.2010 14:23:00 | Jörg Neumann

Neulich bin ich in MEF auf eine echte API-Design-Perle gestoßen.
Der folgende Code führt eine Composition der Parts durch:

public partial class MainWindow : Window
{
  ...
  private void Compose()
  {
    string path = Path.GetDirectoryName(
      Assembly.GetExecutingAssembly().Location);
    DirectoryCatalog catalog =
      new DirectoryCatalog(path);
    CompositionContainer container =
      new CompositionContainer(catalog);
    container.SatisfyImportsOnce(this);
  }
  ...
}

Das Problem hierbei ist, dass der oben stehende Code nicht in jedem Fall kompiliert werden kann. Schauen wir uns die entscheidende Stelle mal genauer an:

container.SatisfyImportsOnce(this);

Die Methode SatisfyImportsOnce() erwartet einen Parameter vom Typ ComposablePart. Nun leitet die oben deklarierte Klasse MainWindow jedoch nicht von ComposablePart ab. Somit ist schnell klar, warum der Code sich nicht kompilieren lässt – möchte man denken.
Er lässt sich jedoch fehlerfrei kompilieren, wenn man den Namespace System.ComponentModel.Composition eingebunden hat!
Dieser enthält nämlich eine Extension Method, die ebenfalls SatisfyImportsOnce() heißt, jedoch einen Parameter vom Typ object erwartet! CompositionContainer ist jedoch im Namespace System.ComponentModel.Composition.Hosting beheimatet, sodass die Verbindung zur Extension Method nicht unbedingt klar ist.

Ein schönes Beispiel dafür, wie man Sprach-Features dafür nutzen kann, den Entwickler maximal zu verwirren ;)

BlogEngine.NET und die Ping Services

27.02.2010 13:22:43 | Klaus Bock

Wer die Ping Dienste von BlogEngine.NET verwendet, sollte sich einmal die Klasse PingService.cs und die Beschreibung der verwendeten XML-RPC API auf Weblogs.com ansehen. BlogEngine.NET sendet als zweiten Parameter im XML-RPC Request die komplette URL des gerade veröffentlichten Artikel. Gefordert wird aber lediglich die Basis-URL des sendenden Blog. Dieses Verhalten ist wohl schon mehreren Benutzern von BlogEngine.NET aufgefallen. So schreibt z.B.: Gabriele Lässer in ihrem Artikel Modifizierte Version BlogEngingeNET 1.5.0.7, Zitat:

Ping-Dienste bestehen fallweise darauf, dass stattdessen nur die Blog-URL selbst angegeben wird.
Sie blockieren/ignorieren so fehlerhafte Pings gerne oder gar das versendende Blog.

Im oben genannten Artikel bietet Gabriele Lässer auch gleich eine passende Lösung an. Dieser Ansatz ist zwar für die Version 1.5.0.7 gedacht, sollte in der aktuellen Version aber ebenfalls funktionieren.

Für mein Empfinden, ist die genannte Lösung etwas zu aufwendig gestaltet. Der Knackpunkt ist ein zusätzlich benötigter Wert, in dem die Basisadresse des jeweiligen Blog gespeichert wird. In der angesprochenen Lösung, wird die genannte Adresse in den Blogeinstellungen gespeichert, was einiges an Änderungen der bestehenden Installation nach sich zieht. Vor allem bei Updates ist es immer mühsam und zeitraubend, die ganzen Änderungen in die neuere Version zu übernehmen.

Da BlogEngine.NET immer die Komplette URL des jeweiligen Artikel sendet, ist die Basis-URL in der Artikel-URL ja bereits vorhanden. Also kann mit einem Einzeiler die ganze Problematik gelöst werden.

//writer.WriteElementString("value", url.ToString());
writer.WriteElementString("value", url.GetLeftPart(UriPartial.Authority) + Utils.RelativeWebRoot);

Der Ansatz aus Gabriele Lässers Artikel bietet noch einiges mehr. Unter anderem auch die Möglichkeit eines Extended Ping XML-RPC Request, mit dem auch der RSS-Feed oder Tags des Blog mit gesendet werden können.

Fazit:

Wer die erweiterte Funktionalität eines Extended Ping XML-RPC Request verwenden will, der sollte sich den Ansatz aus Gabriele Lässers Artikel einmal genauer ansehen.
Wer eine pragmatische Lösung sucht, der braucht nur eine Zeile Code in der Datei PingService.cs, wie im obigen Listing gezeigt, auszutauschen.

Technorati-Tags: | |

Slides & Samples von der BASTA! Spring

27.02.2010 12:33:00 | Jörg Neumann

Die BASTA! Spring war mal wieder ein echtes Highlight im Konferenzkalender. Vielen Dank an die Teilnehmer meiner Sessions für das positive Feedback!
Die Slides & Samples meiner Sessions findet Ihr hier:

PS: Die BASTA! geht auf Tour. Vom 18. bis 19. Mai findet in München die erste BASTA! on Tour statt. Mehr Infos gibt's hier. Ich werde dort zwei Sessions zum Thema Client Development, sowie einen ganztägigen WPF-Workshop durchführen.

Die VSone in München

26.02.2010 15:35:00 | Albert Weinert

Die Tage war ich in München und habe mir die VSone angesehen.  Hier nun mein Endruck der Tage.

Es war meine erste VSone, ich zuerst überrascht dass sie so kompakt ist. Ich schätze es waren so um die 350 Teilnehmer vor Ort. Dies finde ich positiv, dass ganze ist nicht so anonym und man läuft sich des öfteren über den Weg und hat somit viel Chancen mal wieder neue Leute kennen zu lernen. Dass ist ganz anderer Charme wie bei einem Konferenz mit mehreren tausend Teilnehmern. Mir hat dies sehr gefallen.

Die Räumlichkeiten sind für die Art der Konferenz ja schon fast als Ideal zu beschreiben. Viele Räumlichkeiten und trotzdem nie ein Raum dabei wo man dachte der Platz aus den Nähten. Alle Räumlichkeiten liegen beisammen und man kann auch mal schnell wechseln falls das “Ziel” der Session sich nicht mit den eigenen Erwartungen gedackt hat.

Einen Tick zu Sharepointlastig war mir der erste Tag, jedoch fanden sich auch dort Vorträge die meinem Interessengebiet entsprachen.  Der zweite Tag bot schon ein wenig mehr Abwechslung und Teilweise ein paar Auswahlprobleme. Hier und da hatte ich das Problem dass es nicht viel Neues für mich in den Vorträgen gab, aber so ist dies halt wenn man sich selbständig aktiv über das ganze Jahr hinweg weiterbildet und üblicherweise vor den Teilnehmern steht.

Am ersten Abend gab es dann “Party”, aber wie dies so ist mit Parties wo 98% der anwesenden Männer sind… schön schwierig da richtig Party-Stimmung aufkommen zu lassen. Passende Leute findet man auf jedenfall, schöner Abend mit viel Spaß. Nur halt keine Party im eigentlichen Sinne.

Scott Hanselman war auch angereist, er hielt die Keynote am zweiten Tag. Sehr unterhaltssam, jedoch hat es ihn wohl verwundert dass man in Deutschland schon was mehr machen muss wie eine Web.config mit 3 Zeilen zu zeigen um die Menge in Begeisterungsstürme zu versetzen. Wir sind hat halt kein Klatschvieh die alles und jedes übertrieben bejauchzen.

Die vielen Interessanten, ernsten und spaßigen Gespräche mit alten Bekannten und neuen Gesicherten haben mir viel freude gemacht.

Abends fand dann noch dass Nerddinner statt, ein wenig Insidermäßig versteckt aber es durfte sich jeder anmelden, auch nicht VSone Teilnehmer waren dort vertreten. Scott Hanselman durfte musste dann das Bierfass anstechen. Das ganze lange Vorgeplänkel von Erklärungen und übertriebenen Ankündigen vom spritzenden Bierfässern entlud sich dann jedoch in zwei unspektakuläre Schläge von Scott und der Zapfhahn war sicher im Fass eingebracht und wir konnten den Abend beginnen.

Wir waren im Bier- und Oktoberfestmuseum. Ein sehr schönes lokal bei dem man sich nicht vom Namen verleiten lassen sollten. Die Speisen waren hervoragend zubereitet und ausnahmslos von gutem Geschmack. Preislich war ich sehr überrascht, das Preis- Leistungverhältnis ist hervorragend. Also besucht den Laden. Als schöne Abschlussüberraschung übernahm Hannes Preishuber dann auch noch die gesamte Rechnung. Vielen Dank Dafür.

Alles in allem eine gute Konferenz mit einem schönen Gesamtpaket, ich muss schauen dass ich nächstes Jahr als Sprecher dabei bin.

Technorati Tags: ,,

VS 2010 : Coded UI Tests Nutzen und Erweitern

26.02.2010 15:03:00 | Christian Binder

Diese Woche hatte ich wieder einige sehr gute Gespräche auf der Basta und der VSone :-) Eines der Themen, die ich unter anderem zum Thema UI Automation gezeigt habe, war der Coded UI Test. Da in vielen Szenarien die Notwendigkeit besteht, den Coded UI Test zu erweitern, möchte ich hier kurz die Grundlagen beschreiben, welche die ersten Schritte erleichtern sollen. Als erstes gilt es, die verschieden Files und deren Funktion zu verstehen.

image 

CodedUITest.cs enthält alle Test Methoden und kann daher auch editiert werden.

UIMap.uitest ist ein XML File, welches alle Informationen des Recordings enhält. Es wird von dem Recorder erstellt und wenn Asserts oder neue TestSteps hinzugefügt werden erweitert. Im RC gibt es kein Editor für UIMap.uitest.

UIMap.Designer.cs enthält den Code der aus  UIMap.uitest generiert wird. Da UIMap.Designer.cs bei Änderungen immer wieder neu erzeugt wird, dürfen hier hier keine Änderungen vorgenommen werden.

UIMap.cs UIMap ist die Main class, die sich in UIMap.cs und UIMap.Designer.cs aufteilt. Hierbei ist UIMap.cs die partial class, welche nicht bei der Code Generierung angefasst wird und somit das File, in welchem Anpassungen vorgenommen werden können.  

Damit ich nicht so viel Schreiben muss, hab ich ein Demo dazu aufgenommen:
Video Coded UI Test Erweitern Basics

Da es noch eine ganze Reihe zusätzlicher Themen zur Erweiterung des UI Test Frameworks gibt, findet man hier ein Index zu allen Ressourcen vom Produkt Team:
Content Index Coded UI Test

Viel Spass
Chris

TechTalk März 2010: SharePoint 2010 - und warum Sie das als Software-Entwickler interessieren sollte

26.02.2010 08:07:32 | Oliver Scheer

Nicht erst mit seiner neuesten Version hat sich der Office SharePoint Server im Webbereich als äußerst flexibles Allround-Werkzeug etabliert und ist entsprechend weit verbreitet. Trotzdem pflegen nicht wenige Entwickler ihre Vorurteile gegenüber der Anwendung, etwa: SharePoint ist eh nur ein System zum Verwalten von Listen!

Dass die Realität weit von dem entfernt ist, zeigt Ihnen MSDN im Rahmen der kostenlosen TechTalk-Roadshow,  die im März wieder in fünf Städten Station macht. MSDN-Experte Tom Wendel gibt dabei  einen umfassenden Einblick in den Funktionsumfang des neuen SharePoint 2010 und zeigt aus Entwicklersicht, wo überall Sie bei der Anwendung selbst  Hand anlegen können, um dem SharePoint zu vollem Potential zu verhelfen.

Daten/Locations:

  • 22. März 2010, Köln
  • 23. März 2010, Hamburg
  • 24. März 2010, Karlsruhe
  • 29. März 2010, Berlin
  • 30. März 2010, München

Details und Anmeldung unter: http://www.microsoft.com/germany/msdn/techtalk/aktuell2/default.mspx

BASTA! Tag 5: Ein Tag mit Windows Azure

26.02.2010 06:55:00 | Jürgen Gutsch

Warum Windows Azure? Das ist der einzige Workshop m Freitag, der für mich ein absolut neues Thema beinhaltet. Ich hatte bisher nur sehr wenig über Azure gelesen, aber nie wirklich angeschaut. Ich bin also sehr gespannt, was der Workshop alles bringen wird.

Bevor Rainer Stropek mit dem Eigentlichen Workshop beginnt, beschreibt er die Möglichkeiten, die Nachteile und die Vorteile von Windows Azure und Cloud Computing allgemein. Ebenso geht er auf die Datenschutzbedenken ein, die bei der Arbeite mit Windows Azure auftreten. Das Ergebnis ist, das es Recht kritisch ist Azure zu verwenden, dass man genau überlegen sollte, welche Daten man in der Cloud ablegen möchte. Später kommt er zu den Voraussetzungen für die Entwicklung mit Windows Azure.

Vor der Kaffeepause zeigt Rainer eine eine kleine “Hallo Welt”-Demo einer kleinen Cloud-Anwendung.

Nach der Pause ging es weiter mit der Entwicklung einer klassischen ASP.NET Anwendung die anschließend in die Cloud gestellt werden soll. Es ist erstaunlich, wie einfach es ist mit der SDK zu arbeiten und lokal die Cloud-Anwendung zu testen. Das Deploying mit Windows Azure schient dafür um einiges komplizierter zu sein :-/

Für mich selber sehe ich noch keinen Anwendungsfall für Windows Azure, allerdings kann man damit eine ganze Menge möglich machen und bietet einige bequeme Funktionen und Leistungen und insgesamt ist der Workshop sehr interessant und gut durchdacht und es machte Spaß mit Windows Azure herumzuspielen.

Weitere Informationen zu Windows Azure:
http://www.microsoft.com/windowsazure/

Azure Portal:
http://windows.azure.com/

Get started:
http://www.microsoft.com/windowsazure/getstarted/

Azure in der MSDN:
http://msdn.microsoft.com/de-de/azure/cc994380.aspx

DotNetKicks-DE Image

Fazit zu Speed Freak C# and .NET!

26.02.2010 01:28:03 | Jürgen Gutsch

Golo Roden fragte mich zu dem Beitrag über die BASTA! Session “Speed Freak C# and .NET!” von Christian Gross, was den mein Fazit zu dem Thema sei, ob wir jetzt alle öffentliche Felder statt Eigenschaften nutzen sollten, um die Performance der Anwendung zu steigern. Also wieder Crap Code statt Clean Code schreiben sollen.

Das ist definitiv nicht der Fall. Wir sollten natürlich weiterhin Clean Code schreiben. Bei normalen Anwendungen macht es keinen merkbaren Unterschied in der Geschwindigkeit aus, ob wir nun öffentliche Felder oder Eigenschaften verwenden

Diese Session hieß nicht umsonst “Speed Freak …”. In dem Fall der gezeigten Bloomberg Anwendungen ging es um mehrere tausende von Daten die Live dargestellt werden sollten, wie z. B: einem Börsenticker der live alle aktuellen Börsenkurse anzeigt. Der “Speed Freak” wollte zudem Beweisen, dass C# unter Umständen und unter Einhaltung bestimmter Regeln schneller sein kann als C++. Was er auch tatsächlich geschafft hat.

Ich bin nun der Meinung dass es möglich sein sollte, unter bestimmten Voraussetzungen die klassischen Regeln der Objektorientierung und Clean Code zu ignorieren. Und zwar dann, wenn es darum geht mehrere tausende von Daten auf einmal zu verarbeiten und darzustellen, bzw. dann wenn unbedingt Geschwindigkeit erforderlich ist. Und auch dann müssen diese performancesteigernden Möglichkeiten nicht auf die komplette Anwendung angewendet werden, sondern lediglich auf den Teil der Anwendung, der die entsprechende Leistung bringen muss. Wir dürfen nicht auf vorhandene Regeln und Gesetzte pochen, sondern sollten in Ausnahmefällen auch mal über den Tellerrand schauen und wenn es erforderlich ist, diese Regeln zu brechen, um möglicherweise auch auf diese Art noch etwas effektiveren Code zu schreiben.

DotNetKicks-DE Image

Vielen Dank, DNUG Koblenz!

25.02.2010 21:58:00 | Jan Christian Selke

Gestern war es soweit, die DNUG Koblenz feierte ihr zweijähriges Bestehen – herzlichen Glückwunsch! Zudem gab es für mich persönlich auch etwas zu feiern. Im Rahmen dieses besonderen Treffens habe ich mein Debut als Sprecher in einer UserGroup gegeben.

Ich möchte mich daher auf diesem Weg noch einmal bei allen an diesem Abend Anwesenden bedanken. Zum Einen für das an meinem Vortrag zum Thema serverseitige Word-Dokumenterstellung mit dem OpenXml SDK  gezeigte Interesse, zum Anderen auch das Durchhaltevermögen, dass letztlich nötig war, um den auf über 2,5 Stunden ausgedehnten Vortrag  bis zum Schluss zu verfolgen. Dieser Abend war eine neue Erfahrung für mich, die mir sehr viel Spaß gemacht hat.

Vielen Dank!

TechTalk März 2010: SharePoint 2010 - und warum Sie das als Software-Entwickler interessieren sollte

25.02.2010 15:12:24 | Peter Kirchner

Nicht erst mit seiner neuesten Version hat sich der Office SharePoint Server im Webbereich als äußerst flexibles Allround-Werkzeug etabliert und ist entsprechend weit verbreitet. Trotzdem pflegen nicht wenige Entwickler ihre Vorurteile gegenüber der Anwendung, etwa: SharePoint ist eh nur ein System zum Verwalten von Listen!

Dass die Realität weit von dem entfernt ist, zeigt Ihnen MSDN im Rahmen der kostenlosen TechTalk-Roadshow,  die im März wieder in fünf Städten Station macht. MSDN-Experte Tom Wendel gibt dabei  einen umfassenden Einblick in den Funktionsumfang des neuen SharePoint 2010 und zeigt aus Entwicklersicht, wo überall Sie bei der Anwendung selbst  Hand anlegen können, um dem SharePoint zu vollem Potential zu verhelfen.

Daten/Locations:

  • 22. März 2010, Köln
  • 23. März 2010, Hamburg
  • 24. März 2010, Karlsruhe
  • 29. März 2010, Berlin
  • 30. März 2010, München

Details und Anmeldung unter: http://www.microsoft.com/germany/msdn/techtalk/aktuell2/default.mspx

BASTA! 2010 Spring – Anwendungsarchitektur für WPF und Silverlight

25.02.2010 12:30:00 | Stefan Lange

Zu meinem Vortrag „WPF und Silverlight Architektur“ auf der BASTA! Spring finden sich hier die Materialien.

In diesem Vortrag ging es um die Architektur von WPF und Silverlight Anwendungen. Es wurden Möglichkeiten zur Strukturierung von Anwendungen vorgestellt und auch gezeigt, wie man Code zwischen WPF und Silverlight gemeinsam nutzen kann.

Der Beispielcode liegt in C# und VB.NET vor. An dieser Stelle ein großes Dankeschön an Thomas, der mir bei der Erstellung des VB Codes kräftig geholfen hat.

Materialien zu diesem Vortrag:

BASTA! Tag 4: NHibernate – The Open Source ORM Framework

25.02.2010 10:02:04 | Jürgen Gutsch

Meine letzte Session des Tages startet Hadi Hariri mit viel Humor in eine umfangreiche Einführung in die Vorteile von Domain Driven Design und O/R-Mapping.

Hadi erklärt tatsächlich drei Varianten das Mapping zu definieren: Attributes, Mapping File und (na endlich) Fluent Mapping (Das Fluent NHibernate hatte ich nämlich in der letzten NHibernate Session vermisst) Weiter geht es mit der Beschreibung der Features von NHibernate: Transaction, Units of Work, Sessions, Flush Mode, etc… und anschließend mit einigen Demos zu den Mappings. Für die Abfrage der Daten empfiehlt Hadi einen der Beiden LINQ to NHibernate Provider zu nutzen und nicht die anderen drei Möglichkeiten HQL, Criterias und SQL.

In der letzten Demo geht Hadi auf Fluent NHibernate ein :-) Interessant ist, dass Fluent NHibernate zwar nicht alle Mapping-Möglichkeiten abdeckt, aber, dass Fluent NHibernate mit XML-Mappings kombiniert werden kann.

DotNetKicks-DE Image

BASTA! Tag 4: 10 spannende Sachen, die man mit SQL Server CLR-Integration machen kann

25.02.2010 08:33:04 | Jürgen Gutsch

In dieser Session startet Thorsten Kansy (dotnetconsulting.eu) mit den Grundlagen der CLR Integration des SQL Servers, bevor er damit beginnt die 10 spannenden Sachen aufzuzählen. Interessant, dass CLR pro DB aktiviert werden muss und die Assemblies werden in der DB selber gespeichert. Letzteres vereinfacht die Weitergabe und Sicherung der DB mit den Assemblies. Zudem sollte die Assemblies signiert werden und muss mit bestimmten Sicherheitsstufen ausgezeichnet werden. Weiter geht es mit der Beschreibung der Visual Studio Unterstützung für die CLR-Integration. Bei der CLR-Integration müssen natürlich SQL-Datentypen übergeben oder zurückgegeben werden und nicht .NET-Datentypen. Zum debuggen werden Start-SQL-Scripts geschrieben, die die angelegten Funktionen aufrufen.

1. Reguläre Ausdrücke:
Funktionen im bereitstellen um im TSQL Reguläre Ausdrücke bereitzustellen.

2. Freie Datumsformatierung
Beliebige Formatierung von Datumswerten mit Hilfe der .NET DateTime.ToString().

3. String Concat
Verkettung von Zeichenketten, über mehrere Datensätze.

4. Asymmetrische Verschlüsselung
Verschlüsselung und Entschlüsselung von DB Inhalten.

5. Doubletten-Suche
Suchen von doppelten DB Einträgen, nach bestimmten Regeln.

6. SMTP E-Mailversand
Erweiterter Versand von E-Mails.

7. Aktuelle Börsenkurse abfragen
Abfragen über XML Dienste.

8. Benutzerdefinierter Datentyp
Eigene Datentypen die in der DB genutzt werden können.

9. Tabelleninhalt exportieren
Für den Export nach XML oder CSV

10. SSRS Bericht per E-Mail senden
SQL Server Reporting Service Berichte als PDF per E-Mail versenden

DotNetKicks-DE Image

BASTA! 2010 Spring – Von WinForms nach WPF

25.02.2010 07:30:00 | Stefan Lange

Zu meinem Vortrag „Von WinForms zu WPF“ auf der BASTA! Spring finden sich hier die Materialien.

In diesem Vortrag wurde die Schrittweise Migration von WinForms nach WPF diskutiert. Die Slides und der Beispielcode stehen zum Download bereit.

Materialien zu diesem Vortrag:

BASTA! Tag 4: NHibernate und Spring.Net

25.02.2010 06:52:01 | Jürgen Gutsch

Und wieder einmal Manfred Stayer ;-) Er startet mit einer Einführung in O/R-Mapping und in NHibernate. Bei der Beschreibung von NHibernate geht Manfred sehr detailliert auf das Mapping und die Konfiguration per XML ein und zeigt per LiveCoding die Funktionsweise von NHibernate. in einem weiteren LiveDemo stellt Manfred auch LINQ to NHibernate vor.

Weiter geht es mit einer LiveDemo mit Spring.NET als Dependency Injection Container und Service Locator. Etwas enttäuschend, denn nur um DI zu zeigen hätte ich eher einen kleineren schlankeren DI-Container verwendet.

Anschließend geht Manfred kurz auf die weiteren Features von Spring.Net ein, z. B: Transaktionsmanagement, Unterstützung fürs Unittesting. Zum Schluss zeigt Manfred die Vor- und Nachteile von NHibernate und Spring.Net.

DotNetKicks-DE Image

BASTA! Tag 4 Keynote: Writing Functional Code

25.02.2010 05:50:05 | Jürgen Gutsch

“Why Functional Code Matters”

Ted Neward vergleicht anhand diverse Methoden, die herkömmlichen objektorientierten Programmiersprachen mit funktionalen Programmiersprache. Ted beschreibt die Vorteile von funktionalen Sprachen bei diesen Methoden und vor allem die Nachteile und beschreibt, was diese besser machen können als die herkömmlichen Sprachen, bzw.  für was funktionale Programmierung eingesetzt werden kann. In dieser einstündigen Keynote geht Ted sehr umfangreich und ausführlich auf dieses Thema ein.

(Ich möchte hier nicht detailliert auf die einzelnen beschriebenen Aspekte eingehen, da es hier im Moment einfach zu viel ist)

Zum Abschluss relativiert er seine provokanten Ansichten über funktionale Programmierung in dem er sagt, dass funktionale Programmierung die objektorientierte nicht ersetzen soll, sondern eher als unterstützendes Werkzeug angesehen werden sollte.

DotNetKicks-DE Image

BASTA! Tag 4: Data Binding Deep Dive

25.02.2010 02:43:03 | Jürgen Gutsch

Was man aus dem Titel dieser Session vom Rainer Stropek (software architects) leider nicht sehen konnte war, dass es sich hier um Databinding in Silverlight und WPF handelt. Rainer Stropek beginnt mit einer sehr anschaulichen Einführung in das MVVM. Cool an dieser Session: Rainer hält einen Vortrag ohne Powerpoint, sondern nutzt einen eigenen CodeProject-Artikel als Präsentaton und zeigt die Beispiele per LiveCoding direkt im VS2010.

Auch wenn ich mit WPF und Silverlight noch nicht wirklich viel anfangen kann, ist der Vortrag von Rainer – auch für mich – absolut nachvollziehbar und anschaulich. Respekt :-)

DotNetKicks-DE Image

BASTA! Tag 4: Intensions & Interfaces – Making Patterns Concrete

25.02.2010 01:22:01 | Jürgen Gutsch

Udi Dahan (udidahan.com) beginnt in dieser Session mit der Beschreibung wie Software immer komplexer und komplexer werden kann und das es das Ziel sein sollte Software flexibel zu machen und flexibel zu halten.

Oh man, es ist zu früh um einem englischsprachigen Sprecher, bei einem Thema über Design Patterns zu folgen und dabei mit zu schreiben… ;-) Daher an dieser Stelle erst mal keine weiteren Infos. Ich werde am Wochenende diese sehr, sehr interessante Session in eigene Worte fassen und an dieser Stelle posten. Ich bitte das zu Entschuldigen… :-(

DotNetKicks-DE Image

BASTA! 2010 Spring – Blend für Nichtdesigner

24.02.2010 19:00:00 | Stefan Lange

Zu meinem Vortrag „Blend für Nichtdesigner“ auf der BASTA! Spring finden sich hier die Materialien.

In diesem Vortrag ging es um den Nutzen von Blend für den Software Entwickler beispielsweise beim Erstellen von Data Templates oder beim Designen von Custom Controls. Da der überwiegende Teil des Vortrags mit Blend durchgeführt wurde sind die Slides eigentlich wenig hilfreich, der Vollständigkeit halber aber stehen sie hier zum Download bereit.

Materialien zu diesem Vortrag:

BASTA! Tag 3: Advanced Hacking

24.02.2010 13:04:00 | Jürgen Gutsch

In dieser sehr interessanten Session geht Michael Thumann (Enno Rey Netzwerke GmbH) auf die Problemantik von SQL Injection. Er startet mit einer Einführung in die SQL Injection für diejenigen die noch nie was damit zu tun haben. Laut Handzeichen leider überrachend viele :-(

Michael beschreibt wie man mit Hilfe von SQL Injection Betriebssystemfunktionen aufruft um das System zu manipulieren. Wichtig ist hier auf jeden Fall einen Benutzer für den Zugriff auf den SQL zu verwenden der nur die mindestberechtigungen hat. Der SQL Server darf nicht mit Administratorrechten starten.

Im zweiten Teil seiner Session beschreibt Michael wie man mit Hilfe von Treibern Hintertürchen im System öffnen kann. Über die Treiber deshalb, da man damit so nah am System ist um genügend Berechtigung im System zu haben. Dabei beschreibt er wie man an der Treibersignierung vom Microsoft vorbei kommen kann.

Im dritten und letzten Teil der Session möchte Michael die vorangegangenen Techniken gemeinsam anwenden. Also mit SQL Injection einen Treiber als Hintertürchen installieren.

DotNetKicks-DE Image

BASTA! Tag 3 Keynote: Why Software Sucks

24.02.2010 12:45:00 | Jürgen Gutsch

… and What You Can Do About It

Diese Keynote ist eine sehr unterhaltsamsten: David S Platt (http://www.rollthunder.com/) geht mit sehr viel Humor in diese Keynote. Jeder zweite Satz sorgt für Lacher im Publikum.

Der Usability Experte beginnt mit einer Darstellung der unbeliebtesten Branchen in der USA, mit dem Resultat: “Anwender hassen uns (Softwareentwickler) mehr als die Gebrauchtwagenhändler ;-)” Und stellt die Frage warum das so ist.

Ich stelle hier einfach mal ein paar Markante Aussagen von Platt wieder, da man diese Keynote eigentlich selber sehen muss.

Platt’s First, Last and Only Law of User Experience Design: Know Thy User For He Is Not Thee

“The user is not you” ist eine Aussage die Platt im Laufe der Keynote immer wiederholt und z. B: mit folgenden Zahlen belegt:

Nur 5% Entwickler sind weiblich; in der US Bevölkerung gibt es aber 52% Frauen die Software anwenden. Daraus ist zu schließen, dass 47% der männlichen Entwickler für Frauen entwickeln. Wie soll das gut gehen? “The user is not you”

Eine Interessante Frage, die vom Publikum erst nach einem Hinweis beantwortet werden konnte: “What is your customer buying?” Der Kunde kauft eine Idee, eine Vorstellung, einen “Traum” und bekommt vom Softwareentwickler lediglich etwas mit dem er sich den Hintern abwischen kann.

Alle User von Software wollen, laut Platt, das gleiche: “I just want it to work.” Platts Empfehlung an die Softwareentwicklung: “Make it just work!”. Es sind weniger Features zu implementieren die funktionieren, statt viele die der User nicht bedienen kann. Ein Feature das der User nicht bedienen kann ist ein Feature das nicht funktioniert. Wir ENtsickler sollten den User nicht zwingen irgendwelche Features auf irgend eine bestimmte Art zu benutzen um Seiteneffekte zu vermeiden. Wir sollten dem User Features anbieten die nur das tun was sie tun sollen und schon gar keine Seiteneffekte haben.

ALs schlechtes Beispiel nannte er die Menubar in einer älteren MS Word Version die sich versehentlich aus der Anwendung ziehen lassen kann, so das man eine floatende Menubar erhält. Das herausziehen der Menubar ist ein Feature, das man an dieser Stelle nicht benötigt und sogar eher hindernd ist.

Als gutes Beispiel nannte er Google, das es schafft das Herkunftsland des Anwenders zu bestimmen und die Sprache entsprechend zur Verfügung stellt. Demgegenüber nannte er UPS.com als schlechtes Beispiel, wo man als User – egal in welchem Land man sich befindet – erst mal sein Land in einer Dropdown Box suchen muss, im Extremfall mehrere Klicks benötigt um in der riesen Liste sein Land zu finden. Gibt man statt dessen seine UPS-Paketverfolgungsnummer bei Google ein, erhält man auf Anhieb die Gewünschte UPS Seite in seiner Sprache…

Ein weiteres böses Beispiel war die Auswahl auf einem Installer einer Backup-Software: Man konnte auswählen, ob man die Installation “normal” oder “einfach” haben will…

Der Besuch dieser Keynote hat sich auf alle Fälle gelohnt :-)

DotNetKicks-DE Image

BASTA! Tag 3: Speed Freak C# and .NET!

24.02.2010 09:50:00 | Jürgen Gutsch

Christian Gross legte eine wirklich beeindruckende Session hin. Als erste zeigte er eine Bloomberg Anwendung die Real Time Daten live visualisierte. Desweiteren Empfahl er vor jeder weiteren Demo erst einmal dotTrace von JetBrains als Profiler um Performanceproblemen auf den Grund zu kommen. Gut das waren die ersten fünf Minuten der Session :-)

Ab jetzt zeigte er eine Reihe von beeindruckenden Demos. Angefangen mit dem Hinweis, dass Properties mit Gettern und Settern um einiges langsamer sind als öffentliche Felder.

In einer weiteren Demo mit mehreren tausend Schleifendurchläufen zeigte er dass die Verwendung von Klassen als Datenobjekte um einiges langsamer sind als Structs. Schneller als Structs allerdings sind mehrdimensionale Arrays. Aus Gründen der Lesbarkeit empfiehlt Cristian allerdings Structs zu verwenden.

Weiter ging es mit dem Umwandeln von Objekten von einem Typ in den anderen. Das Ergebnis: Casts kosten, eine Prüfung vor einem Cast kostet noch mehr. Zu casten und dabei Fehler mit einem Try-Catch-Block abzufangen kostet um einiges mehr. Die Lösung: “Know your types!!!”, also Casts vermeiden und typisiert arbeiten (Generics verwenden).

Auch interessant war, dass Vererbung und Implementierung von Interfaces einen Massiven Einfluss auf die Performance hat. Methoden die Vererbt, überschrieben oder über ein Interface implementiert wurden waren um ca. das 200fache langsamer als Aufrufe von Methoden aus einfachen Klassen oder Structs.

Und am Schluss kam das aller beste: C# ist schneller als C++! Christian zeigte die gleiche Demo in C++ und C#, dabei war die C# Demo doppelt so schnell wie die C++ Demo. Und es ging noch besser. Mich Codegenerierung per ExpressionTrees halbierte er die Zeiten noch einmal um die hälfte.

Bisher war das auf der BASTA! die beeindruckteste Session :-)

DotNetKicks-DE Image

BASTA! Tag 3: Windows Identity Foundation

24.02.2010 07:46:03 | Jürgen Gutsch

Erster Hinweis von Dominick Baier (thinktecture) zu Windows Identity Foundation ist, dass WIF als Windows Update kommt und ein Teil von Windows sein wird. Also im Prinzip das neue Windows Security System, ohne ein Teil von .NET zu sein.

Über die Beschreibung der klassischen Identifizierungsmöglichkeiten von .NET 1.0 bis hin zu .NET 3.0 leitet Dominick über zu WIF.

Neu an der Art wie WIF arbeitet ist: Sogenannte Claims beschreiben Sicherheitfeatures. Beispiel Rollen, Gruppen, Berechtigungen sind Claims. Claim ist im Prinzip die Basisklasse aller Sicherheitsobjekte. Mit WIF lassen sich auf diese Art beliebige Security-Systeme abbilden, bzw. nachbilden. Um dieses Konzept wurde mit WIF ein neues Framework gebaut.

WIF liefert einen neue Assembly “Microsoft.IdentityModel”. WIF liefert auch zwei neue Inderfaces IClaimsIdentity und IClaimsPrincipal. Wenn man genau nachschaut, sieht man das diese beiden Interfaces von IIdentity und IPrincipal erben, was den Vorteil hat, dass WIF abwärtskompatibel ist. WIF erweitert diese beiden klassischen Interfaces mit Eigenschaften, die die vorhandenen Interfaces um einiges flexibler machen.

WIF wird dadurch sehr flexibel um Identities, bzw. genauer: ClaimsIdentities zu beschreiben. Desweiteren liefert WIF diverse Handler (TokenHandler) um Identities von Systemen wie AD, aus dem HttpContext, etc, in ClaimsIdentities zu konvertieren. Der TokenHandler ließt die Eigenschaften aus, erstellt entsprechende Claims und erstellt mit diesen eine ClaimsIdentity. Aus dieser ClaimsIdentity wird ein ClaimsPrinciple erzeugt der dann in der Anwendung genutzt werden kann.

In ASP.NET wird WIF über HttpModule aktiviert und gesteuert. Innerhalb von ASP.NET wird dann ebenfalls mit ClaimsIdentities und ClaimsPrinciples gearbeitet. Alte Anwendungen müssen für WIF nicht umgeschrieben werden, außer die Registrierung der Module in der Web.Config, da die Identities und Principles ja abwärtskompatibel sind.

Die Möglichkeiten von WIF sind so flexibel und umfangreich und ist auf jeden Fall einen separaten Blogbeitrag wert, nachdem ich mal etwas damit herumgespielt habe.

Und was ist mit Single Sign-On? SSO hat im Prinzip nichts mit WIF zu tun, sondern um SSO zu unterstützen muss einfach ein anderer TokenHandler genutzt werden. Für SSO wird z. B: ein SAML-Token genutzt, der von einem Identity Provider (wie z. B: Windows Live Login) geliefert wird. Der Token Handler erzeigt anhand des Tokens dann wie oben beschrieben ein ClaimsIdentity Objekt. Es kann jeder beliebige Security Token Service als Identity Provider genutzt werden, wichtig ist nur das ein TokenHandler existiert, der das Token verarbeiten kann.

DotNetKicks-DE Image

BASTA! Tag 3 Keynote: – Windows Phone – Die Zukunft hat begonnen

24.02.2010 06:25:03 | Jürgen Gutsch

Ganz spontan wurde aus aktuellem Anlass für 14:00 Uhr eine Keynote zu Wondows Phone angekündigt. Frank Prengel von Microsoft, erzählt uns Neues von Windows Mobile, bzw. Windows Phone. Als erstes erzählt Frank von Neuerungen innerhalb des Windows Mobile Maketplace, und stellt des weiteren die Gewinner des Entwickler-Wettbewerbes “Marketplace – Fertig – Los” vor.

Es gibt weiterhin Verbesserungen für Windows Mobile 6.5.3 damit es auch für moderne Gräte bedienbar bleibt.

Auf zum Thema Windows Phone: Frank lässt nun das bekannt Video zu den Windows Phone 7 Series abspielen, das der eine oder andere ganz sicher schon im Netz gesehen hat. Tolle Bilder auf jeden Fall. Hoffen wir, dass Microsoft in dem Video nicht zu viel verspricht…

Windows Mobile ist scheinbar komplett neu entwickelt worden. Windows Phone ist eine Kombination aus Zune und Windows Mobile, um die Einfache Bedienung von Zune auch im Windows Mobile nutzen zu können. Windows Phone soll unter anderem alle Microsoft Onlinedienste auf ein Gerät zusammenbringen.

Mehr Infos dazu unter www.windowsphone7series.com

Wie werden Anwendungen für Windows Phone entwickelt? Frank wollte nicht konkrete Beispiele nennen, sonder verwies auf die kommende MIX10. Er nannte lediglich das Stichwort “Expression Blend”. Es scheint also darauf hinaus zu laufen, dass Anwendungen in Zukunft mit WPF entwickelt werden können.

DotNetKicks-DE Image

BASTA! Tag 3: Parallel Computing: von LINQ nach PLINQ

24.02.2010 04:57:04 | Jürgen Gutsch

Marc André Zhou (Logica Deutschland GmbH Co. KG) fängt in dieser Session an mit einer schneller Einführung in die Parallelität. Fast eine Wiederholung der vorigen Session.

PLINQ eignet sich nicht für LINQ to SQL, bzw. nicht für LINQ Provider die Abfragen auf eine externe Datenquelle vornehmen, eignet sich also nur für In-Memory-Daten, bzw. bereits geladene Daten. Das reine LINQ eignet sich dagegen optimal für die Parallelisierung. PLINQ prüft selber, ob es nötig ist eine Abfrage parallel auszuführen oder nicht. Dafür ist ein Query Analysis zuständig. Andersherum ist es unter Umständen auch möglich, PLINQ generell zu zwingen Queries parallel auszuführen.

Interessant wird PLINQ allerdings nur bei LINQ-Abfragen, die mehr tun, bzw. rechenintensiv sind. Es macht keinen Sinn einfache LINQ-Abfragen zu parallelisieren, die Performance wird dann eher abnehmen, da PLINQ selber einiges an Overhead mitbringt. Was man bei PLINQ beachten sollte ist dass, außer bei Queries auf Arrays, die vorhergehende Sortierung verloren geht. Das hängt damit zusammen, das die Verarbeitung des Queries, bzw. die Datensätze auf verschiedene Prozessorkerne verteilt wird und die Datensätze nach der Verarbeitung anders zusammengesetzt werden können. Bei Arrays mit fixen Index-Werten ist das nicht der Fall, da die Datensätze wieder an den ursprünglichen Index zurückgespielt werden können.

Interessant ist der asynchrone Abruf der verarbeiteten Daten. PLINQ kann abfragen (Poll), wo bereits Daten verarbeitet worden sind, diese Einsammeln und weitergeben, obwohl der Query noch nicht komplett verarbeitet worden ist.

DotNetKicks-DE Image

BASTA! Tag 3: Parallele Applikationen mit .NET 4.0

24.02.2010 03:38:00 | Jürgen Gutsch

Manfred Stayer (CAMPUS 02) führt uns in dieser Session in die Entwicklung von parallelen Anwendungen ein. Los geht es mit der Frage: Warum muss man Parallelisieren?

Da die Taktfrequenz von Prozessoren sich in Zukunft nicht unendlich erhöhen können, werden daher weitere Prozessorkerne benutzt. Die höhere Rechenleistung wird durch mehrere Prozessorkerne erzeugt. Man geht davon aus, dass sich die Rechenleistung alle zwei Jahre verdoppelt, in Zukunft eben durch parallelisierung.

Task Parallel Library (TPL) in .NET 4.0 ist eine Library die Entwicklern helfen soll Algorithmen auf verschiedene Tasks aufzuteilen, die parallel auf verschiedenen Prozessorkernen ausgeführt werden können. TPL delegiert die Tasks an die Prozessorkerne weiter. Dadurch wird die Auslastung vorhandener Ressourcen (in dem Fall des Prozessors) sichergestellt.

Als Beispiel für den Einsatz der TPL zeigt Manfred eine Rekursion, in der er jeden Rekursiven Aufruf in einem TPL-Task ablegt und so auf die verschiedenen Prozessorkerne verteilt. Dadurch wird die Rekursion deutlich performanter. TPL bietet zudem eine sehr einfache Möglichkeit Schleifendurchläufe zu parallelisieren. Desweiteren ist es möglich Task-Ketten zu bilden, in dem angegeben wird was beim Beenden des Tasks ausgeführt werden soll. Man könnte einfach einen weiteren Task starten. TPL liefert ebenso Möglichkeiten Taksks mit Rückgabewerten zu behandeln, parallele Tasks abzubrechen und auf Exceptions innerhalb von parallelen Tasks zu reagieren.

DotNetKicks-DE Image

Nachdenken über Clean Code

24.02.2010 00:45:02 | Jürgen Gutsch

Ich weis nicht ob es nur mir so geht oder auch anderen, aber wenn ich eine angeregte Unterhaltung zu einem bestimmten Thema habe, spinne ich anschließend bestimmte Ideen aus der Unterhaltung weiter. So auch diesmal, nach einer Unterhaltung zum Thema Accessibillity. Wenn man das Thema Accessibillity noch weiter ausweitet, nicht nur auf das Ergebnis der Softwareentwicklung, dem fertigen Programm, sondern auch auf die Softwareentwicklung selber anwendet, so ergibt sich ebenfalls Clean Code. Schließich gibt es nicht nur Anwender mit Defiziten, sondern auch Entwickler die auf die eine oder andere Art eingeschränkt sind: Clean Code ist Barrierefrei, in mehrerer Hinsicht:

  • Der Code ist für jeden lesbar, auch für diejenigen die es ggf. etwas schwerer haben Dinge auf Anhieb zu erfassen.
  • Der Übersicht im Code wird einfacher, Man wird nicht abgelenkt durch Codes die an dieser Stelle nichts verloren haben.
  • Dadurch das weniger gescrollt werden muss, kann ich mir sehr gut vorstellen, das Entwickler die in Ihrer Motorik eingeschränkt sind, ebenfalls einfacher und schneller arbeiten können.
  • Dadurch das sich weniger Code in einer Datei befindet, kann ich mir ebenfalls sehr gut vorstellen, das sehbehinderte Menschen es einfacher haben die komplette Code-Datei zu erfassen.

Man könnte das noch weiter spinnen. Ich denke, das man aus allen CCD Prinzipien mindestens auch einen Vorteil aus Sicht der Accessibillity ziehen kann.

Es sind nicht nur Endanwender und potentielle Kunden, für die Barrierefrei entwickelt werden muss, es sind unter anderem auch die entwickelnden Kollegen selber, die ohne Barrieren arbeiten wollen.

Ist das etwas weit hergeholt? Ich denke nicht…

DotNetKicks-DE Image

Ihr Beitrag in /Partner – Partner informieren Partner!

23.02.2010 17:11:46 | Peter Kirchner

Wir haben im Partner-Team der D&PE Deutschland die Plattform namens /Partner geschaffen, damit Partner, die erfolgreich unsere Technologien einsetzen, anderen Partnern interessante Software-Lösungen, Best Practies oder Verfahren kurz und prägnant vorstellen können.

/Partner beinhaltet technische Themen, die allerdings aus einer strategischen Sicht beleuchtet werden.

header_partner

Wenn Sie auch daran interessiert sind, mit uns zusammen einen Beitrag über eine beeindruckende Lösung, die Sie erstellt haben, zu veröffentlichen, schreiben Sie mich an! (Für uns sind Partner alle Softwarehersteller, die unsere Technologien und Produkte einsetzen; sie müssen für eine Veröffentlichung kein Mitglied im Microsoft Partner Network sein.)

Wenn Sie sich erst einmal darüber informieren möchten, wer schon alles in /Partner veröffentlicht wurde, schauen Sie einfach rein! Hier eine kleine Auswahl:

Case Study: Durchgängige Automatisierung im Service Request bei Siemens IT Solutions and Services (SIS)

Ein reibungslos ablaufendes Request-Management ist entscheidend für den Erfolg eines IT-Service-Anbieters SIS und econet haben auf Basis von econet cMatrix eine Lösung erstellt, die Service-Requests für IT-Dienste wie E-Mail, Dateiablagen, User-Account-Management weiterlesen...

Case Study: pmportal

Der Erfolg von Projekten hängt stark davon ab, wie effektiv Informationen verwaltet und verteilt werden können. Besonders komplexe Projekte können dabei von einem umfassenden Projektmanagement-Portal profitieren, das bei der Planung und Durchführung sowie weiterlesen...

Case Study: Fotobuch

Mit dem ansprechenden WPF-Client und einem intelligenten Wizard konnte Foto Quelle die Umsätze im Fotobuch-Bereich gegen den allgemeinen Trend um 27 % steigern. (Stefan Hagemann, Geschäftsführer der Foto Quelle) Eine Anwendung muss darauf Rücksicht nehmen, weiterlesen...

Case Study: Blended Library

Das Forschungsprojekt „Blendend Library“ dient der Entwicklung natürlicher Benutzerschnittstellen der nächsten Generation für die Bibliothek der Zukunft. In diesem Szenario spielen neuartige interaktive Ein- und Ausgabegeräte eine entscheidende Rolle. weiterlesen...

Case Study: Benutzungsfreundliches GUI Design mit .NET WPF

Eine hochmoderne Hardware mit einem wenig attraktiven User Interface. Beim intelligenten Apotheken-Lagersystem Vmax von Rowa passten GUI und Hardware nicht gut zusammen. Eine Neuimplementierung der GUI sollte dieses Problem beheben. Die Fragen: Wie harmonieren weiterlesen...

BASTA! Tag 2: Advanced Debugging mit Visual Studio 2008 und 2010

23.02.2010 13:54:00 | Jürgen Gutsch

In dieser Session zeigt Ingo Rammer (thinktechture) mit dem Visual Studio 2008 und auch dem Visual Studio 2010 zusätzliche Möglichkeiten und neue Features beim Debuggen. Ingo Rammer springt hier recht schnell von einem Debugging-Feature zum anderen. Hier eine Auswahl:

Visual Studion 2008:

Breakpoints:

Breakpoint-Gruppen: mehrere Breakpoints die Gruppiert dargestellt sind, z. B. lassen sich Breakpoints auf beliebige Funktionen eines Bestimmten namens machen. Alle erzeugten Breakpoints werden gruppiert dargestellt.

Versteckte Funktionen beim Rechtsklick auf einen Breakpoint:

  • “Condition…”: Bedingung für einen Hit festlegen.
  • “Hit Count…”: Break nach einer bestimmten Anzahl von Hits.
  • “When Hit…” Möglichkeit beim Hit eine Aktion aus zu führen.

Einen Break im C# Code ausführen, mit:

if(System.Diagnostics.Debugger.IsAttached)
{
  Debugger.Break();
}

Debug-Ausgabe:

  • Attribut DebuggerDisplay um die Ausgabe in den Debug-Ausgaben zu ändern.
  • Attribut DebuggerBrowsable um Eigenschaften in den Debug-Ausgaben explizit aus oder ein zu blenden.
  • Attribut DebuggerTypeProxy um Attribute für die Debug-Ausgabe hinzuzufügen.
  • Attribut DebuggerVisualiser um z. B: Debug-Ausgaben woanders auszugeben.

Threading:

Beim Debuggen vom Multithreading-Anwendung gibt es diverse Möglichkeiten zur Steuerung der Aktuellen Threads, z. B: Einfrieren bestimmter Threads um nur den fehlerhaften Thread auszuführen.

Exception Handling

Wie geht man richtig mit einer Exception um? Antwort: ACT

  • Avoid:
    Fehler vermeiden
  • Catch (only if handled):
    Nur abfangen, wenn die Fehler auch behandelt werden. Logging ist keine Fehlerbehandlung
  • Throw essential Exceptions:

 

Neu in Visual Studio 2010

IntelliTrace (“Historical Debugging”) kann zu einem bestimmten Zustand des Debggers zurückspringen um “Daten aus der Vergangenheit” zu Debuggen. Siehe auch: http://msdn.microsoft.com/en-us/library/dd264915(VS.100).aspx

Pin to Source: Stellt bestimmte Variableninhalte innerhalb des Source Editor dar. Siehe: http://thedatafarm.com/blog/dotnet/vs2010-beta-2-pin-to-source-for-debugging-ndash-cool-but-with-a-caveat/

Crash Dump Debugging: Mit VS2010 ist es möglich einen Memory Dump zu debuggen. Voraussetzung ist allerdings eine .NET 4.0 Anwendung. Siehe auch: http://channel9.msdn.com/posts/Glucose/Hanselminutes-on-9-Debugging-Crash-Dumps-with-Tess-Ferrandez-and-VS2010/

DotNetKicks-DE Image

Wie zufrieden sind Entwickler mit Microsoft?

23.02.2010 13:02:39 | Kay Giza

Ich möchte gerne hier das Editorial des 'MSDN Flash 04/2010: Visual Studio 2010 RC +++ IE8 +++ SharePoint 2010' zitieren. Der Newsletter wurde gestern, am Montag wie immer alle zwei Wochen versendet. Dort behandelte ich im Editorial einige Themen und bekam dazu sehr positive Rückmeldungen. Daher dachte ich mir, vielleicht ist es hier für die Leser auf Giza-Blog.de auch interessant und die eine oder der andere hat dazu auch noch Feedback. Würde mich sehr freuen. Zitat aus dem Newsletter: Herzlich Willkommen zum MSDN Flash 04/2010! Wie zufrieden sind Anwender, Partner und Entwickler mit Microsoft? Dies beschäftigt uns alle hier bei MSDN jeden Tag. Dabei nutzen wir nicht nur das Internet (wie z.B. Foren, Social Media-Webseiten oder MSDN Online), E-Mails und Events, um Themen mit Ihnen zu diskutieren, sondern wir... [... mehr in diesem Blogeintrag auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

dotnet Cologne 2010 am 28. Mai 2010 in Köln

23.02.2010 12:47:16 | Albert Weinert

Die Community-Entwickler-Konferenz dotnet Cologne 2010 wird am 28. Mai 2010 im Holiday Inn am Stadtwald stattfinden.

Dieses Jahr steht Sie im Zeichen von Visual Studio 2010 und .NET 4.0, wobei sich auch Themen Abseits davon finden werden. 18 Sessions sind für den Tag geplant. Also schnell den Fortbildungsurlaub beim Arbeitgeber beantragen und sich im Bedarfsfall ein Hotelzimmer sichern.

Eine Anmeldung ist ab dem 3. März 2010 um 10:20 Uhr möglich, somit habe alle die gleichen Chancen eines der 150 begehrten Super Early Bird Tickes zu bekommen. Denn der Super Early Bird beträgt nur 25 €, wer sich zu spät anmeldet läuft in gefahr 40 € bzw. 55 € zu bezahlen.

Am Abend veranstaltet dass dotnet-forum.de ihre Community Grill-Fete. An dieser können die Konferenz Teilnehmer und Mitglieder des dotnet-forum.de (auch ohne Konferenz) teilnehmen. Bei schönem Wetter draußen am See!

Des Weiteren suchen wir noch Sprecher, wer also möchte kann sich mit Vorschlägen an uns wenden. Neben Ruhm & Ehre gibt es für Sprecher auch freien Eintritt. Details dazu finden sich auf der Call for Papers Seite.

Also, verbreitet die Kunde der dotnet Cologne 2010, in Blogs, bei den Chefs, bei den Kollegen, bei Freunden, in den User Groups und beim ganzen Rest. Macht es schnell und gründlich damit die Chancen auf die Super Early Birds gegeben sind.

Wir suchen auch noch Sponsoren damit wir die Konferenz auch zu diesen günstigen Preisen anbieten können, wer Interesse hat seine Produkte oder Firma vorzustellen der Wende sich bitte an uns dann gibt es genauere Informationen dazu.

BASTA! Tag 2: Building a Rich Web UI at the Speed of jQuery UI

23.02.2010 11:08:00 | Jürgen Gutsch

Im ersten Teil dieser Session führt Dino Esposito (Managed Design) uns in die jQuery UI ein, beschreibt den Umfang von jQuery und jQuery UI und warum jQuery so populär geworden ist und was nötig ist um jQuery zu nutzen, sowie die Vorteile der Verwendung von jQuery UI. Anhand des DatePickers beschreibt Dino in einer Demo die Funktionsweise und die Möglichkeiten von jQuery UI.

Im zweiten Teil zeigt Dino in vielen Demos die Verwendung der Tabs, des Accordions und den Dialogs. Die Erstellung der Tabs erfordert etwas mehr Aufwand als der DatePicker, da die Infrastruktur für die Tabs im Dom erst aufgebaut werden muss (siehe auch hier: http://docs.jquery.com/UI/Tabs). Natürlich ist der Aufwand auch nur minimal und nicht zu vergleichen mit der manuellen Implantation von Tabs oder die Nutzung von ServerControlls diverser Drittanbieter. Eine sehr interessante Demo ist die Erzeugung der Tabs anhand von Infos die per Webservice geholt werden, wobei der Aufruf des Webservice vom ASP.NET AJAX übernommen wird, der die Daten an jQuery UI weitergibt. Anhand des Accordion zeigt Dino die Möglichkeit Clientseitiges Caching mit jQuery umzusetzen um z. B: vom Server geladene Daten auf dem Client zwischen zu speichern.

Auch in diese Session war allein schon die Tatsache Dino live und in Farbe zu erleben, ein Vergnügen. Die Session hat sich auf alle Fälle gelohnt  :-)

DotNetKicks-DE Image

Webcast zur MS Office 2010 Entwicklung mit VSTO 4.0 erschienen

23.02.2010 10:28:00 | Lars Keller

Jens Häupel (Microsoft Evangelist u.a. für MS Office 2010 Entwicklung) hat einen Webcast veröffentlicht, der die Neuerungen zu VSTO 4.0 erklärt. Der Webcast zeigt die neuen Features, wie z.B. Backstage Programmierung. Besonders interessant ist auch, wie die neuen Sprachfeatures von C# 4.0 die MS Office Entwicklung erheblich vereinfachen.

Schöner Webcast – sehenswert! :-)

Link:

02.03.10 Treffen der .NET Developer Group Braunschweig – BizTalk Server 2009 – Ein Überblick für Entwickler

23.02.2010 10:08:00 | Lars Keller

Das 43 User Group Treffen der .NET Developer Group Braunschweig findet am 02.03.10, um 20:30 Uhr in dem Restaurant Zucker (ehemals Kilian’s Raffinerie) statt.

Achtung! Beachtet bitte die späte Uhrzeit von 20:30!

Dieses Mal kommt uns Robert Meyer mit einem Vortrag zum Thema “BizTalk Server 2009 – Ein Überblick für Entwickler”.

Sicher standen Sie schon einmal vor dem Problem, das Geschäftsprozesse welche über  unterschiedliche Anwendungen laufen und zu verschiedenen Zeitpunkten ausgeführt werden, untereinander kommunizieren müssen. Im schlimmsten Fall sind diese Anwendungen auch noch in verschiedenen Technologien umgesetzt worden. Genau dann könnte BizTalk Server 2009 von Microsoft ein guter Lösungsansatz sein. Ich möchte Ihnen an diesem Abend das Grundprinzip des BizTalk Servers 2009 und die wichtigsten Elemente für die Entwicklung einer BizTalk Anwendung vermitteln.

Sprecher an diesem Abend wird Robert Meyer, Development Trainer bei der ppedv AG und freiberuflicher .NET Entwickler, sein. Seine Schwerpunkte liegen auf dem Gebieten .NET Entwicklung, ADO.NET Entity Framework, SQL Server und BizTalk Server.

Weitere Informationen unter www.dotnet-braunschweig.de.

Wie immer ist jeder herzlich willkommen!

BASTA! Tag 2: Using Mocks for Sate and Interaction based Testing

23.02.2010 09:33:00 | Jürgen Gutsch

Hadi Hariri (JetBrains) legt los :-) Cool, mit welchem Schwung und Elan Hadi in die Session geht.

Hadi beginnt mit der Beschreibung dazu, wann ein Unit Test ein Unit Test ist und wann nicht, beschreibt die Definition von Unit Test. Es geht darum die Architektur seiner Anwendung testbar zu gestallten und testbar zu halten. Anhand vieler anschaulicher Code Demos zeigt Hadi was in der Regel falsch gemacht wird. Selbstverständlich kommt hier natürlich der ReSharper, vor allem der Unit Test Runner von ReSharper zum Einsatz ;-) Hadi beschreibt die Problematik der Unit Tests und fragt nach einer Lösung. Die Lösung ist natürlich wie erwartet: Dependency Injection. (Ob er LightCore schon kennt? *g* )

Interessant: Was ist der Vorteil von Constructor Injection im Gegensatz zu Property Injection?
Ganz einfach: Die Klasse kann nicht instanziiert werden, ohne das benötigte Instanzen injiziert werden. Die Klasse ist somit weniger fehleranfällig. So einfach das klingt und so lange ich Dependency Injection auch schon selber nutze, aber so einfach ist es mir selber gar nicht in den Sinn gekommen. Komisch eigentlich…

Langsam aber sicher kommt Hadi zu Mocking Frameworks. Hand made Mocks sind kommen in den Demos zum Einsatz. Was wird er Empfehlen? moq, Rhino Mocks? Ja, über Castle Dynamic Proxy und einer eigenen Mocking Framework implementation kommt er zu Demos zu moq und Rhino Mocks.

Wie Hadi dein Einsatz von Rhino Mocks beschreibt ist absolut anschaulich und für jeden nachvollziehbar, sowie mit genug Witz um die Session nicht langweilig werden zu lassen.

Auch interessant: Die unterscheide zwischen moq und Rhino Mocks (moq hatte ich bisher nie verwendet). moq unterscheidet z. B. nicht zwischen Mock und Stub. Rhino dagegen gibt ein Objekt zurück welches das angegebene Interface implementiert, das direkt verwendet werden kann. Nicht so moq: moq gibt ein Mocking Objekt zurück, welches das Stub in der Eigenschaft Object bereit hält:

Rhino:

IUserRepository userRepo = MockRepository.GenerateStub<IUserRepository>();
IUserService userServ = new UserService(userRepo);

moq:

var userRepo = new Mock<IUserRepository>();
IUserService userServ = new UserService(userRepo.Object);

Der Unterschied zwischen einem Mock und einem Stub war mir ehrlich gesagt auch nicht wirklich klar: Mit Stubs lassen sich Funktionen und deren Rückgaben testen, mit Mocks dagegen lassen sich auch Interaktionen zwischen zwei Klassen in einer Funktionalität testen, beispielsweise in dem erwartete Aufrufe auf eine zweite Klasse innerhalb der Funktionalität abgefragt werden. Oder anders: Stubs nutzt man um Funktionalität zu ersetzen und Mocks um Interaktion zu testen.

Okay, nicht so viel neue für mich, allerdings war es sehr interessant Hadi Hariri zu erleben.

DotNetKicks-DE Image

BASTA! Tag 2: Agiles Planning Poker: Aufwandsabschätzung in agilen Projekten

23.02.2010 08:00:00 | Jürgen Gutsch

Theorie:

Manfred Stayer erklärte zunächst die unterschiedlichen Methoden der Aufwandsabschätzung per Zerlegung der Aufwände, einholen von Expertenmeinungen und Vergleichen mit vorherigen Aufwänden.

Eine vierte Variante aus den Agilen Prozessen ist das “Planning Poker”. Für die Abschätzung werden sog. Story Points verwendet die in etwa den Aufwänden in Stunden entsprechen. üblicherweise werden in etwa folgende Bewertungsreihen verwendet:

1, 2, 3, 5, 8, 13, Big
1, 2, 4, 8, 16, Big

Für die Bewertung des Sprints werden werden die Story Points zusammengerechnet. Das Resultat wird dann als Velocity des Teams bezeichnet, also die Anzahl der Story Points die pro Iteration geschafft werden.

Praktischer Teil:

Sehr interessant war die Übung zum Thema, in der nach dem “Schere / Stein / Papier”-Prinzip Aufwände für vorgegebene Anforderungen geschätzt werden sollten. Für die Planung wurden uns 10 Minuten zur Verfügung gestellt und für die Ausführungen drei Minuten. Die Schätzung sollten per Handzeichen bekannt gegeben werden. Die Aufgaben sahen wie folgt aus:

Iteration 1
a) Einstöckiges Kartenhaus
b) Luftballon aufblasen (20 cm)
c) Eine Karte aus gemischten Stapel finden 
d) Hut Falten 
e) 2x eine 6 würfeln

Iteration 2
a) zwei zweistöckige Kartenhäuser 
b) Drei Karten aus gemischten Stapel finden
c) Zwei Luftballons aufblasen (30 cm) und aneinander binden
d) 6x eine 6 Würfeln

Nicht erfüllte Anforderungen sollten in die 3. Iteration übernommen werden

Interessant was, dass keines der Teams gleich abschätzte und jedes Team bei dieser Übung andere Erfahrungen gemacht hat. Jedes Team konnte am Ende eine andere Velocity vorweisen.

PlaningPoker.com

Passend gibt es ein Spiel zum Planing Poker auf http://www.planningpoker.com/

DotNetKicks-DE Image

Silverlight: Produkt-Informationen vs. technische Informationen

23.02.2010 07:17:48 | Kay Giza

Wer sich für Silverlight interessiert, hat ein Problem? Genau wie bei jedem anderen Produkt kommt es darauf an, wer man ist. Wenn man dies weiß bzw. sich einordnen kann, dann weiß man (meistens) auch, wo man sich informieren sollte. So ist es bei jedem Produkt. Na gut, fast bei jedem Produkt. Aber jedes Produkt welches ein großes Volumen an zu vermittelnden Informationen aufweist, ergeht es so. Beispiel anhand von Silverlight: Ein Entwickler möchte gerne Code Snippets, technische Artikel, SDK, Tipps und Tricks sowie News & Informationen vorfinden. Schlichtweg Hilfestellungen rund um die Softwareentwicklung mit und um Silverlight. Ein Entscheider und Anwender (also der Otto-Normalverbraucher) benötigt andere Informationen. Wie soll ich es formulieren, er brauch die Wikipedia-Informations-Packung. Ein Entscheider der für sein Unternehmen eine Entscheidung für ein Produkt herbeiführen möchte oder sich schlichtweg informieren möchte, benötigt Fakten, Marketing-Materialien etc. und keinen Code. Ebenso gleichgelagert gilt dies für den Endanwender. Wie handhabt es Microsoft? Ich glaube wer sich für Silverlight interessiert... [... mehr in diesem Blogeintrag auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

BASTA! Tag 2: Agile Projekte mit Scrum – Grundlagen und Praxis

23.02.2010 04:07:00 | Jürgen Gutsch

Gerhard Fließ stellt Scrum als einen der meist genutzten Agilen Projektmanagementprozess mit den einfachsten Regeln vor, das in einem einzigen Schaubild dargestellt werden kann:

Wie Ihr wahrscheinlich feststellt, habe ich gestern und heute hauptsächlich Sessions besucht, (bzw. werde besuchen) die Agiles Projektmanagement betreffen. Ich werde hier nicht unbedingt konkret auf die Themen eingehen, sondern nur wirklich herausstechendes posten. Da die Themen teilweise zu komplex sind um sie hier komplett niederzuschreiben. Einen konkreten Beitrag über meine Sicht auf agiles Projektmanagement werde ich wahrscheinlich in den nächsten Wochen hier veröffentlichen.

DotNetKicks-DE Image

BASTA! Tag 2: Planung agiler Projekte mit TFS 2010

23.02.2010 03:24:00 | Jürgen Gutsch

Thomas Schissler (artiso AG) springt für den erkrankten Michael Willers (devcoach) ein und ersetzt das Thema “MSF agile – Agile Projekte in .NET-Projekten”

Nach einer ausführlichen Einführung in Scrum spielt Thomas ein Best Practices Beispiel anhand des TFS 2010 durch.

Für das Anforderungsmanagement gibt es die “User Story” als neuer Work Item-Typ in TFS 2010 damit lassen sich jetzt Product Backlogs im TFS abbilden. Hierarchische Work Items unterstützen die Visualisierung abhängiger Work Items, bzw. in diesem Fall die User Stories. Damit lässt sich die Projektplanung im TFS noch agiler planen als noch mit der letzten TFS Version. Neu ist auch, dass sich die Hierarchie der Work Items nun auch im Excel abbilden lassen, so haben auch Projektbeteiligte ohne Visual Studio Erfahrung die Möglichkeit die Planung einzusehen oder auch vorzunehmen.

Auch zur Überwachung der Projekte und auch der einzelnen Sprints liefert der TFS 2010 ausreichend Werkzeuge mit dem SharePoint Dash Board des TFS und den SQL Server Reporting Services.

Für die Kommunikation zwischen Entwickler und dem Product Owner empfiehlt Thomas das Work Item “Issue”, in der der Entwickler seine Probleme definiert einer User Story zuordnet. Der Product Owner ist hier in der Lage die Fragen zu beantworten. Die gesamte Kommunikation wird so auch im TFS dokumentiert.

DotNetKicks-DE Image

BASTA! Tag 2: Keynote

23.02.2010 02:00:00 | Jürgen Gutsch

Peter Monadjemi (von Activetraining) beginnt den Tag 2 mit einer Keynote zum Thema: “Cloud oder Desktop -  wohin geht die Reise?”. Peter erzählt über die Cloud Infrastruktur vom Microsoft und die angebotenen Services, die “Cloud Services”:

  • Exchange Online
  • SharePoint Online
  • Office Communication Online
  • Office Live Meeting

Interessant ist, dass es bereits Azure-Prototypen in Deutschland z. B. von T-Systems gibt: “Stromboxx” für die Stromabrechnung.

Weiter geht es mit kurzen Ausblicke auf Win7 (mit MultiTouch) sowie Visual Studio.

Neno Loje springt (wie er es immer macht) kurz ein, macht sich über den Namen “Azure” lustig (“Azure” bezeichnet einen wolkenlosen Himmel *fg*) und zählt die Neuerungen von TFS 2010 auf.
Interessant hierbei: Jede MSDN Visual Studio Version beinhaltet eine CAL für den TFS, was den TFS für mehr Firmen interessant machen sollte.

Weiter mit Peter Monadjemi geht es mit Verbesserungen beim WPF und dem WPF Editor, sowie in Silverlight. Hier springt Jürg Neumann für eine kurze Silverlight-Demo ein.

Auch in .NET 4.0 und für die parallele Programmierung – erzählt Peter - gibt es einige interessante Neuerungen, die auf jeden Fall einen genaueren Blick nötig machen.

Dr. Holger Schwichtenberg springt hier ein um über Neuerungen im ADO.NET Entity Framework 4.0 zu erzählen und präsentiert eine Demo zu Model-First-Datenbank Erstellung mit dem Entity Framework. Anschließend erzählt er über Neuerungen im ASP.NET 4.0.

DotNetKicks-DE Image

BASTA! Tag 1: Freie Werkzeuge für agile Teams

22.02.2010 08:28:00 | Jürgen Gutsch

Gerhard Fließ stellt freie Werkzeuge vor die (zwingend) für agile Teams und agile Projekte erforderlich sind.

1. Anforderungsverwaltung => Agilo (www.agile42.com)
Eine auf Trac basierende Webanwendung mit der Tasks in Userstories zusammengefasst werden können und Backlogs und Sprints zugeordnet werden können. Eine Gesamtübersicht zeigt dabei den aktuellen Stand des Projektes an.

2. Quellcodeverwaltung => SVN
Gerhard zeigte anhand von Subversion die Installation, Verwaltung und Nutzung von SVN
Als SVN-Client fürs Visual Studio wurde AnkSVN gezeigt. AnkhSV integriert sich voll in das Visual Studio und erinnert in der Handhabung stark an den TFS

3. Continous Integration => Hudson
Hudson ist ein schlanker auf Java basierender Buildserver, der durch viele Plug-Ins auf die eigenen Bedürfnisse angepasst werden kann.

4. UnitTests => NUnit
NUnit wurde aus Zeitgründen nur schnell angeschnitten, aber UnitTesting sollte eh allen klar sein.

Das war der erste Tag der BASTA! Morgen startet die Hauptkonferenz, die viele weitere interessante Sessions verspricht :-)

DotNetKicks-DE Image

BASTA! Tag 1: Erfolgreiche und flexible Projekte durch agile Muster

22.02.2010 05:12:00 | Jürgen Gutsch

Manfred Steyer (Campus 02) führt mit Witzigen und anschaulichen Folien in die verschiedenen agilen Modelle (XP, Scrum, Christal) ein. Manfred beschreibt Techniken und Muster aus den verschiedenen Modellen sowie Probleme die beim klassischen Wasserfall entstehen und mit agilen Methoden behoben werden können. Aber auch die agilen Prozesse sind nicht perfekt, lösen aber dennoch die meisten Probleme die bei klassischen Prozessen zwangsweise entstehen. Je nach Projekttyp sollte ein anderer agiler Prozesstyp verwendet werden, der die Anforderungen besser lösen kann.

Abschließend zur Vormittagssession gab es einen kleinen Praxis-Workshop (“Agile Hour"), in denen in Sechser-Gruppen ein kleines Szenario durchgespielt wurde. Innerhalb einer Gruppe gab es die Kunden, welche die Anforderungen für ein Produkt definieren sollten und  die Entwickler, der das ganze umsetzen sollte. Da es bei Agilen Prozessen erlaubt ist, das der Kunde Änderungen während der Projektphase einbringt, sollte es auch hier durchgespielt werden. Insgesamt gab es sieben Projektschritte, die durchgespielt wurden:

  • Teil 1: Der Kunde erstellt in 5 Minuten ein Backlog und priorisiert die Anforderungen
  • Teil 2: Der Kunde erklärt dem Entwickler die Anforderungen und dieser schätzt den Aufwand
  • Teil 3: Die Entwickler beginnen mit der Umsetzung
  • Teil 4: Iteration Review: Die Entwickler präsentieren ihre Arbeit
  • Teil 5: Der Kunde ändert seine Anforderungen und die Entwickler schätzen diese Änderungen ab
  • Teil 6: Die Entwickler setzen die neuen Anforderungen um
  • Teil 7: Iteration Review: Die Entwickler präsentieren erneut ihre Arbeit.

In diesem gespielten Szenario wurde sichtbar, wieso es wichtig ist, dass der Kunde in das Projekt einbezogen wird. Und ggf. Anforderungen ändern bzw. neu definieren kann.

Mal sehen, ob der Nachmittag genauso agil weitergeht. Geplant ist Gerhard Fließ mit “Freie Werkzeuge für Agile Teams”.

DotNetKicks-DE Image

BASTA! Tag 1: Ankunft

22.02.2010 03:19:01 | Jürgen Gutsch

Die Parkplatz suche um Maritim Rhein Main Hotel gestaltete sich schwieriger, ich hab dann dennoch die Tiefgarage genommen. Trotz des Regens beeindruckt die Glasfront des Veranstaltungsortes. (Foto kommt später)

Nach dem Empfang bei der Registrierung erhält jeder Teilnehmer einen Rucksack voll mit Infomaterial, einem Heft mit der ausführlicher Agenda, sowie einem Bändel für die Eintrittskarte die dann auch als Namensschild dient. Die Agenda ist für mich ungemein wertvoll, da ich meine Agenda auf dem Schreibtisch liegengelassen habe.

Überall nette Damen die für Kaffe etc. zuständig sind. Die Räume haben Namen wie “Ulm” und “Titisee”, so fühlt man sich doch auch in Darmstadt irgendwie Zuhause ;-) Zumindest, wenn man aus dem südlichen Teil Deutschland kommt.

Im Moment warte ich noch auf den Start der ersten Session um 9:30 Uhr: “Erfolgreiche und flexible Projekte durch agile Muster” mit Manfred Stayer vom CAMPUS 02. Ich bin gespannt.

DotNetKicks-DE Image

VS 2010 Layer Diagram : Wie kann ich Namespaces auf Layer mappen?

19.02.2010 18:06:01 | Christian Binder

In dem neuen Layer Diagram kann man ja recht einfach Klassen und Projekte(also die Assemblys) vom Solution Explorer auf die Layer des Diagramms ziehen und somit, die für die Validierung notwendige Verknüpfung zwischen Code und Layer herstellen. In vielen Fällen kann es aber sinnvoller sein mit Namespaces zu arbeiten, also Namespaces auf Layer zu mappen und auf diese Weise die Validierung durchzuführen. Aber wie kann ich Namespaces verknüpfen? Am einfachsten mit dem Architecture Explorer. Im Class View bekommt man alle Namespaces angezeigt und kann diese auch noch Filtern, jetzt einfach selektieren und auf den entsprechenden Layer ziehen fertig.

LayerDiagram

 

Wenn man eine Grafische Übersicht der Namespaces sucht, um sich einen bessern Überblick existierender Abhängigkeiten zu verschaffen, kann man sich diese entweder über den Architecture Explorer erzeugen lassen oder über das Menu > Architecture.

image

Viel Spass
Chris

BlogEngine.NET und 404 Fehler

19.02.2010 16:34:53 | Klaus Bock

Im Originalzustand zeigt BlogEngine.NET beim Umgang mit 404 Fehlern ein etwas seltsames Verhalten, dass so auf den ersten Blick nicht ersichtlich ist aber unter Umständen unangenehme folgen haben kann.
Wird eine vom Benutzer angegebene Seite oder ein Artikel nicht gefunden, leitet BlogEngine.NET den Benutzer auf eine eigene 404 Fehlerseite um und bietet einige relevante oder ähnliche Seiten zur Auswahl an. Soweit ist daran nichts verwerfliches zu finden. Betrachtet man dabei aber den Netzwerkverkehr in einem Analysewerkzeug wie etwa Fiddler, wird das Verhalten sichtbar.

Wie in folgender Grafik zu sehen ist, wird beim Aufruf einer nicht verfügbaren Ressource mittels 302 auf die error404.aspx umgeleitet. Die error404.aspx wird jetzt wie jede andere Seite des Blog an den Client ausgeliefert, Auch mit dem selben Statuscode; 200 OK.

falscher Status bei einem 404 Fehler Wenn am anderen Ende als Client ein Benutzer mit einem Browser sitzt, ist dieses Verhalten nicht weiter schlimm. Was wenn der Client aber der Bot einer Suchmaschine ist? Der freut sich nicht über eine schön gestaltete Fehlerseite. Für ihn ist das die temporär verschobene, aber ursprünglich angeforderte, Ressource. Wenn jetzt der Suchmaschinenrobot einem Link von einer anderen Seite gefolgt ist, auf der die Adresse falsch geschrieben wurde, wird die Fehlerseite error404.aspx als der angegebene Link indiziert. Dieses Verhalten will bestimmt niemand haben.

Die Lösung des Problems ist denkbar einfach. Bei der Verarbeitung der Fehlerseite muss lediglich der Statuscode 404 an den Client zurückgegeben werden. Dies wird mit einer Zeile Code am Ende der Page_Load Ereignis der error404.aspx.cs erreicht:

Page.Title += Server.HtmlEncode(" - " + "Page not found");

// Fehlercode 404 zurückgeben
this.Response.StatusCode = 404;

Was verändert sich dadurch?
Die 302 Weiterleitung auf die Fehlerseite wird nach wie vor durchgeführt. Dann aber wird der richtige Statuscode 404 gesendet.

richtiger Status bei einem 404 FehlerFür den Benutzer mit dem Browser ändert sich dabei nicht. Der Suchmaschinen Bot aber weiß jetzt, die angegebene Ressource gibt es auf dem Server nicht. Also wird auch keine falsche Seite in den Index der Suchmaschine geschrieben.

Technorati-Tags: | |

ASP.NET Webforms Anwendungen und Ajax (Teil 4) Scriptservices, Page Methods und das ASP.NET AJAX Framework

18.02.2010 22:14:42 | Andre Kraemer

Nachdem ich in Teil 1 der Serie den manuellen Ansatz zur AJAX Implementierung gezeigt habe und in den Teilen 2 und 3 auf (halb-)automatische Alternativen einging, möchte ich dieses Mal einen anderen Weg zeigen, ASP.NET Scriptservices in Verbindung mit ASP.NET AJAX.

Rekapitulieren wir noch einmal:

Teil 1 der Serie zeigte einen manuellen Ansatz, der hauptsächlich damit kämpfte, dass man innerhalb des JavaScript Codes selbst darauf achten musste, die verschiedenen Besonderheiten der unterschiedlichen Browser zu berücksichtigen. Dies geschah in den Teilen 2 und 3 zwar automatisch hinter den Kulissen, dafür hatten wir bei diesen Alternativen jedoch das Problem, dass bei jedem AJAX Request sowohl der komplette ViewState übertragen wurde und vor allem auf dem Server auch der komplette Page Life Cycle durchlebt wurde.

Leichtgewichtig durch die Ajax Welt

Heute möchte ich deshalb einen Ansatz zeigen, der die Vorteile der bisher vorgestellten Ansätze vereint, jedoch nicht über die selben Nachteile verfügt.

Konkret bedeutet dies, dass die Implementierung auf Clientseite browserübergreifend stattfinden wird, zwischen Client und Server nur die wirklich notwendigen Daten übertragen werden und der Page Life Cycle auf der Serverseite nicht durchlaufen wird.

Page Methods

Der erste Schritt Richtung einer leichtgewichtigen Implementierung führt über die sogenannten Page Methods. Page Methods sind statische Methoden einer *.aspx Seite, die mit dem [WebMethod] Attribut annotiert werden. Für den Client erscheinen Page Methods wie normale Methoden eines Web Services.

Ausgehend vom Beispielcode der letzten drei Teile der Serie passe ich den Servercode für die Methode, die den Inhalt einer Datei zurückliefert also wie folgt an:

using System.IO;
using System.Web.UI;
using System.Web.Services;

public partial class Teil4 : Page
{
	[WebMethod]
    public static string ReadStaticFile()
    {

	     string fileContent;
         using (var reader =
             new StreamReader(
                 System.Web.HttpContext.Current.Server.MapPath("~/static.html")))
         {

             fileContent = reader.ReadToEnd();
         }
         return fileContent;
     }
}

Als einzige Neuerung im Vergleich zur vorherigen Version fällt das zuvor beschriebene Attribut [WebMethod] auf.

Um die Methode ReadStaticFile nun clientseitig über das ASP.NET Ajax Framwork nutzen zu können, müssen wir innerhalb der *.aspx Seite bei unserem ScriptManager noch die Eigenschaft EnablePageMethods mit dem Wert true versehen.

<asp:ScriptManager ID="ScriptManager1" runat="server" EnablePageMethods="True"/>

Als Ergebnis rendert der Server bei einem Aufruf der Seite nun folgenden Java Script Code inline in die Seite hinein:

 <script type="text/javascript">
         //<![CDATA[
         var PageMethods = function() {

            PageMethods.initializeBase(this);
            this._timeout = 0;
            this._userContext = null;
            this._succeeded = null;
            this._failed = null;
         }
         PageMethods.prototype = {
             _get_path: function() {
                 var p = this.get_path();
                 if (p) return p;
                 else return PageMethods._staticInstance.get_path();
             },
             ReadStaticFile: function(succeededCallback, failedCallback, userContext) {
                 /// <param name="succeededCallback" type="Function" optional="true" mayBeNull="true"></param>
                 /// <param name="failedCallback" type="Function" optional="true" mayBeNull="true"></param>
                 /// <param name="userContext" optional="true" mayBeNull="true"></param>
                 return this._invoke(this._get_path(), 'ReadStaticFile', false, {}, succeededCallback, failedCallback, userContext);
             } 
         }
         // und vieles mehr ;-)

Wie man sieht, wird ein JavaScript Objekt PageMethods angelegt, welches über eine Funktion ReadStaticFile verfügt. Die Funktion hat also genau denselben Namen wie unsere serverseitige Funktion. Weiter nimmt Sie drei optionale Parameter entgegen:

  • succeededCallBack: Funktion, die aufgerufen wird, wenn die Ajax Anfrage erfolgreich beendet wurde
  • failedCallBack: Funktion, die aufgerufen wird, wenn die Ajax Anfrage fehlerhaft beendet wurde
  • userContext: Der Inhalt dieser Variable wird an die Funktionen succeededCallBack bzw. faildCallBack durchgereicht.

Der clientseitige Aufruf der Page Method gestaltet sich nun relativ einfach. Als erstes fügen wir der *.aspx Seite einen neuen ClientScriptBlock hinzu:

<script type="text/javascript">       
  function getStaticFile() {
    PageMethods.ReadStaticFile(onSuccess, onError, "MeinKontext");
  }

  function onSuccess(result, userContext, methodName) {
    var contentDiv = $get('content');
    if (userContext) {
      result += "<p>Der UserContext war: <strong>" + userContext + "</strong></p>";
    }

    result += "<p>Der Methoden Name war: <strong>" + methodName + "</strong></p>";
    contentDiv.innerHTML = result;
  } 

  function onError(result) {
    var contentDiv = $get('content');
    contentDiv.innerHTML = result;
  }

</script>

Einstiegspunkt für unseren späteren Code (Click Ereignis unseres Links) ist die Funktion getStaticFile. Sie ruft die Methode ReadStaticFile des Objekts PageMethods. Als Argumente übergeben wir zum einen die Funktionen für die erfolgreiche bzw. fehlerhafte Behandlung der Ajax Anfrage sowie als drittes die Zeichenfolge "MeinKontext".

Die Funktion onSuccess ist nun die Funktion, die die (erfolgreiche) Antwort des Servers verarbeitet. Sie nimmt neben der eigentlichen Antwort des Servers, auch den zuvor übergebenen userContext entgegen. Außerdem wird der Name der aufgerufenen Servermethode im Parameter methodName übergeben. Da JavaScript relativ flexibel ist, was die Anzahl der Parameter angeht und Funktionen einzig durch ihren Namen und nicht anhand ihrer Signatur identifiziert, können die beiden letzten Parameter übrigens auch problemlos weg gelassen werden.

Innerhalb der Methode onSuccess holen wir uns via $get zunächst eine Referenz auf das Div Element in das wir später unser Ergebnis schreiben möchten. $get ist übrigens eine Funktion des ASP.NET Ajax Client Frameworks. Sie ist (vereinfacht gesagt) die Kurzschreibweise für die JavaScript Funktion document.getElementById.

Weiter werden noch userContext (falls vorhanden) und der aufgerufene Methodenname an das Ergebnis angehangen. Im letzten Schritt wird das komplette Ergebnis schließlich in unser Container Div geschrieben.

Der Aufruf  der Funktion getStaticFile geschieht schließlich im Event onclick eines HTML Links (a Tag).

   17     <p>

   18         <ahref="#"onclick="getStaticFile()">Hier klicken zum Request einer statischen Datei

   19         </a>

  // ....

   27     </p>

   28     <divid="content">

   29         Bitte klicken Sie auf einen der Links, damit dieser Bereich gefüllt wird.

   30      </div>

Schweres Leichtgewicht

Ruft man die Seite nun im Browser auf, fällt auf, dass neben der eigentlichen Seite auch drei JavaScript Dateien des Microsoft ASP.NET Ajax Client Frameworks geladen werden.

Erster Request der Seite

Die erste Anfrage umfasst nun also 93 kb, von denen sich 85 kb auf die MS AJAX Script Dateien verteilen.

Seinen Vorteil spielt die Herangehensweise jedoch bei den Ajax Anfragen aus. Wie man im folgenden Screenshot sieht, gehen hier gerade einmal 127 Byte über die Leitung. Weiter erkannt man deutlich, dass während des Posts kein ViewState mehr zum Server übertragen wird.

02_ajaxpost

Auch die Antwort ist relativ schmal und beschränkt sich auf das nötigste:

03_ajaxantwort

Die Antwort ist übrigens im JSON (Java Script Object Notation) Format serialisiert. Hätte unser Post Daten in Form von Argumenten für unsere Page Method enthalten, wären diese auch automatisch im JSON Format serialisiert worden. Eine etwas besser lesbare Variante der JSON formatierten Antwort enthalt der Tab JSON des Firebugs:

04_ajaxjson

In unserem Beispiel ist die Antwort zwar noch recht übersichtlich, so dass wir den Tab JSON eigentlich nicht benötigen würden, spätestens bei der Rückgabe komplexer Objektstrukturen lernt an den Tab jedoch schnell zu schätzen ;-)

Es geht noch besser!

Obwohl die bisherige Implementierung bereits ganz gut ist, gibt es noch zwei Kritikpunkte. Zum einen erscheint die Plazierung einer statischen Methode innerhalb der *.aspx Seite ein wenig eigenartig. Da sie weder auf Instanz Exemplar-Felder, noch auf Exemplar-Methoden der Seite zugreifen kann, ist sie innerhalb der Seite eigentlich fehl am Platz.

Außerdem stört mich der automatisch generierte JavaScript Script Block innerhalb der Seite, der die Proxies für die PageMethod Aufrufe zur Verfügung stellt. Lieber wäre mir die Variante einer eingelinkten externen JavaScript Datei.

Beide Punkte können wir glücklicherweise recht einfach lösen, nämlich durch den Einsatz von Script Services. Script Services sind normale Web Services, die mit dem ScriptService Attribut annotiert werden. Erstellt man einen Web Service mit Visual Studio 2008, ist dieses Attribut sogar bereits über der Klasse enthalten. Allerdings wird es automatisch auskommentiert.

Um einen Web Service nun also als Script Service zur Verfügung zu stellen, genügt es den Kommentar, wie in Zeile 13 des folgenden Listings gezeigt, zu entfernen.

   11 [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

   12 // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.

   13 [System.Web.Script.Services.ScriptService]

   14 publicclassAjaxDemoService : WebService {

   15 

   16     [WebMethod]

   17     publicstring HelloWorld() {

   18         return"Hello World";

   19     }

   20 

   21     [WebMethod]

   22     publicstring Echo(int number)

   23     {

   24         returnstring.Format("Sie haben {0} eingegeben.", number);

   25     }  

   26 }

Prinzipiell reicht dies aus, um den Service via Ajax anzusprechen. Um uns das Leben jedoch ein wenig einfacher zu machen, lassen wir das ASP.NET Ajax Framework für uns - analog zur Page Method Lösung - JavaScript Proxies für unsere Methoden Aufrufe erstellen. Dazu fügen wir innerhalb des ScriptManager Tags der Seite ein Kind Element <Services> ein. Diesem Element fügen wir als weiteres Kind Element eine ServiceReference ein, deren Pfad auf unseren Service verweißt.

   10     <asp:ScriptManagerID="ScriptManager1"runat="server"EnablePageMethods="True">

   11         <Services>

   12             <asp:ServiceReferencePath="~/AjaxDemoService.asmx"/>

   13         </Services>

   14     </asp:ScriptManager>

An dieser Stelle sei noch einmal darauf hingewiesen, dass dieser Schritt reine Bequemlichkeit und nicht zwingend erforderlich ist. Ohne ihn könnten wir unseren Service genauso via JavaScript rufen und würden genauso JSON als Serialisierungsformat nutzen können. Allerdings müssten wir den clientseitigen Aufruf dann komplett selbst entwickeln und hätten keine Proxies zur Verfügung.

Da wir jedoch bequem sind, lassen wir uns Proxymethoden generieren. Diese können wir dann in unserem bestehenden Client Script Block innerhalb der Seite aufrufen.

Wie die folgende Abbildung zeigt, erhalten wir dann sogar Intellisense und erfahren somit, welche Argumente eine bestimmte Methode entgegen nimmt.

05_VS

Der Rest gestaltet sich ähnlich der Page Method Implementierung. Als wichtiger Unterschied wäre noch zu erwähnen, dass die generierten Proxies standardmäßig in eine externe JavaScript Datei geschrieben werden und somit nicht mehr als Client Script Block in der Seite auftauchen.

Die Kommunikation zwischen Client und Server läuft analog der Page Method Implementierung.

Der Client sendet in seiner Anfrage unter anderem einen Header Content-Type mit dem Wert "application/json; charset=utf-8". Dieser ist besonders wichtig, denn er steuert den Serialisierungsmechanismus des Servers. Hat dieser Header einen anderen Wert, wird die Antwort XML Serialisiert. Somit ist sichergestellt, dass JavaScript Clients JSON erhalten, wohingegen andere Clients XML erhalten.

06_ajaxheader2

Die nächste Abbildung zeigt, dass auch die Post Parameter via JSON serialisiert werden:

07_ajaxpost2

Für die Antwort ist dies natürlich auch weiterhin der Fall:

07_ajaxantwort2

Fazit:

Dieser Teil der Serie hat gezeigt, dass sich die Menge der übertragenen Daten während eines Ajax Requests mit der Hilfe von Page Methods, Script Services und dem ASP.NET Ajax Framework auf ein Minimum reduzieren lassen. Außerdem wird bei dieser Variante der ASP.NET Page Life Cycle im Gegensatz zu den vorherigen Beispielen nicht durchlaufen.

Beides in Kombination kann zu gewaltigen Performancevorteilen verglichen mit Client Callbacks oder dem Updatepanel führen.

Einziger Wermutstropfen ist die Übertragung der 85 kb großen ASP.NET Ajax Framework Java Script Dateien während des ersten Requests.

Eine Abhilfe für dieses Problem werden wir uns im nächsten Teil der Serie ansehen.

Wie immer freue ich mich natürlich über Kommentare zu diesem Blog Beitrag.

 

Dieser Beitrag war hilfreich? Dann bitte nicht vergessen Ihn zu kicken!



blog.codemurai.de © André Krämer |Impressum | Abonieren

BASTA! Spring 2010

18.02.2010 04:24:00 | Jürgen Gutsch

Nächste Woche, am Montag den 22.02.2010, beginnt in Darmstadt eine neue Ausgabe der BASTA! Spring. Da ich dieses Jahr die Möglichkeit erhalten habe, an der gesamten Konferenz teilzunehmen, werde ich hier – nächste Woche - täglich ein paar Informationen zu den von mir besuchten Sessions veröffentlichen. Natürlich versuche ich auch ein oder zwei bekannte Persönlichkeiten der Entwicklercommunity zu treffen und mit ihnen zu sprechen, eventuell ergibt sich daraus auch das eine oder andere Interview. Ich hoffe auch einige Neuigkeiten zu erhaschen und hier präsentieren zu können.

Selbstverständlich ist auch meine Kamera dabei um ein paar Schnappschüsse machen zu können.

Nebenbei:
Zudem bietet die BASTA! für mich die Gelegenheit mit Oliver Sturm das (per Twitter) angedrohte Bierchen zu trinken und mich über den Sinn und Unsinn von Drittanbieter-Controlls im ASP.NET unterhalten zu können ;-)
Ich hoffe sehr das Oliver zwischen seinen Sessions einige Minuten für mich übrig hat :-)

Roberto Bez, Peter Bucher, sowie Gregor Biswanger (der eine Session TDD und BDD abhält) werden unter anderem ebenfalls an der BASTA! Spring teilnehmen. Ich hoffe auch hier auf anregende Diskussionen mit denen :-)

Möglicherweise bekommt Peter die Möglichkeit seinen neuen Dependency Injection-Container LightCore vorzustellen. Wer weis… ;-)

DotNetKicks-DE Image

Sie haben Feedback für Visual Studio 2010? Wir möchten es wissen!

17.02.2010 15:47:53 | Peter Kirchner

vsfeedbackLetzte Woche wurde der Release Candidate von Visual Studio 2010 veröffentlicht, damit Sie diesen RC mit Ihren Projekten testen können.

Wenn Sie Feedback zu diesem RC für uns haben, so lassen Sie es uns auf dieser Umfrageseite wissen.

Sollten Sie Probleme mit dem RC gefunden haben, berichten Sie diese bitte über Microsoft Connect.

Buildautomatisierung mit psake

16.02.2010 22:43:00 | Jan Christian Selke

PSake (ausgesprochen ‘Sake’, wie der Reiswein) ist ein PowerShell basierendes Build Automationstool von James Kovacs. Die Intention des Projekts war es, weg von Xml hin zu einer schlanken Scriptsyntax basierenden Notation zu kommen. Inspiriert wurde die Syntax hierbei unter anderem von Rubys rake. – Und dem Anspruch wurde auch gerecht.

Anwendung findet es bereits bei namhaften Open Source Projekten wie Rhino Mocks.

Installation von psake

Der Quellcode und damit auch der Download wird bei github gehostet. Einfach die zip Datei öffnen und die Datei psake.ps1 in das PowerShell Verzeichnis kopieren - fertig.

Jetzt kann psake durch Aufrufe des Musters psake <buildscript.ps1> [task(s)] gestartet werden.

Syntax Beispiel

Ein einfaches Beispiel für ein build Skript (neben etlichen anderen) wird direkt von James Kovacs in dem Zip Paket mitgeliefert.

properties {
   $testMessage =’Executed Test!’
   $compileMessage=’’
   $cleanMessage=’’
}

task default –depends Test

task Test –depends Compile, Clean {
   $testMessage
}

task Compile –depends Clean {
   $compileMessage
}

task Clean {
   $cleanMessage
}

 

Das Skript kann nach dem oben genannten Muster aufgerufen werden. Wird kein Task explizit angegeben, wird nach dem Task default gesucht.

psake default1.ps1

Funktioniert dann alles nach Wunsch, sollte die Shell folgende Meldung ausgeben.

psake_einfach

 

Einfaches Real-Life Beispiel

Wie sieht es aber aus, wenn tatsächlich ein bestehendes Projekt gebaut werden soll? Ich habe ein ganz einfaches Testprojekt dafür aufgesetzt. Es wird nichts anderes getan, als einfach nur ein build Verzeichnis zu löschen, das Projekt zu kompilieren und die Artefakte in ein neues build Verzeichnis zu kopieren. Verpackt habe ich das Skript in die Datei build.ps1.

properties {
  $base_dir  = resolve-path .
  $build_dir = "$base_dir\build"
  $bin_dir   = "PSakeBuildTest/bin/Debug/*.*"
  $sln_dir   = "$base_dir\PSakeBuildTest.sln"
}

task Default -depends Compile, Deploy

task Compile –depends Clean {
   new-item $build_dir –itemType directory
   exec msbuild "$sln_dir" -outdir="$build_dir"
}

task Clean {
   remove-item –force $build_dir –ErrorAction SilentlyContinue
}

task Deploy -depends Compile {
   copy-item "$bin_dir" "$build_dir"
}

Und es funktioniert wunderbar. Der Output der Shell sollte nun der folgenden ähneln.

psake_einfach

Integration

Integrationsmöglichkeiten für TeamCity, Hudson und CruiseControl.Net sind zumindest geplant. Bei github ist auch bereits ein Beispiel für TeamCity zu finden. Es kann mit Sicherheit eine Alternative zu bestehenden “etablierten” Tools wie NAnt oder MSBuild sein.

Wer sehen möchte, wie weit es bereits “produktiv” genutzt werden kann, sollte sich einen schon älteren Post von J. P. Boodhoo ansehen oder direkt das build Skript von Rhino Mocks bei Ayende.

To Trace or not to Trace

16.02.2010 16:02:00 | Jan Christian Selke

Ist Methoden tracen (noch) state-of-the-art? Diese Frage stelle ich mir gerade.

In einem Projekt nutze ich PostSharp zur Implementierung eines Rechtesystems und zum automatisierten Protokollieren auch und vor allem von Methodenein- und ausgängen. Einen ähnlichen Ansatz habe ich vor einiger Zeit unter Methodenein-und ausgänge tracen… beschrieben.

Jetzt hat sich ein Problem eingeschlichen, das sich im Verhalten von PostSharp geäußert und mich nachdenklich gestimmt hat. Unsere Infrastruktur Komponente ließ sich nicht mehr bauen; Der Postbuild Prozess von PostSharp schlug jedes mal mit einer TypeLoadException fehl. Nach einiger Zeit, die ich mit der Suche nach der Ursache verbracht habe, begann ich mich zu fragen, warum wir Postsharp überhaupt zu genau diesem Zweck einsetzen. Welchen Sinn macht es und welcher Mehrwert wird dadurch generiert?

Zum Beantworten der Fragen muss ich noch etwas ausholen. Wir entwickeln dieses Projekt testgetrieben. In diesem Sinne werden die Methoden bereits mit verschiedensten Eingangsparametern gespeist und (so sollte es zumindest sein) alle möglichen und unmöglichen Verhaltensweisen simuliert. Es dürfte im Testsystem keine Überraschungen durch unvorhergesehene Werte oder Aufrufe geben. Der Zweck ist also klar, aber wo bleibt immer noch der Mehrwert?

Ist es nicht vielmehr so, dass testgetriebene Entwicklung das Protokollieren fast überflüssig macht? Ich möchte nicht sagen vollständig - das Mitschreiben von Fehlern halte ich nach wie vor für sinnvoll -, aber das exzessive Pflastern von Methoden mit Log-Statements zu Debug-Zwecken halte ich für sinnentleert. Ich denke, es geht sogar noch darüber hinaus. Denn nicht sparsam eingesetztes Protokollieren macht die Logdatei extrem unübersichtlich. Unter Umständen wird sogar ein zusätzliches Tool zur Analyse von Logdateien benötigt (Eigentlich komisch, ein Werkzeug zur Analyse muss durch ein Analysewerkzeug analysiert werden ?!). Vermehrtes Protokollieren macht zudem den Quellcode unübersichtlich. Ich gehe sogar noch weiter und behaupte, dass es den Quellcode nicht nur schwer lesbar macht, sondern auch nur deshalb erfolgt, weil der Quellcode an sich schon schlecht lesbar war und das Verhalten des Systems schwer vorhersehbar und/oder instabil ist. Solche Anwendungen sind davon geprägt, dass kleine Änderungen an der Codebasis nur schwer vorhersehbare Konsequenzen nach sich ziehen.

Für mich hat sich eine Frage beantwortet. Ich werde Protokollierung nur noch sehr sparsam, sorgsam dosiert und zielgerichtet anwenden. Das bedeutet aber auch, in Zukunft mit Sicherheit nicht mehr in Verbindung mit Aspektorientierung.

Windows 7 – Sind Sie auch schon startklar?

16.02.2010 14:33:16 | Peter Kirchner

Windows 7 ist bereits seit 117 Tagen auf dem Markt. Es wird Zeit, zu fragen: sind auch Ihre Anwendungen bereits kompatibel für Windows 7?

Ja?!

Großartig! Lassen Sie es die Welt wissen und tragen Sie Ihre Produkte und Lösungen auf www.isvappcompat.com/de ein.

Nein?!

Es wird wirklich Zeit dafür! Auf unseren MSDN-Seiten finden Sie viele Ressourcen, wie Sie Ihre Anwendungen kompatibel bekommen. Natürlich erfahren Sie auch, wie Sie die vielen neuen Features von Windows 7 nutzen können.

Übrigens: auch wenn Sie noch nicht ganz so weit sind, können Sie Ihre Produkte trotzdem schon auf www.isvappcompat.com/de eintragen. ;-) Sie werden dann zwar noch nicht auf Start Klar 7 aufgeführt, aber Sie erhalten technische Ressourcen, die Ihnen bei dem Umstieg helfen.

Start Klar 7

DNUG München: msdn tv war dabei – 15.02.2010

16.02.2010 14:06:05 | Jan Schenk



tweetmeme_url = 'http://blogs.msdn.com/jansche/archive/2010/02/16/dnug-m-nchen-msdn-tv-war-dabei-15-02-2010.aspx'; tweetmeme_source = 'jansche';

Gestern abend war es also mal wieder so weit. Das monatliche Treffen der .NET Usergroup München stand an. Und dank des Hinweises von Gregor Biswanger, der an diesem Abend der Referent war, war auch msdn tv mit am Start und hat gefilmt und Interviews gemacht. Ein paar Impressionen von der gut besuchten Veranstaltung gibt es heute schon in Bildern.

_MG_0498_MG_0500

_MG_0506_MG_0514


_MG_0528_MG_0536

Was Gregor in seinem abendfüllenden Vortrag über Silverlight 4 erzählt, und wie ihr ihn auch in eure Usergroup einladen könnt, erfahrt ihr entweder in msdn tv im März, oder auf Gregors Blog unter http://www.dotnet-blog.net/.

IE8: aktuelle neue deutschsprachige Tutorials, Anleitungen, How-To-Guides auf MSDN

16.02.2010 11:21:51 | Kay Giza

Wir haben viele neue aktuelle und deutschsprachige Tutorials, Anleitungen und How-To-Guides rund um den Windows Internet Explorer 8 (IE8) auf MSDN bereitgestellt. U.a. ist die komplette MSDN Library zum Thema IE8 vollständig aktualisiert und in deutscher Sprache verfügbar. Ein Bereitstellungshandbuch sowie Anleitungen zum Internet Explorer Administration Kit 8 (IEAK) sowie einige frische neue Whitepaper stehen zur Verfügung... [... in diesem Blogeintrag finden Sie eine Zusammenfassung sowie die (Download-) Links...]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

MSDN TV - Ausgabe 15.02.2010

16.02.2010 11:06:33 | Kay Giza

Eine wirklich interessante neue Folge von MSDN TV ist erschienen! Gleich zwei heiße Top-Themen präsentiert die aktuelle Ausgabe von MSDN TV: Wir gehen der Frage nach, was Windows 7 und Bob Dylan gemeinsam haben und präsentieren Mitglieder der Microsoft-Community, die erstmals vor der Kamera auspacken. Aber der Reihe nach: im Interview mit Moderator Jan Schenk informiert diesmal MSDN-Experte und Windows-Entwickler Oliver Scheer unter trickreicher Zuhilfenahme sogenannter CueCards über einige interessante Features von Windows 7 und über Ressourcen, die jeder Developer kennen sollte. Beispiel: das Windows API Code Pack. In den Kurznachrichten gibt’s Infos zum Windows 7 Developer Center, zur neuesten Version der Microsoft... [... vollständiges Video ansehen in diesem Blogeintrag auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Development and Design: Now on Windows Phone 7

15.02.2010 21:23:31 | Oliver Scheer

Jetzt wird es richtig spannend.

“Conferences just don't get any better than this-announcing Windows Phone 7

Join us at MIX10 and be among the first to learn how to build applications and games for Windows Phone 7. We'll introduce you to the development platform, show you how to work with the Windows Phone 7 development tools, and give you a tour of the Windows Phone Marketplace. All MIX10 attendees will receive access to the Windows Phone 7 development tools and have access to a dedicated track on the Windows Phone 7 platform that runs throughout the event.

MIX10 attendees will get exclusive free developer support for the Windows Phone 7 development tools. Don't miss this unique opportunity to be among the first to learn about Windows Phone 7.

REGISTER NOW FOR MIX10

The ONLY way to learn about Windows Phone 7 is to register now for MIX10-we've even extended the special discount on registration through February 21st-you have less than a week to take advantage of this $200 discount.

Don't wait! This is absolutely your last chance to receive this discount. “

Ich bin dort, wer noch?

TheOliver

BizTalk: Zugriff auf UNB-Segment und AS2-Eigenschaften innerhalb Orchestration

15.02.2010 20:30:00 | Wolfgang Kluge

In einer Orchestration bekommt man es normalerweise nur noch mit den eigentlichen Daten einer Nachricht zu tun. So sind bei EDIFACT-Nachrichten z.B. die UNA- und UNB-Segmente nicht Teil des Schemas. Weiterhin fehlen auch die AS2-Header und eben alles, was nicht unbedingt benötigt wird. Das hat seine Vorteile (ist aufgeräumt), manchmal wird aber auch der Zugriff auf diese Daten benötigt.

Läuft eine Nachricht mal auf einen Fehler, so kann man in den "Message Details" erkennen, dass verschiedene "Context-Properties" aus eben diesen sonst nicht sichtbaren Segmenten (oder aus dem Protokoll) zu den einzelnen Nachrichten zugewiesen sind.

Auf diese Kontexteigenschaften kann man mittels Message(ContextProperty) innerhalb einer BizTalk Server Expression Shape in Orchestration Expression Shape zugreifen. Im Falle von EDIFACT-Eigenschaften muss aber - damit man die Auswahl der Context Properties überhaupt zu sehen bekommt - noch eine Referenz auf die DLL Microsoft.BizTalk.Edi.BaseArtifacts (oft zu finden unter C:\Program Files\Microsoft BizTalk Server 2006\Microsoft.BizTalk.Edi.BaseArtifacts.dll) zum Projekt hinzugefügt werden.

Mit dieser Referenz sind dann Kontexteigenschaften in den Namespaces EDI (für EDIFACT und X12 - Eigenschaften) und EdiIntAs (für AS2 - Eigenschaften) vorhanden.

Windows Phone 7 Series

15.02.2010 17:16:08 | Oliver Scheer

windowsphone7seriesVor wenigen Minuten wurde der Weltöffentlichkeit zum ersten mal “Windows Phone 7 Series” vorgestellt: Microsofts neue mobile Plattform der nächsten Generation. Integrierte Benutzerkonzepte, aggregierte Informationen aus unterschiedlichen Quellen, einfach zusammengefasst und bedienbar für den Benutzer.

Die offizielle Homepage, inklusive eines sehr guten Simulators, heißt: http://www.windowsphone7series.com/

Den offiziellen deutschen Blog zu diesem Thema findet man ab sofort hier: http://blogs.msdn.com/windowsphone/ 

Weitere Informationen über die Entwicklerstory wird es auf der MIX’10 in Las Vegas im März und parallel hier in diesem Blog geben.

Es wird extrem spannend. Ich freu mich.

TheOliver

MSDN TV – Neue Folge online

15.02.2010 12:52:18 | Oliver Scheer

Gleich zwei heiße Top-Themen präsentiert die aktuelle Ausgabe von msdn tv: wir gehen der Frage nach, was Windows 7 und Bob Dylan gemeinsam haben und präsentieren Mitglieder der Microsoft-Community, die erstmals vor der Kamera auspacken. Aber der Reihe nach: im Interview mit Moderator Jan Schenk informiert diesmal MSDN-Experte und Windows-Entwickler Oliver Scheer unter trickreicher Zuhilfenahme sogenannter CueCards über einige interessante Features von Windows 7 und über Ressourcen, die jeder Developer kennen sollte. Beispiel: das Windows API Code Pack.

In den Kurznachrichten gibt’s Infos zum Windows 7 Developer Center, zur neuesten Version der Microsoft-Vortragssammlung Webcast DVD Edition 2009, zur frisch gelaunchten Übersicht über die deutschsprachigen Microsoft Social Media Angebote auf dem Web-Portal „Community Guide“, zum Imagine Cup Wettbewerb 2010 und einem wichtigen Termin, den Verwender des Release Candidate von Windows 7 beachten sollten.

Schließlich bedanken sich noch drei Gewinner des Expression Studio Gewinnspiels vom Herbst letzten Jahres per Video für die übersandten Preise. Ach so – wegen Bob Dylan: Die Vorlage zum CueCard-Video stammt aus dem Jahr 1965 und ist hier anzuschauen.

msdn tv – Nachrichten für Entwickler (Ausgabe 02/2010)

15.02.2010 11:27:39 | Jan Schenk



tweetmeme_url = 'http://blogs.msdn.com/jansche/archive/2010/02/15/msdn-tv-nachrichten-f-r-entwickler-ausgabe-02-2010.aspx'; tweetmeme_source = 'jansche';

Get Microsoft Silverlight

Gleich zwei heiße Top-Themen präsentiert die aktuelle Ausgabe von msdn tv: wir gehen der Frage nach, was Windows 7 und Bob Dylan gemeinsam haben und präsentieren Mitglieder der Microsoft-Community, die erstmals vor der Kamera auspacken. Aber der Reihe nach: im Interview mit Moderator Jan Schenk informiert diesmal MSDN-Experte und Windows-Entwickler Oliver Scheer unter trickreicher Zuhilfenahme sogenannter CueCards über einige interessante Features von Windows 7 und über Ressourcen, die jeder Developer kennen sollte. Beispiel: das Windows API Code Pack.

In den Kurznachrichten gibt’s Infos zum Windows 7 Developer Center, zur neuesten Version der Microsoft-Vortragssammlung Webcast DVD Edition 2009, zur frisch gelaunchten Übersicht über die deutschsprachigen Microsoft Social Media Angebote auf dem Web-Portal „Community Guide“, zum Imagine Cup Wettbewerb 2010 und einem wichtigen Termin, den Verwender des Release Candidate von Windows 7 beachten sollten.

Schließlich bedanken sich noch drei Gewinner des Expression Studio Gewinnspiels vom Herbst letzten Jahres per Video für die übersandten Preise. Ach so – wegen Bob Dylan: Die Vorlage zum CueCard-Video stammt aus dem Jahr 1965 und ist hier anzuschauen.

msdn tv ist ein neues Video-Nachrichtenformat, und hat seinen Ursprung auf MSDN Online (http://www.der-evangelist.de/go.php?http://www.msdn-online.de/msdntv/). Alle zwei Wochen präsentiert Ihnen Jan Schenk, Developer Evangelist mit Hut, die wichtigsten Neuigkeiten für Entwickler, Hintergrundberichte und Interviews zu aktuellen Technologien sowie Highlights von Messen und Konferenzen. Das ganze kompakt, in ca. 15 Minuten erfrischend jung verpackt , und sowohl als Download für Ihren Rechner oder im Online-Player per Streaming verfügbar.

msdn tv is a German-speaking new and innovative video news series, and has originally been featured exclusively on the German MSDN Online Platform (http://www.der-evangelist.de/go.php?http://www.msdn-online.de/msdntv/). Hatted Developer Evangelist Jan Schenk biweekly presents latest news for developers, background-stories and interviews concerning current and upcoming technologies, as well as video-highlights from fairs and conferences. Packed into 15 minutes, these news videos feature a fresh informative style, and are downloadable as well as available as online streaming video.

Word Dokumente stilgerecht erstellen

14.02.2010 22:28:00 | Jan Christian Selke

Ebenso wie es Formatdefinitionen auf Ebene von paragraphs und character runs in dem StyleDefinitionsPart (der styles.xml Datei im Package) gibt, existieren auf verschiedenen Ebenen angesiedelte Referenzen im MainDocument.

Nicht nur, dass die Referenzen in den jeweiligen Property Sektionen (bspw. w:pPr oder w:rPr) zu finden sind, sie sind auch entsprechend ihres Scope benannt. Die Referenzen für paragraphs werden über das <w:pStyle> Tag in die ParagraphProperty’s eingebunden. In den RunProperty Sektionen wird der Tag <w:rStyle> verwendet und natürlich gibt es dann noch den TableStyle <w:tblStyle>. Die verschiedenen Ebenen können dabei beliebig ihrer Hierarchie geschachtelt werden.

Die tatsächliche Referenzierung mit einem konkreten Style findet über das Attribut w:val statt. Hier wird auf die Id des einzubindenden Styles verwiesen, beispielsweise Heading1:

<!-- Innerhalb der document.xml –>
<w:pPr>
    <w:pStyle w:val=”Heading1”>
</w:pPr>

<!-- Innerhalb der styles.xml -->
<w:style w:type="paragraph" w:styleId="Heading1">
    …
</w:style>

Wird eine einfache Überschrift mit Untertitel in ein Dokument eingefügt, und damit Styles basierend auf paragraphs und auf text runs, könnte der dazu notwendige Quellcode also folgendermaßen aussehen.

Neu_Einfach

Unglücklicherweise sieht das Dokument jetzt völlig entgegen der Erwartungen aus. Die Styles wurden nicht übernommen, zudem fehlen die Leerzeichen.

Ergebnis_1

Die Leerzeichen werden ignoriert. Durch Einfügen des Attributes xml:spaces=”preserve” lässt sich dieses Problem einfach aus der Welt schaffen. Der Einfachheit halber wird dieses Attribut später direkt an dem Document Element eingefügt und gilt damit auf dem gesamten Dokument.

Die Styles werden nicht angezogen, da die styles.xml in dem neu generierten Dokument (noch) nicht existiert. Hierfür sind mir drei verschiedene Lösungsansätze bekannt. Der erste beruht darauf, dass ein neues Dokument erstellt wird. Die beiden darauf folgenden setzen auf bestehenden Dokumenten auf. Die Varianten sind also:

  1. Erstellen eines neuen StyleDefinitionsParts und definieren eigener Styles (umständlich und aufwändig)
  2. Öffnen und Bearbeiten eines bestehenden Dokuments (in diesem Dokument müssen alle Styles, die in dem späteren Dokument genutzt werden sollen, einmal eingebunden worden sein. Nur so wurden die Definitionen aus dem Template in das Dokument übernommen.)
  3. Speichern einer fertigen styles.xml und Einbinden dieser als Vorlage in das Visual Studio Projekt (Bei jedem neuen Dokument die styles.xml in den StyleDefinitionsPart einlesen.)

Die erste Lösung halte ich in fast allen Fällen für unpraktikabel und/weil viel zu umständlich. Die zweite Lösung stelle ich hier kurz vor. Dazu können aus der bisherigen Lösung die Zeilen

sub1

durch die Folgenden ersetzt werden.

sub2

Am Methodenende noch eine kleine Anpassung zur Erhaltung der Leerzeichen.

sub3

Nun entspricht das Ergebnis schon deutlich mehr den Erwartungen.

ergebnis_2

Die Dokumentstruktur sieht ebenfalls wie erwartet aus:

doc_struktur

Wer Variante 3 ausprobieren möchte, sollte aus einem bestehenden Dokument die styles.xml herauskopieren und als Ressource in das Visual Studio Projekt einbinden. Die Ressource kann dann als Stream in einen neuen StylesDefinitionsPart eingelesen werden. Beispielhaft könnte es folgendermaßen aussehen…

stream_styles

Der Umgang mit Styles ist nicht immer ganz einfach, vor allem wenn sie stark kaskadieren. Als einfacher Weg der sich häufig anwenden lassen kann, hat sich wieder einmal die vorlagenbasierte Bearbeitung erwiesen. Wo hier die Grenzen liegen, muss immer wieder in jedem Fall für sich evaluiert werden.

Nutzlosen Whitespace zur Laufzeit aus dem HTML entfernen

13.02.2010 14:58:29 | Klaus Bock

clean html Ein Verhalten von ASP.NET ist die Auslieferung von wirklich übel formatiertem HTML an den Client. Da werden alle eingerückten Elemente so belassen wie sie in der Quelltextanzeige von Visual Studio™ dargestellt werden. Auch alle unnötigen Zeilenumbrüche werden so ausgeliefert wie sie sind. Selbst Fließtexte, wenn sie bereits im Quelltext vorhanden sind, werden sinnlos umgebrochen und eingerückt. Bei der Bearbeitung des Quellcode ist dieses Verhalten ja ganz angenehm, bei der Auslieferung an den Client wohl eher unnötig.
Im Großen und Ganzen wird so einiges an unnötigem Content erzeugt, der jedes mal zum Client übertragen werden muss. Außer der Verschwendung von Bandbreite, die hier sicherlich nicht das Hauptproblem darstellt, müssen vom Browser immer diese überflüssigen Umbrüche, Leerzeichen und Einrückungen geparst werden. Das dürfte sich, je nach verwendetem Browser, negativ auf die Geschwindigkeit beim Rendern der Seite auswirken.
Dabei ist es relativ einfach, den überflüssigen Whitespace zu entfernen, damit der Quellcode so aussieht wie in der oben gezeigten Grafik.

Bei der Recherche zur Lösung dieses Problems, bin ich auf verschiedene Ansätze gestoßen. Die beiden meist genutzten sind das überschreiben der Page.Render Methode einer Seite, und die Verwendung eines HttpResponse.Filter.

Im Blog von Mads Kristenson habe ich zwei Artikel zu dem Thema gefunden:
In Remove whitespace from your pages zeigt er einen Ansatz mit regulären Ausdrücken um Leerzeichen zwischen Tags und Zeilenumbrüche zu entfernen.
In Remove whitespace from your ASP.NET page zeigt er einen etwas komplexeren Weg um Leerzeichen und Zeilenumbrüche zu entfernen.
Beide Ansätze basieren auf dem Überschreiben der Render-Methode einer Seite.

Auf codeproject bin ich auf zwei Artikel über die Verwendung eines HttpResponse.Filter zum Entfernen von Leerzeichen und Umbrüchen gestoßen.
Reduce The Size Of Your ASP.NET Output zeigt einen Ansatz auf Basis sehr vieler und Aufwendiger Manipulationen einer Zeichenkette.
Removing White Chars from ASP.NET Output using Response.Filter property dagegen, zeigt  zwei verschiedene Wege: einen Ansatz auf Basis eines StreamReader und einen durch direkte Manipulation auf byte Ebene des Stream.

Mir persönlich haben alle bisher gefundenen Ansätze nicht sonderlich zugesagt. Sie alle bieten kaum, oder nur sehr schwer umsetzbar, eine Möglichkeit der Feinabstimmung, wie denn mit den Leerzeichen, Tabs und Umbrüchen umgegangen werden soll.
Gerade hier auf meinem Blog werden Tabulatorzeichen von einem Plug-In zur Formatierung des Quellcode verwendet. An andere Stelle, in der selben Seite, sind diese Tabulatorzeichen absolut überflüssig. Genau so verhält es sich auch mit Zeilenumbrüchen; In der Darstellung von Quellcode werden sie benötigt, zwischen HTML-Tags sind sie unerwünscht.

Wo also ansetzen?
Zunächst einmal galt es den richtigen Zeitpunkt zum Eingriff in den HTML-Output zu finden. Mir erschien das Ereignis PreRequestHandlerExecute als der richtige Moment, der unmittelbar vor der Ausführung einer Seite liegt. Normalerweise wird hier ein Http-Modul benötigt. Da ich jedoch den Filter hier in meinem Blog unter BlogEngine.NET testen wollte, konnte ich mich einfach in ein bestehendes Modul einklinken. Ich habe einfach meinen Filter im bestehenden Kompressionsmodul verwendet, wie man in Zeile 64 des folgenden Listing sehen kann.

void context_PostReleaseRequestState(object sender, EventArgs e)
{
    HttpContext context = ((HttpApplication)sender).Context;
    if (context.CurrentHandler is System.Web.UI.Page && context.Request["HTTP_X_MICROSOFTAJAX"] == null && context.Request.HttpMethod == "GET")
    {
        CompressResponse(context);
        context.Response.Filter = new WhiteSpaceFilter(context.Response.Filter);

        if (BlogSettings.Instance.CompressWebResource)
            context.Response.Filter = new WebResourceFilter(context.Response.Filter);
    }
    else if (!BlogSettings.Instance.CompressWebResource && context.Request.Path.Contains("WebResource.axd"))
    {
        context.Response.Cache.SetExpires(DateTime.Now.AddDays(30));
    }
}

Der Filter selbst, ist lediglich eine Klasse, die von der Klasse Stream ableitet. In der überschriebenen Methode Stream.Write, kann nun die Manipulation der Daten stattfinden.
Als Container der Daten für die verschiedenen Manipulationen habe ich mich für eine StringBuilder Instanz entschieden. In ihr können alle Zeichenfolgenbearbeitungen genau wie in einem string erfolgen, ohne die Nachteile der fortdauernden Neuerzeugung einer String-Instanz.
Bei der Bearbeitung der Daten in der StringBuilder-Instanz, bin ich auf eine Eigenart gestoßen, die mir so nicht geläufig war. Wenn Daten folgendermaßen

var sb = new StringBuilder(Encoding.Default.GetString(buffer));

in einen StringBuilder geschrieben werden, wird das Tabulatorzeichen in seiner String Darstellung \t nicht erkannt. Zunächst dachte ich an ein Problem mit der Kodierung des byte Array. Nach dem mir aber dieses Verhalten, hier die Diskussion Tabulatorzeichen wird nicht gefunden, so bestätigt wurde, bin ich einen kleinen Umweg gegangen.
Da die Tabulatorzeichen ja als byte-Code im Array vorliegen, musste ich nur den byte-Code das Tabulatorzeichen durch den byte-Code eines anderes Zeichen ersetzen welches als String Darstellung im StringBuilder gefunden wird und gleichzeitig in Texten so gut wie nicht vorkommt. Hier habe ich mich für die Tilde ˜ entschieden. Sie kommt im HTML Quelltext nicht vor, da sie unter ASP.NET bereits als Pfad aufgelöst wurde. Wenn sie im Fließtext eines Beitrag auftaucht, ist sie normalerweise als HTML-Code &tilde; enthalten.
Also braucht jetzt nur noch der byte-Code des Tabulatorzeichen mit dem Code der Tilde ersetzt zu werden. Dies geschieht in einer einfachen for-Schleife.

private static byte[] MarkTabs(byte[] buffer)
{
    for (int i = 0; i < buffer.GetLength(0); i++)
    {
        if (buffer[i].Equals(9))
        {
            buffer[i] = 126;
        }
    }

    return buffer;
}

So markiert, kann nun in der StringBuilder Instanz die Tilde durch eine String Entsprechung \t des Tabulatorzeichens ersetzt und verarbeitet werden.

// Tabs als ~ markieren
var markedBuffer = WhiteSpaceFilter.MarkTabs(buffer);
var sb = new StringBuilder(Encoding.Default.GetString(markedBuffer));

// ~ wieder als Tab markieren
sb.Replace("~", "\t");

Da ich in meinen Blogartikeln öfter mal Quelltextbeispiele enthalten sind, möchte ich in diesen die Tabulatoren und Zeilenumbrüche wegen der Formatierung erhalten. Da das HTML der Ausgabeseite in einer StringBuilder Instanz vorliegt, können die Codeblöcke recht einfach mit einem regulären Ausdruck gefunden werden.

private static Regex code = new Regex("<div style=\".+\" id=\".+\" class=\"wlWriterEditableSmartContent\"><pre title=\"code\" class=\".+\">(.*)</pre></div>",
    RegexOptions.Singleline | RegexOptions.Compiled);

Da oftmals mehrere Codeblöcke in einem Artikel vorhanden sein können, werden sie kurzerhand mit einer Hilfsmethode in einer List<T> vom Typ string gespeichert

// Status der Code-Bereiche sichern
List<string> codeStore = (List<string>)WhiteSpaceFilter.SaveCodeStatus(buffer);
private static IList<string> SaveCodeStatus(byte[] buffer)
{
    var sb = new StringBuilder(Encoding.Default.GetString(buffer));
    var codeStatus = new List<string>();
    var codeStoreMatches = code.Matches(sb.ToString());

    foreach (Match match in codeStoreMatches)
    {
        codeStatus.Add(match.Value);
    }

    return codeStatus;
}

und können so, nach dem Entfernen des Whitespace einfach wieder in den ursprünglichen Zustand versetzt werden.

// Status der Code-Bereiche wieder herstellen.
var codeRestorematches = code.Matches(sb.ToString());

for (int i = 0; i < codeRestorematches.Count; i++)
{
    sb.Replace(codeRestorematches[i].Value, codeStore[i]);
}

Wie das eigentliche Entfernen des Whitespace geschieht, ist wahrscheinlich eher situationsabhängig. Ob ein regulärer Ausdruck oder eine genau definierte Zeichenfolge verwendet wird, sollte jeder für sich entscheiden.
Das HTML der jeweiligen Seite kann im StringBuilder praktisch wie eine Zeichenfolge behandelt werden. Es können also einzelne Teile der Seite, wie etwa der Head-Bereich, unabhängig vom anderen Inhalt bearbeitet werden.
Performanceprobleme sind auch kaum zu befürchten, da sowohl reguläre Ausdrücke als auch die Ersetzungen im StringBuilder sehr schnell verarbeitet werden. Ich konnte keine Verzögerungen beim Entfernen des Whitespace feststellen, die über 50 Millisekunden hinausgingen. Die Reduzierung der unkomprimierten Größe der Startseite dieses Blog von 82.3 auf 62.5 kb rechtfertigt aus meiner Sicht den Aufwand allemal.

Fazit:

Das Entfernen des Whitespace lässt sich technisch relativ einfach umsetzen. Eine allgemeingültige Regel konnte ich nicht erkenne, da der Inhalt und die Struktur der einzelnen Webseiten so unterschiedlich sind, wie ihre Betreiber.
Ob sich der Aufwand rechnet, muss jeder für sich selbst entscheiden.
Im Moment spielen die Ladezeiten einer Webseite nur eine untergeordnete Rolle. Allerdings wird gemunkelt, dass Google die Ladezeit einer Webseite in zukünftige Bewertungen mit einließen lassen will.
Nicht zuletzt freut sich jeder Besucher über eine Seite die flott geladen und dargestellt wird.

Technorati-Tags: | | |

1. CeBIT- Stammtisch für .NET, SQL-Server und VFP Entwickler – Ich bin dabei!

13.02.2010 07:06:00 | Lars Keller

Die dFPUG Hannover veranstaltet den “1. CeBIT – Stammtisch für .NET, SQL-Server und VFP”. Zum ersten Mal wird auch .NET für die FoxPro Gruppe ein Thema sein. Ich freue mich sehr über die Einladung einen Vortrag zu dieser Veranstaltung dazu steuern zu dürfen. Mein Vortrag wird die Möglichkeiten der MS Office Entwicklung mit .NET zeigen und einen kleinen Überblick/Einstieg in das Thema geben.

Weitere Details zu dem Event:

Wir freuen uns, am Freitag, den 5.3.2010 ab 18.00 Uhr den 1.CeBIT-Stammtisch für Entwickler von .NET, SQL-Server und Visual FoxPro veranstalten zu können. In lockerer Runde werden Ihnen Vorträge von bekannten Rednern zu interessanten Themen rund um die o.g. Entwicklungswerkzeuge präsentiert. Auch das Networking unter den Teilnehmern wird sicherlich nicht zu kurz kommen. Die Teilnahme ist selbstverständlich kostenlos!

Die geplanten Vorträge:
18:00-18.15 Andreas Flohr (indisoftware GmbH): Keynote
18.15-18.45 Rainer Becker (Wizards & Builders GmbH/dFPUG): Neues zu Visual FoxPro
19:00-19.30 Lars Keller (AX Solutions GmbH): Microsoft Office Entwicklung mit .NET
19:45-20.15 Rudi Vogel (Vogel Software GmbH): Die Starlib-Erweiterung für .NET
20:30-21:00 Torsten Weggen (indisoftware GmbH): DotNetNuke(DNN) – Das Webframework für den professionellen Einsatz
21:15-21:45 Armin Neudert (TMN-Systemberatung GmbH): Webbasierte "Rich Client"-Applikationen mit Silverlight – ein Überblick
22:00-22:30 Armin Neudert (TMN-Systemberatung GmbH): SQL Server: Coding Tipps und Tricks
In den Pausen und danach Networking zwischen den Teilnehmern. Ende der Veranstaltung gegen 23.30 Uhr. Speisen und Getränke können vor Ort zu zivilen Preisen erworben werden.

Der Veranstaltungsort:
Restaurant Lister Turm (im Biergarten Lister Turm)
Walderseestr.100 (Ecke Bernadotte-Allee)
30177 Hannover
Tel.: 0511/ 6965603

Links:

16.02.10 Treffen der .NET Developer Group Braunschweig – DataBinding unter WPF

13.02.2010 06:18:00 | Lars Keller

Unser 42 User Group Treffen der .NET Developer Group Braunschweig findet am 16.02.10, ab 19 Uhr in dem Restaurant Zucker (ehemals Kilian’s Raffinerie) statt.

Dieses Mal hält unser Mitglied Holger Mester einen Vortrag zum Thema “DataBinding unter WPF”.

Datenbindung an Win- und Webforms bietet Microsoft schon lange. Um schnelle und vorzeigbare Prototypen zu erstellen, ist diese Technik hervorragend geeignet. Soll die Datenbindung in großen Projekten zum Einsatz kommen, kommt sie schnell an ihre Grenzen und sorgt für unsaubere Strukturen, da die Daten aus der Datenquelle direkt an das Control durchgereicht werden, ohne die Geschäftsobjekte zu berücksichtigen.
Mit der WPF nahm Microsoft einen neuen Anlauf. Mit dieser neuen Technologie ist eine schärfere Trennung zwischen View und Daten per default möglich. Das schlägt sich natürlich auch auf die Datenbindung durch.
Dieser Vortrag führt in die Datenbindung unter WPF ein und zeigt, wie man einzelne Objekte und Listen an WPF-Controls anbindet. Der Vortrag wird durch Codebeispiele begleitet.

Weitere Informationen unter www.dotnet-braunschweig.de.

Wie immer ist jeder herzlich willkommen!

AIT Build Suite 2010

12.02.2010 14:35:40 | Christian Binder

Die AIT stellt ein kostenfreies Tool zum Download bereit, das einige sehr interessante Erweiterungen im Bereich Team Build mit sich bringt. 
Zum einen erweitert das Tool Assoziierung von Changesets im Team Build, so dass nicht nur der Build Status sondern auch die Build Qualität genutzt werden kann, um auf die Assoziierung Einfluss zu nehmen. Auch ist eine Lösung zur Versionierung der Assemblies durch den Build Prozess enthalten, als auch eine Integration von Sandcastle Projekten zur Code-Dokumentation durch den Build Prozess.

Mehr Infos hier

Viels Spass

Chris

99,5 % Kostenlos = MSDN

12.02.2010 10:15:02 | Oliver Scheer

MSDN - das Microsoft Developer Network - unterstützt Entwickler mit einem reichhaltigen Angebot von Online- und Offline-Services und liefert mit seinem umfangreichen Know-how-Fundus effiziente Hilfe, wenn es um Fragen der Anwendungsprogrammierung auf Basis von Microsoft-Produkten und -Technologien geht. Angefangen beim .NET Framework, den verschiedenen .NET-Sprachen und der Entwicklungsumgebung Visual Studio, über Windows und Webprogrammierung, bis hin zur Entwicklung für mobile Plattformen bietet Ihnen MSDN Online genug Treibstoff, um Ihre Probleme und Fragen hinter sich zu lassen und Ihre Ziele schnell zu erreichen. Natürlich auch zu neuen Themen und Technologien wie Windows 7, Cloud Computing, Silverlight oder Multicore-Programmierung. Lesen Sie auch gerne, was die deutschsprachige Wikipedia über uns schreibt: MSDN auf Wikipedia
Mit MSDN Online möchten wir Ihnen unter der Internetadresse www.msdn-online.de grundsätzlich eine umfangreiche Grundversorgung anbieten. Dort, wo wir Ihnen einen extra Service oder die Extraportion Know-how anbieten, bemühen wir uns dies natürlich kostenfrei für Sie zu realisieren. So sind 99.5% aller unserer Online-Angebote kostenfrei nutzbar.

Mehr Infos: http://msdn-online.de/willkommen

ASP.NET Webforms Anwendungen und Ajax (Teil 3) Das Updatepanel

12.02.2010 00:51:55 | Andre Kraemer

Zu Anfang hoch gelobt, später ausgepfiffen und verpönt. Was sich im ersten Moment nach der typischen Geschichte deutscher Castingshow Teilnehmer anhört, ist in Wirklichkeit das Schicksal des ASP.NET AJAX Updatepanels.

Woll kaum ein anderes Control hat nach seiner Einführung einen solchen Hype verursacht und ist später so tief gefallen.

Der Reihe nach

Ehe wir im dritten Teil meiner ASP.NET Ajax Serie prüfen werden, ob das Updatepanel seinen schlechten Ruf zu recht oder unrecht hat, möchte ich zunächst jedoch kurz ein paar allgemeine Worte über das Steuerelement verlieren.

Das Updatepanel kam mit den ASP.NET Ajax Extensions in der Version 1.0 für das .NET Framework 2.0 auf den Markt und musste für Visual Studio 2005 noch separat heruntergeladen und installiert werden. Ab Visual Studio 2008 ist das UpdatePanel sofort von Hause aus in der Version 3.5 des ASP.NET Ajax Frameworks enthalten.

Ziel des Updatepanels ist es, ASP.NET Entwicklern die Möglichkeit zu geben Ajax zu implementieren, ohne selbst clientseitigen Code schreiben zu müssen. Im Gegensatz zu den Client Callbacks, die ich im Teil 2 der Serie vorgestellt habe, können ASP.NET Entwickler also in Ihrer Komfortzone - dem Server - bleiben.

Der klassische Ansatz über ASP.NET Postbacks

Basis für den heutigen Blogpost wird wieder eine leicht modifizierte Variante des Beispielcodes der vorherigen beidenTeile der Serie sein. Da das Updatepanel aus Entwicklersicht rein serverseitig arbeitet, sind zunächst einige Veränderungen am bestehenden Quellcode notwendig.

Zum einen sind sämtliche HTML Links (a Tags) durch ASP.NET LinkButtons zu ersetzen. Außerdem habe ich den HTML Div Tag, der das Ergebnis der Click-Aktionen anzeigte, durch ein ASP.NET Literal Control ersetzt. Den zuvor in die Seite integrierten JavaScript Code des letzten Beispiels habe ich komplett entfernt.

    1 <%@PageLanguage="C#"AutoEventWireup="true"CodeFile="Teil3.aspx.cs"Inherits="Teil2"%>

    2 

    3 <!DOCTYPEhtmlPUBLIC"-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    4 <htmlxmlns="http://www.w3.org/1999/xhtml">

    5 <headrunat="server">

    6     <title></title>

    7 </head>

    8 <body>

    9     <formid="form1"runat="server">

   10     <h1>

   11         ASP.NET Webforms Anwendungen und Ajax (Teil3): Das Updatepanel</h1>

   12     <div>

   13         <p>

   14             <asp:LinkButtonID="StaticLinkButton"runat="server"OnClick="StaticLinkButton_Click">Hier klicken zum Request einer

   15                 statischen Datei</asp:LinkButton>

   16             <br/>

   17             <asp:LinkButtonID="HelloWorldLinkButton"runat="server"OnClick="HelloWorldLinkButton_Click">Hier

   18                 für Hello World WebService klicken</asp:LinkButton>

   19             <br/>

   20             <asp:LinkButtonID="EchoLinkButton"runat="server"OnClick="EchoLinkButton_Click">Hier für Echo WebService klicken.

   21                 Geben Sie bitte vorher eine Zahl in nebenstehendem Feld ein:</asp:LinkButton>

   22             &nbsp;<asp:TextBoxID="EchoTextBox"runat="server"Width="40px">4711</asp:TextBox>

   23         </p>

   24     </div>

   25     <asp:LiteralID="contentLiteral"runat="server">Bitte klicken Sie auf einen der Links,

   26     damit dieser Bereich gefüllt wird.</asp:Literal>

   27     </form>

   28 </body>

   29 </html>

Serverseitig hat der Code keine Überraschungen parat. Je HTML Link Button gibt es einen Handler für das Click Event, in dem der Inhalt des Literal Controls gesetzt wird.

    1     protectedvoid StaticLinkButton_Click(object sender, EventArgs e)

    2     {

    3         this.contentLiteral.Text = this.ReadStaticFile();

    4     }

    5 

    6     protectedvoid HelloWorldLinkButton_Click(object sender, EventArgs e)

    7     {

    8         this.contentLiteral.Text = this.CallHelloWorldService();

    9     }

   10 

   11     protectedvoid EchoLinkButton_Click(object sender, EventArgs e)

   12     {

   13         this.contentLiteral.Text = this.CallEchoService();

   14     }

   15 

   16     privatestring ReadStaticFile()

   17     {

   18         string fileContent;

   19         using (var reader = newStreamReader(Server.MapPath("~/static.html")))

   20         {

   21             fileContent = reader.ReadToEnd();

   22         }

   23         return fileContent;

   24     }

   25 

   26     privatestring CallHelloWorldService()

   27     {

   28         returnnewAjaxDemoService().HelloWorld();

   29     }

   30 

   31     privatestring CallEchoService()

   32     {

   33         int value;

   34         int.TryParse(this.EchoTextBox.Text, out value);

   35         returnnewAjaxDemoService().Echo(value);

   36     }

Startet man die Seite nun, sieht man dass ein GET Request auf die Seite Teil3.aspx abgesetzt wird. Die Antwort umfasst 2.1 kb.

01ersterRequest

Klickt man nun auf einen der Link Buttons, wird ein Postback ausgeführt und die komlette Seite neu vom Server auf den Client übertragen. Dies überrascht auch nicht, schließlich wurde noch keinerlei Ajax Funktionalität implementiert.

02normalerPostback  

Ein erster Versuch mit dem Updatepanel

Um die Seite nun zu "ajaxifizieren", benötigen wir zwei Controls. Das erste ist der ASP.NET Scriptmanager. Seine Hauptaufgabe ist es, Scripte zum Client zu liefern. Er muss vor allen AJAX Controls innerhalb der Seite erscheinen. Außerdem ist noch anzumerken, dass der Scriptmanager nach dem Highlander prinzip arbeitet: "Es kann nur einen geben!" - nun ja, zumindest pro Seite. Andernfalls würde zur Laufzeit eine InvalidOperationException ausgelöst werden.

Dies bedeutet übrigens, dass ich beim Einsatz von Masterpages keinen ScriptManager auf einer Contentseite platzieren darf, falls  auf der Masterpage bereits ein Scriptmanager genutzt wurde. Stattdessen müsste ich auf der Contentseite einen ScriptmanagerProxy einsetzen. Diesen benötige ich allerdings nur, falls ich auf der Contentseite deklarativ noch weitere Scripte hinzufügen möchte, die auf der Masterpage nicht gebraucht werden.

Da ich langsam etwas ausschweifend werde: Zurück zum Thema!

Das zweite Control, das wir auf unserer Seite brauchen ist ein Updatepanel. Es dient als Container des Bereichs, der später aktualisiert werden soll. Updatepanels dürfen im Gegensatz zum Scriptmanager übrigens mehrfach auf einer Seite vorkommen.

 03toolbox

Nachdem ich Scriptmanager und Updatepanel auf die Seite gezogen, und die die Clientcontrols in das Updatepanel verschoben habe, sieht das Markup meiner Seite wie folgt aus.

    1 <body>

    2     <formid="form1"runat="server">

    3     <asp:ScriptManagerID="ScriptManager1"runat="server">

    4     </asp:ScriptManager>

    5     <h1>

    6         ASP.NET Webforms Anwendungen und Ajax (Teil3): Das Updatepanel</h1>

    7     <asp:UpdatePanelID="UpdatePanel1"runat="server">

    8         <ContentTemplate>

    9             <p>

   10                 <asp:LinkButtonID="StaticLinkButton"runat="server"OnClick="StaticLinkButton_Click">Hier klicken zum Request einer

   11                 statischen Datei</asp:LinkButton>

   12                 <br/>

   13                 <asp:LinkButtonID="HelloWorldLinkButton"runat="server"OnClick="HelloWorldLinkButton_Click">Hier

   14                 für Hello World WebService klicken</asp:LinkButton>

   15                 <br/>

   16                 <asp:LinkButtonID="EchoLinkButton"runat="server"OnClick="EchoLinkButton_Click">Hier für Echo WebService klicken.

   17                 Geben Sie bitte vorher eine Zahl in nebenstehendem Feld ein:</asp:LinkButton>

   18                 <asp:TextBoxID="EchoTextBox"runat="server"Width="40px">4711</asp:TextBox>

   19             </p>

   20             <asp:LiteralID="contentLiteral"runat="server">Bitte klicken Sie auf einen der Links,

   21     damit dieser Bereich gefüllt wird.</asp:Literal>

   22         </ContentTemplate>

   23     </asp:UpdatePanel>

   24     </form>

   25 </body>

Da keine Anpassungen im Code Behind meiner Seite notwendig sind, kann ich die Anwendung nun direkt starten.

Ein Blick auf den Netzwerkverkehr zeigt, dass bei der ersten Anfrage der Seite neben der eigentlichen Seite noch drei JavaScript Dateien übertragen wurden. Die Verweise auf diese drei Script Dateien wurden durch den ScriptManager automatisch in die Seite eingetragen. Allerdings werden nun statt der initialen 2.1 kb knapp 90 kb zum Client übertragen.

04ersterRequestMitUpdatePanel

Den eigentlichen Vorteil sehen wir, sobald wir auf einen der Links klicken. Nicht nur, dass die Seite nicht komplett neu geladen wird und somit das lästige flackern beim Seitenneuaufbau entfällt, auch die Menge der übertragenen Daten hat sich auf 1,5 kb reduziert.

05AsyncRequest1Post

Anscheinend haben wir also alles richtig gemacht. Leider aber auch nur anscheinend. Ein näherer Blick auf die Antwort des Servers zeigt, dass neben dem aktualisierten Inhalt auch das Markup für unsere drei Aktionslinks sowie die Textbox erneut übertragen wurden.

06AsyncRequest1Antwort

Das liegt daran, dass wir einen klassichen Updatepanel Anfängerfehler gemacht haben. Wir haben den kompletten Inhalt der Seite in das Updatepanel geschoben. Somit wird dieser auch vollkommen korrekt wieder vollständig vom Server zum Client übertragen.

Das ist selbstverständlich nicht das, was wir wollten. Schließlich ist unsere Ajax Implementierung nur augenwischerei wenn im Hintergrund doch wieder (fast) alles zum Client übertragen wird.

Ein zweiter Anlauf

Was können wir also tun? Nun, da wir nur den Inhalt des Steuerelements contentLiteral aktualisieren möchten, sollten wir offensichtlich auch nur diesen in das Updatepanel aufnehmen. Dazu schieben wir einfach die drei Aktionslinks wieder über das Updatepanel.

Wenn wir die Seite nun starten, stellen wir jedoch fest, dass ein Klick auf einen der Aktionslinks wieder einen vollständigen Postback inklusive komplettem Rendern der Seite auslöst.

Die Ursache hierfür ist, dass ein Updatepanel standardmäßig nur einen partiellen Postback verursacht und sich somit erneuert, wenn eines seiner Childcontrols einen Postback initiert.

Glücklicherweise lässt sich dieses Verhalten jedoch leicht ändern. Für jedes Updatepanel können sogenannte Trigger registriert werden, die einen partiellen Postback auslösen. Ein Trigger ist dabei nichts anderes, als ein Event eines Servercontrols.

Das Registrieren eines solchen Triggers kann entweder über den Designer oder über das ASP.NET Markup geschehen. Um es über das Markup zu lösen, müssen wir unser Beispiel wie folgt anpassen:

    1     <asp:UpdatePanelID="UpdatePanel1"runat="server">

    2         <ContentTemplate>

    3             <asp:LiteralID="contentLiteral"runat="server">Bitte klicken Sie auf einen der Links,

    4     damit dieser Bereich gefüllt wird.</asp:Literal>

    5         </ContentTemplate>

    6        <Triggers>

    7             <asp:AsyncPostBackTriggerControlID="StaticLinkButton"EventName="Click"/>

    8             <asp:AsyncPostBackTriggerControlID="HelloWorldLinkButton"EventName="Click"/>

    9             <asp:AsyncPostBackTriggerControlID="EchoLinkButton"EventName="Click"/>

   10         </Triggers>

   11     </asp:UpdatePanel>

Lädt man die Seite nun erneut, stellt man fest, dass die Aktionslinks wieder partielle Postbacks auslösen. Außerdem werden auch nur die notwendigen Daten übertragen.

07AsyncRequest2Antwort

Zu viel des Guten

Das Ergebnis sieht eigentlich schon ganz gut, so das man meinen könnte, dass wir nun fertig wären. Leider gibt es aber noch ein kleines Problem. Um dies zu verdeutlichen lege ich ein weiteres Updatepanel auf der Seite an. Dieses Panel erhält ein Literal-Control, welches serverseitig mit der aktuellen Uhrzeit gefüllt wird.

    1     <asp:UpdatePanelID="UpdatePanel2"runat="server">

    2         <ContentTemplate>

    3             <asp:LiteralID="TimeLiteral"runat="server"></asp:Literal>

    4         </ContentTemplate>

    5     </asp:UpdatePanel>

 

    1     protectedvoid Page_Load(object sender, EventArgs e)

    2     {

    3         this.TimeLiteral.Text = DateTime.Now.ToLongTimeString();

    4     }

Meine Erwartungshaltung wäre, dass bei einem Klick auf einen der drei Aktionslinks nur das ursprüngliche Updatepanel aktualisiert wird, da die Links nur hier als Trigger registriert wurden. Das neue Updatepanel sollte nicht aktualisiert werden.

Ein kurzer Test zeigt dass dem nicht so ist:

08_2UpdatePanels1 08_2UpdatePanels2

Wie die beiden Abbildungen zeigen, wurde nicht nur der Bereich des ersten Updatepanels, sondern auch der des zweiten Updatepanels aktualisiert.

Glücklicherweise lässt sich dieses Verhalten jedoch steuern! Das Updatepanel verfügt über eine Eigenschaft UpdateMode. Diese gibt an, wann sich das Updatepanel aktualisieren soll. Standardmässig ist diese Eigenschaft mit dem Wert Always belegt. Stellt man den Wert jedoch auf Contidional, wird das Updatepanel nur noch aktualisiert, wenn entweder eines seiner Childcontrols einen Postback initiert hat, einer der registrierten Trigger ausgelöst wurde, oder explizit die Methode Update serverseitig gerufen wurde.

Die folgenden Abbildungen zeigen die Auswirkung der Änderung des UpdateModes:

08_2UpdatePanels3

08_2UpdatePanels4

08_2UpdatePanels5

Fazit

Richtig eingesetzt ist das Updatepanel meiner Meinung nach besser als sein Ruf und für einfache Szenarien durchaus geeignet. Ajax Funktionalitäten können mit wenig Aufwand und ohne manuellen Scriptcode implementiert werden.

Achtet man darauf, nicht die komplette Seite in ein Updatepanel zu integrieren und den UpdateMode auf Conditional zu setzen, kann das Updatepanel in vielen Szenarien guten Gewissens genutzt werden. Man sollte sich allerdings darüber im Klaren sein, dass serverseitig bei jeder Anfrage der komplette Page-Lifecycle durchlaufen wird. Zeitaufwändige Operationen im Page_Load können - ähnlich wie bei den Client Callbacks - die Ajax Anfragen demnach erheblich verlangsamen!

Was man machen kann, wenn man den Pagelifecycle nicht komplett durchlaufen möchte, werde ich übrigens im nächsten Teil dieser Serie zeigen.



blog.codemurai.de © André Krämer |Impressum | Abonieren

Behaviour Driven Development (BDD) - QM Frühschoppen 16.3.2010

11.02.2010 18:52:00 | Ozgur Aytekin

mit dem Vortrag "Behaviour Driven Development: Software-Entwicklungsprojekte erfolgreich abschließen"

Behaviour Driven Development (BDD) unterstützt agile Software-Entwicklung, indem es die Zusammenarbeit zwischen Entwicklern, Testern und dem Business fördert:
Entwickler erhalten dadurch eindeutige Spezifikationen, Tester einen konsistenten Ausgangspunkt für ihre Testfälle und das Business bekommt eine echte Chance zu beurteilen, ob die Anforderungen richtig erfasst wurden.

Wir wollen Ihnen das Konzept von BDD vorstellen und Ihnen zeigen, wie diese Methode den erfolgreichen Abschluss Ihrer Projekte unterstützt. Nützen Sie diese Chance, im Anschluss direkt mit unseren Experten darüber zu diskutieren.

Diese Veranstaltung richtet sich an Softwarearchitekten, Lead Developer und Entscheidungsträger aus dem IT-Bereich.

Datum & Ort
Datum: 16.3.2010
Zeit: 08:00 – 09:30
Ort: TechTalk Software AG, Technoparkstrasse 1, 8005 Zürich

http://www.techtalk.ch/About-us/News/Events/Fruhstuck.aspx

Visual Studio 2010 Release Candidate für alle

11.02.2010 12:19:27 | Oliver Scheer

Der Release Candidate (RC) von Visual Studio 2010, die letzte Vorabversion vor der Produktveröffentlichung am 12. April 2010, steht nun allen Interessierten in den kommenden Editionen als öffentlicher Download zur Verfügung. Zum Wochenbeginn hatten bereits Inhaber einer MSDN Subscription exklusiven Zugriff auf die – gegenüber der früheren Vorabversion Beta 2 dank umfassenden Kundenfeedbacks immens beschleunigte – Entwicklungsumgebung gehabt. Die ausschließlich englischsprachig verfügbaren Vorabversionen verfügen weiterhin über eine „Go Live“-Lizenz, die den produktiven Einsatz bereits heute erlaubt. Zeitgleich zu Visual Studio 2010 hat auch das grundlegende .NET Framework 4, in den Visual Studio 2010-Installationen bereits enthalten, den RC-Status erreicht und ist von MSDN Online auch separat herunterladbar.
Download: Visual Studio 2010 (RC) und .NET Framework (RC)
Visual Studio General Manager Jason Zander bittet die geneigten Tester der Release Candidates ein weiteres Mal um ihr wertvolles Feedback und stellt in einem Channel 9-Interview die jüngste Entstehungsgeschichte der Release Candidates vor.
Tagesaktuelle Nachrichten rund um Visual Studio finden Sie auch im Visual Studio Developer Center auf MSDN. Im MSDN Forum zu Visual Studio können Sie sich mit der Community austauschen und in der MSDN Mediathek finden Sie zahlreiche weitere Multimediainhalte zu Visual Studio 2010: MSDN Mediathek

Verwandte Links:

MSDN Library zu Visual Studio 2010

Visual Studio 2010 Release Candidate für alle

11.02.2010 11:10:02 | Peter Kirchner

Der Release Candidate (RC) von Visual Studio 2010, die letzte Vorabversion vor der Produktveröffentlichung am 12. April 2010, steht nun allen Interessierten in den kommenden Editionen als öffentlicher Download zur Verfügung. Zum Wochenbeginn hatten bereits Inhaber einer MSDN Subscription exklusiven Zugriff auf die – gegenüber der früheren Vorabversion Beta 2 dank umfassenden Kundenfeedbacks immens beschleunigte – Entwicklungsumgebung gehabt. Die ausschließlich englischsprachig verfügbaren Vorabversionen verfügen weiterhin über eine „Go Live“-Lizenz, die den produktiven Einsatz bereits heute erlaubt. Zeitgleich zu Visual Studio 2010 hat auch das grundlegende .NET Framework 4, in den Visual Studio 2010-Installationen bereits enthalten, den RC-Status erreicht und ist von MSDN Online auch separat herunterladbar.

Download: Visual Studio 2010 (RC) und .NET Framework (RC)

Visual Studio General Manager Jason Zander bittet die geneigten Tester der Release Candidates ein weiteres Mal um ihr wertvolles Feedback und stellt in einem Channel 9-Interview die jüngste Entstehungsgeschichte der Release Candidates vor.

Tagesaktuelle Nachrichten rund um Visual Studio finden Sie auch im Visual Studio Developer Center auf MSDN. Im MSDN Forum zu Visual Studio können Sie sich mit der Community austauschen und in der MSDN Mediathek finden Sie zahlreiche weitere Multimediainhalte zu Visual Studio 2010: MSDN Mediathek

Nachdenken über Clean Code Developper

11.02.2010 02:34:02 | Jürgen Gutsch

Die Initiative

Über ein Jahr ist es her, dass Ralf Westphal und Stefan Lieser die Clean Code Developer Initiative ins leben gerufen haben. Viel Lob gab es für die Initiative aus der Entwickler-Community. Im Großen und Ganzen ist jeder der Meinung, dass die Prinzipien und …. richtig und wichtig sind und angewandt werden sollten.

Natürlich gibt es auch einige Stimmen die sagen, dass die Prinzipien und Praktiken zu übertrieben seien oder aufgrund des großen Aufwandes nicht umsetzbar seinen. Wieder andere stören sich an den empfohlenen Armbändern und Graden. Selbstverständlich ist fast allen klar, das der vorhandene Mehraufwand während der Einarbeitung in die Prinzipien und Praktiken im Nachhinein durch die bessere Wartbarkeit des Codes wieder rein geholt wird. Ebenfalls betonen die beiden Initiatoren immer wieder, dass die Armbänder und die Einhaltung der Grade kein Muss ist, sondern eine Empfehlung um sich Stück für Stück in die Prinzipien und Praktiken einzuarbeiten, um den Überblick zu behalten und nicht alles auf einmal lernen zu müssen.

Ich persönlich halte die Initiative und die Motivation von Ralph und Stefan für eine großartige Sache. Ich habe in meiner Laufbahn als Webentwickler gesehen, dass es nötig ist Entwickler zum Umdenken zu bewegen, dass es dringend erforderlich ist, dass sich ein neues und besseres Qualitätsbewusstsein bei den Entwicklern durchsetzt. Damit sage ich nicht, dass ich die Prinzipien und Praktiken selber schon komplett verinnerlicht habe und selber ständig Clean Code schreibe. Ganz im Gegenteil, eine Punkte muss ich selber lernen, wie z. B: Test Driven Developement. Ich weis, dass TDD richtig ist und umgesetzt werden sollte, aber ich habe es selber noch nicht geschafft wirklich richtig TDD einzusetzen. Ich ertappe mich immer wieder dabei, das ich mehr implementiere, als die aktuelle Anforderung verlangt. Was TDD angeht hat mein Kopf noch nicht komplett umgestellt. Ich bin also selber noch dabei alle Prinzipien und Praktiken zu verinnerlichen.

Das Problem der Initiative

Ich denke mit meiner Einstellungen zur Clean Code Developer Initiative stimme ich mit der Mehrheit der Community überein und genau das ist das große Problem an CCD.

Die Clean Code Developer Initiative ist meines Wissens leider nur in der Entwickler Community bekannt, mehrheitlich sogar nur in der .NET-Entwickler Community. Ralf und Stefan nutzen mehrheitlich die Kanäle der Community (Usergroups, Foren, Blogs, Twitter, Fachzeitschriften) und sprechen damit natürlich auch nur aktive beteiligte der Community an.

Stefan erzählte mir, bei seinem Besuch beim .NET-Stammtisch Konstanz-Kreuzlingen, dass eine Kampagne gestartet wurde, bei der möglichst viele Berufsschulen angeschrieben wurden um auf CCD aufmerksam zu machen. Stefan und Ralf wollten das Problem bei den Wurzeln packen, nämlich bei der Ausbildung der zukünftigen Softwareentwickler. Das Ergebnis war ernüchternd: Laut Stefan gab es keinerlei Feedback auf diese Kampagne.

Um ganz ehrlich zu sein: Ich hätte das leider so oder so ähnlich vorhersagen können.

Das Problem der Berufsschulen

Leider sieht es in den meisten Berufsschulen so aus (wie ich vor mehreren Jahren im Gespräch mit einem Berufsschulrektor und selber während meiner Ausbildung zum Fachinformatiker für Anwendungsentwicklung erfahren habe ), dass bestimmte Fachrichtungen bevorzugt werden. Leider sind es in den wenigsten Fällen die die IT-Berufe. Die IT-Klassen sind diejenigen, die häufig in den Berufsschulen eine Randbedeutung haben. Das sind die Klassen, die angeboten werden müssen, weil es im Gesamtangebot gut aussieht. Warum das so ist, kann ich nicht sagen und ich möchte auch an dieser Stelle nicht darüber spekulieren.

Hinzu kommt, dass es zwei verschiedene Arten von Lehrern gibt. Das sind zum einen die unmotivierten ehemaligen Apotheker (kein Witz!), die einem Objektorientierung anhand von C++ nahe legen sollen zum anderen die jungen, motivierten Lehrer die tatsächlich aus dem echten IT-Leben kommen und wissen, was es heißt junge Menschen Fachwissen beizubringen. Leider sind letztere sehr selten anzutreffen :-/

Desweiteren kommt hinzu, dass die angehenden Anwendungsentwickler in den seltensten Fällen eine einzelne klasse bilden. Oft sitzen angehenden Anwendungsentwickler mit angehenden Systemintegratoren in einer Klasse. Beide Fachgebiete bekommen den gleichen Lehrplan, lediglich die Prüfungen sind unterschiedlich. Die Schüler fragen sich bei über der Hälfte der Fächer, was sie hier überhaupt zu suchen haben. Wieso muss ein Anwendungsentwickler wissen wie er einen RJ45 Stecker an das Kabel moniert und was hat ein Systemintegrator mit objektorientierter Programmierung zu tun.

Der motivierte angehender Anwendungsentwickler sieht die Zeit in der Berufsschule als störende Unterbrechung seiner interessanten Arbeit im Geschäft.  Der motivierte angehender Anwendungsentwickler sitz im Unterricht und beschäftigt sich mit dem aktuelle Kundenproblem. Und der motivierte angehender Anwendungsentwickler lernt zu 95% im geschäftlichen Alltag und nicht in der Berufsschule. Der Grund hierfür ist dass er in der Schule nicht neues oder nichts relevantes lernt. Die Themen sind entweder altbacken oder passen nicht in sein Fachgebiet.

Kann man dann wirklich CCD über die Berufsschulen an die Auszubildenden zu bringen? Ich denke nicht.

Mit den obigen Aussagen möchte ich aber auf keinen Fall die Ausbildung zum Fachinformatiker für den Bereich Anwendungsentwicklung schlecht machen. Ganz im Gegenteil. Der ausgebildete Anwendungsentwickler ist ein Fachmann mit - im Normalfall – dreijähriger Berufs- und Projekterfahrung, den ich persönlich einem frischgebackenen Uni- oder FH-Abgänger vorziehen würde. (Natürlich spielen da noch weitere Faktoren eine Rolle.)

Eine Firma die selber ausbildet, schafft sich einen Mitarbeiter, der optimal an die Bedürfnisse der Firma angepasst ist, die Firma und deren Prozesse kennt und nicht eingearbeitet werden muss.

Gibt es Lösungen?

Um das Problem der Berufsschulen zu lösen, sind nicht Ralf und Stefan gefragt, sondern die ausbildende Industrie selber. Es liegt an denen, den Kammern und den Schulen mit dem nötigen Druck davon zu überzeugen, die schulische Ausbildung ihrer “Zöglinge” zu verbessern und praxisnah zu gestalten. Selbstverständlich versucht das jeder Industriezweig, worauf die Schulen doch wieder die Fachgebiete priorisieren müssen. Da beißt sich die Schlange in den Schwanz…

CCD sollte, aus meiner Sicht, direkt in den Firmen selber bekannt gemacht werden und dafür ist die Initiative so wie sie ist eigentlich schon bestens geeignet :-) Allerdings lässt sich das nicht in einer Hauruckaktion erledigen, sondern ist ein langwieriger Prozess, bei dem es noch mehrere Jahre gehen wird, bis die Mehrheit der Entwickler die Prinzipien und Praktiken überhaupt mal durchgelesen haben. Aber dafür sind die Instrumente und das Merchandising der Clean Code Developer Initiative genau richtig. Die Armbänder und auch die T-Shirts provozieren regelmäßig eine Unterhaltung, die jedes Mal mit der Frage “Was ist denn ein Clean Code Developer?”  beginnt.

Ich bin der Meinung, dass die Initiative an sich schon bewirkt, dass die Mehrheit der Entwickler auf lange Sicht umdenken. Aber auf die Schnelle ist das sicher nicht zu bewerkstelligen.

Schlusssatz

Dieser Beitrag ist keine Kritik an der CCD-Initiative und auch keine Kritik an der Mehrheit der Entwickler, sondern ist einfach nur eine Niederschrift meiner Gedanken über meine Erfahrung mit der Initiative und den Berufsschulen in Deutschland. Ich hoffe nicht, dass sich damit jemand auf irgend einer Weise angegriffen fühlt.

DotNetKicks-DE Image

Innovative Anwendungen fuer Windows 7 entwickeln

11.02.2010 00:47:03 | Kay Giza

Was sind die ersten Schritte, um wenn man sich über die Anwendungsentwicklung für Windows 7 informieren möchte?

Umfassende Informationen zur Softwareentwicklung für Windows 7 finden Sie im MSDN Windows Developer Center. Ob Logo-Programm, Entwicklerhandbuch, Code Snippets oder Testlabor-Zugang in die „heiligen Hallen“ in Redmond, ob Einsteigerinformation oder Profikniffe: Jede Menge Hyperlinks verführen zum Stöbern und Entdecken. Auch ein deutschsprachiges Entwicklerforum zu Windows 7 steht fortschrittlichen Entwicklern für Fragen und Austausch zu Windows 7-spezifischer Entwicklung zur Verfügung.

MSDN Online Deutschland informiert weiterhin ausführlich multimedial über die neuen sowie bekannten Möglichkeiten der Softwareentwicklung für Windows 7.
Informieren Sie sich noch heute wie Sie innovative Windows 7 Features in Ihre Anwendungen einbauen können.

Windows 7 - so macht entwickeln Spaß!


This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Public-Download: Visual Studio 2010 Release Candidate (RC) und .NET Framework 4 RC

10.02.2010 22:55:46 | Kay Giza

Die kommenden Versionen von Visual Studio und .NET Framework sind auf der Zielgeraden und sehen fast die Zielflagge! Kostenloser Download nun für alle: Visual Studio 2010 und .NET Framework 4 stehen ab sofort als Release Candidate zum öffentlichen Download für jedermann zur Verfügung. Die Release Candidates von Visual Studio 2010 und .NET Framework 4 demonstrieren anschaulich, auf welche Neuerungen und User Experience sich Entwickler freuen dürfen. Performance-Engpässe aus früheren Vorab- bzw. Beta-Versionen sind behoben (ich berichtete). Überzeugen Sie sich jetzt von der letzten Vorabversion vor der Produktveröffentlichung am 12. April 2010, testen Sie alles ausführlich und lassen Sie sich von Visual Studio 2010 und .NET Framework 4 begeistern! Release Candidate jetzt herunterladen: Die Release Candidate-Versionen von Visual Studio 2010 und .NET Framework 4 stehen ausschließlich in englischen Versionen zur Verfügung und lassen sich als ISO-Dateien herunterladen. Lesen Sie alle Details, weiterführende Informationen und erfahren Sie die Download-Links in diesem Blogartikel auf Giza-Blog.de... [... mehr in diesem ausführlichen Blogartikel]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

VSTO Projekt endlich auf dem Buildserver

10.02.2010 17:58:00 | Jan Christian Selke

Nun habe ich es also endlich geschafft. Mein VSTO Projekt wird auf dem Buildserver vollständig kompiliert. Der Anfang dazu war auch gar nicht so schwer, eigentlich war alles gar nicht schwierig…

Zu Beginn nahm ich die Anleitung von Kent Boogaart zur Hand, die in einem älteren Post beschrieben wurde, und legte los. Punkt 1 …check, Punkt 2 …check, die Punkte 5 und 6 irritierten mich dann aber doch etwas. Wo sollte ich denn die beschriebenen Dlls finden. Halt, Moment – in den GAC registrieren, also liegen sie wohl auf der Entwicklermaschine ebenfalls dort.

Genau so war es auch, aber hat schon mal jemand versucht Assemblies aus dem GAC zu kopieren? Es funktioniert nicht. Nach etwas Suche musste ich feststellen, dass sie in keinem anderen Verzeichnis zu liegen scheinen. Glücklicherweise ist verschwundenes Wissen zurückgekehrt, dass ich bisher auch noch nicht benötigt hatte. Es gibt einen Registry Key, der einem Einblick in die physikalische Sicht des GAC gewährt. Kurz gesucht und gefunden.

Einfach in den Registry Zweig

   [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Fusion]

falls nicht schon vorhanden, ein neues DWORD DisableCacheViewer eintragen. Der Wert 0 wird als nicht vorhanden gewertet, dass dem Regelfall entspricht. Wird irgendein Wert ungleich eingetragen, zeigt der GAC im Explorer, was er zu bieten hat.

Also, den Wert auf 1 gesetzt, schon zeigte der GAC was er alles hat. Kurzerhand die Dlls herauskopiert und den Wert auf 0 gesetzt. Daraufhin zeigte der GAC wieder die gewohnte gecachte Sicht an.

Die kopierten Dlls nun noch auf den Buildserver kopiert und im GAC registriert, schon lief der erste vollständige Integrationsbuild auf dem Server.

Kurze Schlussanmerkung: Da auf unserem Buildserver nur die .Net Runtime installiert ist, musste ich das gacutil.exe aus dem SDK Verzeichnis der Visual Studio Installation von der Entwicklungsmaschine auf den Server kopieren.

Windows 7 Release Candidate läuft bald ab!

10.02.2010 14:08:19 | Peter Kirchner

Wie bereits angekündigt läuft der Release Candidate (RC) von Windows 7 am 1. Juni 2010 ab. Schon vorher geht es aber ab dem 15. Februar los mit Benachrichtigungen von Windows 7 RC. An dieser Stelle daher noch einmal der Hinweis, vor dem Ablaufdatum entweder auf die Vollversion von Windows 7 zu wechseln oder sich eine frühere Version von Windows zu installieren.

Detailinformationen zu den einzelnen Phasen bis zum 1. Juni 2010 und dem daraus resultierendem Verhalten von Windows 7 erfahren Sie in diesem Blog-Beitrag.

LightCore gibt es nun auch als signierte Version

09.02.2010 22:49:02 | Jürgen Gutsch

Wei bereits geschrieben, hat Peter Bucher einen eigenen Dependency injection-Container entwickelt und Anfang diesen Jahres veröffentlicht.

Damit LightCore auch von signierten Anwendungen heraus verwendet werden kann, haben Peter und Golo Roden beschlossen, auch eine signierte Version des DI-Containers zur Verfügung zu stellen. Golo wird also zukünftig zu jeder neuen Version von LightCore auch eine signierte Version zur Verfügung stellen. Die aktuelle signierte Version kann im Moment unter folgender URL heruntergeladen werden:

http://www.goloroden.de/Downloads/LightCore.aspx

In den nächsten Tagen wird es auch einen Link auf der offiziellen Projektseite geben.

Hinweis:
Die Assembly “LightCore.CommonServiceLocator.dll”  kann derzeit nicht signiert werden, da diese von einer nicht signierten Assembly von Microsoft abhängig ist. .NET verbietet es aus Sicherheitsgründen, von einer signierten Assembly auf eine nicht signierte zu verweisen.

(via: LightCore signiert)

DotNetKicks-DE Image

TDD – Probleme vermeiden mit der AAA-Syntax

09.02.2010 11:20:15 | Gregor Biswanger

Immer mehr Prinzipien und Vorgehensweisen lenken die heutige Softwareentwicklung auf den korrekten Pfad. Das gleiche gilt natürlich auch für die Test-Ebene. Nur zählen hierbei ganz andere „Golden Rules“. Eines der wichtigsten Regeln beim Schreiben von Tests, ist die Einhaltung der AAA-Syntax.

tdd-red-green-feeling

Die AAA-Syntax

Beim Schreiben von Unit-Tests muss immer eines der wichtigsten Regel eingehalten werden: „Eine Test-Methode muss Isoliert und unabhängig von anderen Test-Methoden ausführbar sein.“. Die Test-Methoden dürfen daher nur Objekte testen, die explizit für sie erstellt wurden. Sobald eine Instanz von einem Objekt für mehrere Test-Methoden zugreifbar ist, wird bereits die soeben genannte Regel gebrochen.

Bei manchen Test-Frameworks, wie zum Beispiel NUnit, können mittels SetUp- und TearDown-Attribute eigene Methoden zum vorbereiten und aufräumen von Objekten verwendet werden. Das ist zum Beispiel sehr gut um ein neues Datenbank-Schema vor jedem Aufruf einer Test-Methode zu erzeugen. Allerdings wäre hier auch ein Nachteil, dass dieser Vorgang auch ausgeführt wird, wenn andere Test-Methoden keinen Datenbankzugriff benötigen. Daher werden auch Instanzen zur Verfügung gestellt, die eventuell von anderen Test-Methoden nicht verwendet werden dürfen. Folglich müssen eigene Instanzen bei jeder Test-Methode selbst zu Beginn erzeugt werden.

TDD-AAA-Syntax

Abb.1 – Eine Test-Methode die durch eigene Bereiche aufgeteilt wird.

Dazu wird eine Test-Methode in 3 Bereiche aufgeteilt. Jeder einzelne Bereich hat zudem auch seinen eigenen Aufgabenbereich. Die jeweiligen Bereiche sind durch die 3 x AAA geregelt (siehe Abb.1). Daher ist die AAA-Syntax entstanden und baut sich wie folgt auf:

 

Arrange – Instanzen für den Test vorbereiten

Aus der AAA-Syntax steht der erste Buchstabe A für Arrange, das so viel bedeutet wie „die Einrichtung“. Hierbei müssen alle Instanzen für den Test vorbereitet werden. Die Instanzen müssen direkt erzeugt werden, und zum Beispiel nicht von einem Microkernel (ServiceLocator). Um somit abhängichkeiten zu vermeiden. Die Einzige Ausnahme wäre hierbei ein Mocking-Framework. Hierbei wird explizit verlangt, dass ein gefälschtes Objekt erzeugt wird.

 

   1: [TestFixture]
   2: public class CustomerRepositoryTest
   3: {
   4:     [Test]
   5:     public void Get_Customers_from_Repository()
   6:     {
   7:         // Arrange
   8:         List<Customer> customers = new List<Customer>();
   9:  
  10:         Customer customerA = new Customer
  11:                                 {
  12:                                     Firstname = "Gregor", 
  13:                                     Lastname = "Biswanger"
  14:                                 };
  15:  
  16:         Customer customerB = new Customer
  17:                                 {
  18:                                     Firstname = "Robert",
  19:                                     Lastname = "Walter"
  20:                                 };
  21:  
  22:         customers.Add(customerA);
  23:         customers.Add(customerB);
  24:  
  25:         ICustomerRepository customerRepository = new CustomerRepository();
  26:  
  27:         // Act
  28:         // ...
  29:  
  30:         // Assert
  31:         // ...
  32:     }
  33: }

Listing 1 – Ein einfacher Test der mit Arrange beginnt.

   1: [TestFixture]
   2: public class CustomerRepositoryTest
   3: {
   4:     [Test]
   5:     public void Get_Customers_from_Repository()
   6:     {
   7:         // Arrange
   8:         List<Customer> customers = new List<Customer>();
   9:  
  10:         Customer customerA = new Customer
  11:                                 {
  12:                                     Firstname = "Gregor", 
  13:                                     Lastname = "Biswanger"
  14:                                 };
  15:  
  16:         Customer customerB = new Customer
  17:                                 {
  18:                                     Firstname = "Robert",
  19:                                     Lastname = "Walter"
  20:                                 };
  21:  
  22:         customers.Add(customerA);
  23:         customers.Add(customerB);
  24:  
  25:         ICustomerRepository customerRepository = MockRepository.GenerateMock<ICustomerRepository>();
  26:         customerRepository.Stub(repository => repository.GetCustomers()).Return(customers);
  27:  
  28:         // Act
  29:         // ...
  30:  
  31:         // Assert
  32:         // ...
  33:     }
  34: }

Listing 2 – Ein erweiterter Test mit einem Mock-Framework.

 
Act – Aktivitäten der Instanzen ausführen

Der zweite Buchstabe A aus der AAA-Syntax, steht für Act und bedeutet so viel wie „der Vorgang“. Beim „Act“ werden von den jeweiligen Instanzen deren Funktionen aufgerufen. Also beim TDD-Prozess wird hier deklariert, was von der späteren Implementierung ausgeführt werden soll.

 

   1: [TestFixture]
   2:  public class CustomerRepositoryTest
   3:  {
   4:      [Test]
   5:      public void Get_Customers_from_Repository()
   6:      {
   7:          // Arrange
   8:          List<Customer> customers = new List<Customer>();
   9:  
  10:          Customer customerA = new Customer
  11:                                  {
  12:                                      Firstname = "Gregor", 
  13:                                      Lastname = "Biswanger"
  14:                                  };
  15:  
  16:          Customer customerB = new Customer
  17:                                  {
  18:                                      Firstname = "Robert",
  19:                                      Lastname = "Walter"
  20:                                  };
  21:  
  22:          customers.Add(customerA);
  23:          customers.Add(customerB);
  24:  
  25:          ICustomerRepository customerRepository = MockRepository.GenerateMock<ICustomerRepository>();
  26:          customerRepository.Stub(repository => repository.GetCustomers()).Return(customers);
  27:  
  28:          // Act
  29:          List<Customer> customersResult = customerRepository.GetCustomers();
  30:  
  31:          // Assert
  32:          // ...
  33:      }
  34:  }

Listing 3 – Ein einfacher Test mit einem Act erweitert.

 

Assert – Die Erwartung definieren

Der dritte und letzte Buchstabe A steht für das Assert. Assert bedeutet „die Erwartung“. Dieser Bereich ist für das feststellen und versichern einer vom Act ausgeführten Anforderung. Die meisten Test-Frameworks bieten dazu statische Assert-Klassen bereit.

 

   1: [TestFixture]
   2: public class CustomerRepositoryTest
   3: {
   4:     [Test]
   5:     public void Get_Customers_from_Repository()
   6:     {
   7:         // Arrange
   8:         List<Customer> customers = new List<Customer>();
   9:  
  10:         Customer customerA = new Customer
  11:                                 {
  12:                                     Firstname = "Gregor", 
  13:                                     Lastname = "Biswanger"
  14:                                 };
  15:  
  16:         Customer customerB = new Customer
  17:                                 {
  18:                                     Firstname = "Robert",
  19:                                     Lastname = "Walter"
  20:                                 };
  21:  
  22:         customers.Add(customerA);
  23:         customers.Add(customerB);
  24:  
  25:         ICustomerRepository customerRepository = MockRepository.GenerateMock<ICustomerRepository>();
  26:         customerRepository.Stub(repository => repository.GetCustomers()).Return(customers);
  27:  
  28:         // Act
  29:         List<Customer> customersResult = customerRepository.GetCustomers();
  30:  
  31:         // Assert
  32:         CollectionAssert.AllItemsAreNotNull(customersResult);
  33:         CollectionAssert.AreEqual(customers, customersResult);
  34:     }
  35: }

Listing 4 – Ein einfacher Test mit seinen definierten Asserts.

 

Fazit

Mit der Verwendung der AAA-Syntax leiten sich mehrere Vorteile heraus. Zum einem wird hierbei verhindert, dass die erste und wichtigste Regel gebrochen wird. Des Weiteren verhindert man eine Unübersichtlichkeit. Durch die AAA-Syntax wird der Test-Code um einiges Strukturierter und somit leserlicher für andere Entwickler.

Visual Studio 2010 und .NET Framework 4 Release Candidate (RC) erschienen

09.02.2010 10:33:22 | Kay Giza

Schon wieder ein Vorsprung für Inhaber einer MSDN Subscription: Sie können jetzt den Release Candidate von Visual Studio 2010 sowie von .NET Framework 4 aus den MSDN Subscriber Downloads herunterladen. In Kürze wird auch für alle anderen Interessenten ein öffentlicher Download zur Verfügung stehen. Die letzte Vorabversion vor der Veröffentlichung von Visual Studio 2010 im April steht ausschließlich in englischsprachiger Version zur Verfügung und erlaubt das Testen der letzten Verbesserungen und immensen Performancesteigerungen für die Entwicklungsumgebung, die dank des vielfältigen Kundenfeedbacks seit der Vorabversion Beta 2 erreicht werden konnten. Visual Studio General Manager Jason Zander bittet die geneigten Tester der Release Candidates ein weiteres Mal um ihr wertvolles Feedback und stellt in einem Channel 9-Interview die jüngste Entstehungsgeschichte der Release Candidates vor.

Entwickler ohne MSDN Subscription werden die Software im weiteren Verlauf dieser Woche ebenfalls über diese spezielle Website kostenlos herunter laden können. Der Release Candidate von Visual Studio 2010 verfügt über eine „Go Live License“ für den produktiven Einsatz. Geben Sie uns bitte weiterhin Feedback – es kommt direkt dort an, wo es wichtig ist: In den Produktgruppen und Entwicklungsteams, die hart daran arbeiten, Visual Studio 2010 zur besten Entwicklungsumgebung zu machen. Visual Studio 2010 erscheint am 12. April 2010.

Tagesaktuelle Nachrichten rund um Visual Studio finden Sie auch im Visual Studio Developer Center auf MSDN. Im MSDN Forum zu Visual Studio können Sie sich mit der Community austauschen und in der MSDN Mediathek finden Sie zahlreiche weitere Multimediainhalte zu Visual Studio 2010: MSDN Mediathek

Verwandte Links:



This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

LINQ-Queries dynamisch aufbauen

08.02.2010 20:00:00 | Martin Hey

Einer der größten Vorteile von LINQ to Objects ist es, dass man typsicher auch sehr komplexe Abfragen über Objektstrukturen durchführen kann. Zuweilen möchte man aber dem Anwender die Möglichkeit bieten, selbst zu bestimmen, welche Operationen mit den Objektstrukturen durchgeführt werden. Als Beispiel soll hier die dynamische Filterung und Sortierung anhand der Member des Objekts dienen. Spätestens zu diesem Zeitpunkt wird eines der größten Pro's von LINQ zum Verhängnis - die Typsicherheit.

Um hier eine gewisse Dynamik unterzubringen muss man zunächst wissen, wie LINQ-Queries aufgebaut sind. Sie bestehen aus sogenannten Expression Trees, die dann ausgeführt werden. Liegt ein LINQ-Query vor, kann man sich z.B. mit dem Expression Tree Viewer aus den C# Samples den Expression-Tree ansehen.


Um hier dynamische Filterung und/oder Sortierung zu implementieren, gilt es, einen solchen Baum dynamisch aufzubauen. Das ist gar nicht so kompliziert, wie es sich auf den ersten Blick anhört.

Angenommen, es liegt eine generische List mit Adressen vor (im Beispiel Restaurant-Adressen) - mit den für Adressdaten typischen Membern (Name, Straße, Postleitzahl, Ort). Per Parameter soll definiert werden können, welche Eigenschaft gefiltert werden soll und wie das Filterkriterium ist -gleiches gilt für die Sortierung.
Im Beispiel definiert die Klasse RestaurantRepository Zugriffsmethoden für den Zugriff auf Listen vom Typ Restaurant. Dabei kann mittels GetRestaurants eine komplette Liste abgerufen werden die Methode GetFilteredRestaurants implementiert den dynamischen Aufbau. Als Parameter dient hier zunächst ein Dictionary, dessen Key den zu filternden Membernamen und dessen Value den zu filternden Wert beinhaltet - sowie eine Liste, deren Inhalt definiert nach welchen Membern sortiert werden soll.

public static IEnumerable<Restaurant> GetFilteredRestaurants(Dictionary<string, string> filter, List<string> sort)
{
IEnumerable<Restaurant> restaurants = GetRestaurants();


#region get lambdas
// where
ParameterExpression pe = Expression.Parameter(typeof(Restaurant), "address");
Expression whereExpression = null;
foreach (string filterAttribute in filter.Keys)
{
Expression left = MemberExpression.Property(pe, filterAttribute);

string filterValue = filter[filterAttribute];

Expression right = Expression.Constant(filterValue);

if (whereExpression == null)
{
whereExpression = Expression.Equal(left, right);
}
else
{
whereExpression = Expression.And(whereExpression, Expression.Equal(left, right));
}
}

Expression<Func<Restaurant, bool>> whereCondition = Expression.Lambda<Func<Restaurant, bool>>(whereExpression, new ParameterExpression[] { pe });

var filteredItems = restaurants.AsQueryable().Where(whereCondition);

// order by
Expression queryExpr = filteredItems.Expression;
string methodAsc = "OrderBy";
string methodDesc = "OrderByDescending";

foreach (string sortCriteria in sort)
{
var type = typeof(Restaurant);
var property = type.GetProperty(sortCriteria);
var parameter = Expression.Parameter(type, "p");
var propertyAccess = Expression.MakeMemberAccess(parameter, property);
var orderByExpression = Expression.Lambda(propertyAccess, parameter);

queryExpr = Expression.Call(typeof(Queryable), methodAsc,
new[] { type, property.PropertyType },
queryExpr, Expression.Quote(orderByExpression));
methodAsc = "ThenBy";
methodDesc = "ThenByDescending";
}

#endregion

return (filteredItems.Provider.CreateQuery(queryExpr)).ToList();
}

Zunächst wird eine ParameterExpression instanziiert. Da Member mit Konstanten verglichen werden sollen, wird für jedes Filterkriterium eine MemberExpression und eine Konstante initiiert. Beides wird mit Expression.Equal verkettet. Mit Hilfe von Expression.And können mehrere solcher Vergleiche aneinandergekettet werden.

Ist die Filterung durchgeführt, kann dann noch die Sortierung bearbeitet werden. Auch hier wird wieder eine Expression mit MemberAccess initiiert. Anhand des Wertes kann dann mit Hilfe von Expression.Call die Sortierung durchgeführt werden.

Ein kleines Testprogramm zeigt dann, dass der Code auch funktioniert...

Deutsche Post Schreibcenter jetzt auch auf Facebook

08.02.2010 13:58:33 | Kay Giza

Postkarten vom PC verschicken, dass finde ich echt nett. 1. schreibe ich so selten Brief (eigentlich nie) und 2. Postkarten höchsten im Urlaub (wobei da verschicke ich meistens auch E-Mails). Im Grunde genommen ist es dennoch nett, wenn man mal Post bekommt, oder? Ab und zu nutze ich den Service der deutschen Post, das SchreibCenter. Man schreibt seine Postkarte online, die Deutsche Post druckt und frankiert und liefert direkt in den Briefkasten. Relativ neu ist das SchreibCenter nun auch auf Facebook vertreten. Mit der Schreibcenter Applikation der Deutschen Post kannst Du individuelle Postkarten-Collagen mit Bildern aus Deinem Facebook Album erstellen und als echte Postkarte verschicken. Poste Deine selbst erstellten Postkarten auf Deiner Pinnwand oder schicke sie per Email an einen Freund... [... lesen Sie den vollständigen Blogeintrag auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Endspurt: ASP.NET MVC 2 RC 2 Released

08.02.2010 00:37:04 | Jürgen Gutsch

Für alle die es noch nicht mitbekommen haben: Die RC 2 des ASP.NET MVC 2 ist raus.

Mehr zu RC 2 hat Phil Haack in diesem Beitrag: ASP.NET MVC 2 RC 2 Released

Download

DotNetKicks-DE Image

Nachlese zum 6.Treffen der SharePoint Usergroup Dresden

07.02.2010 20:45:00 | Martin Hey

Das erste Treffen der SharePoint Usergroup Dresden im Jahr 2010 fand am 28.01. statt. Gastgeber war erstmalig die datafino GmbH am Waldschlösschen und bei verschneiten Straßen war es für den ein oder anderen ein Abenteuer, zum Treffen hin und abends auch wieder zurück nach Hause zu kommen. Der Abend war aus meiner Sicht aber sehr gelungen und ich würde mich freuen, wenn wir hier öfter zu Gast sein dürfen.

Nachdem sich alle von den Anreisestrapazen mit Hilfe eines belegten Brötchens erholt und wir einen zu unseren Notebooks passenden Raum gefunden hatten, konnte der Abend beginnen.

Zunächst zeigte Ronny Schattauer theoretisch und im folgenden auch praktisch, wie er in einem Projekt Visio zur Datenmodellierung im SharePoint verwendet. Dabei werden zunächst mit Hilfe von definierten Stereotypen ER-Modelle erzeugt, diese werden dann in XML ausgegeben und mit Hilfe eines eigens geschriebenen Konvertierungs-Tools werden aus dem so erstellten Modell Template-XML-Dateien für Content-Types und Listen erstellt, die dann problemlos verteilt werden können. Wer schon jemals mehrere Content-Type-XML-Dateien per Hand erstellt und die dazugehörigen Listen-Templates, der weiß, wie fehleranfällig die manuelle Arbeit ist - und um so spannender finde ich diese Möglichkeit, sich die Arbeit zu erleichtern.

Im Anschluss an diese doch eher technische Präsentation gab es eine eher fachliche Diskussion unter dem Thema "Enterprise 2.0 mit SharePoint 2010". Und auch hier waren zum Teil sehr spannende Anregungen und Anmerkungen der Teilnehmer - und das Spektrum ging angefangen von Fragen wie "Wie hole ich Anwender ab, die auf Web 0.5 Stand sind?" bis zu "Wie funktioniert das Bewerten-Feature in SharePoint 2010 eigentlich genau?".

Abschluss bot eine kleine Verlosung, denn es gab eine Eintrittskarte zu den SharePoint Days, die im Rahmen der Basta! Spring durchgeführt werden, zu gewinnen. Ich geh davon aus, dass alles organisatorische soweit geklärt ist, und André die Karte nun schon in den Händen hält. Herzlichen Glückwunsch.

Treffen der .NET Usergroup Dresden

07.02.2010 19:46:00 | Martin Hey

Das letzte Treffen der .NET Usergroup ist noch gar nicht so lange her - letzten Mittwoch war es soweit. Eigentlich wollte ich dort auch einen Vortrag halten, aber eine fiese Erkältung hat mich davon abgehalten. Die Präsentation ist aber nur aufgeschoben und wir suchen schon nach einem neuen passenden Termin. Außerdem ärgere mich auch ein wenig, den Vortrag von Erik zum Thema
Azure verpasst zu haben

Und wo ich einmal dabei bin: Das nächste Treffen steht auch schon direkt vor der Tür: Die .NET-Usergroup Dresden trifft sich das nächste Mal am 24.02. um 18:00 Uhr. Auch dieses Mal verspricht es wieder sehr interessant zu werden: Alexander Groß - vielen bekannt von der .NET Usergroup Leipzig - macht mit uns einen Rundgang durch sein aktuelles Projekt. Technisch wird das sehr interessant, denn mit dabei ist eine bunte Mischung von Technologien, Produkten und Frameworks - um nur wenige zu nennen: FubuMVC, NHibernate, MSpec, AutoMapper, ReSharper, Rake und MSDeploy. Ohne Slides aber dafür direkt am lebenden Objekt gezeigt, bleibt viel Raum für Diskussionen und Fragen.

Wir treffen uns dieses Mal bei der Communardo Software GmbH. Nähere Informationen zum Termin und eine Anfahrtsbeschreibung gibt es natürlich auch.

Buch-Tipp: Cloud Computing mit der Windows Azure Platform

07.02.2010 15:28:04 | Kay Giza

*freu* Endlich mal wieder ein Blogeintrag in meiner Kategorie: Ich lese zur Zeit...

Ich lese zur Zeit das Buch '
Cloud Computing mit der Windows Azure Platform: Softwareentwicklung mit Windows Azure und den Azure Services
'.
Wer einen Einblick in die Thematik haben möchte, ist hier genau richtig!

Das Buch richtet sich an alle, die sich für das Thema Cloud Computing interessieren und in diesem Zusammenhang eine Affinität zur Microsoft Technologieplattform besitzen. Das Buch ist inhaltlich sehr breit aufgestellt, sowohl technische Entscheidern, Unternehmens- und Softwarearchitekten als auch Entwicklern dürfte das Buch gefallen.

Das Kapitel 1 und Kapitel 2 beleuchten die Thematik auf einer strategischen Ebene. Die Kapitel geben einen Überblick über Cloud Computing im Allgemeinen und die Umsetzung auf der Microsoft Technologieplattform.
Kapitel 3 bis Kapitel 6 richten sich stärker an Entwickler, die in Software-Implementierungsprojekte involviert sind und an technischen Details der Windows Azure Plattform interessiert sind. Hier werden Windows Azure, Live Framework, .NET Services und SQL Azure beschrieben. Die beiden letzten Kapitel geben einen Ausblick auf Einsatzszenarien, in denen die Windows Azure Plattform verwendet werden kann.
Kapitel 10 ist ein Update zum gedruckten Buch und ist bis zur Auflage 2 nur online erhältlich (siehe weiter unten).

Mein Kollege Holger Sirtl zeigt also auf Basis der Community Technology Preview (CTP) der Windows Azure Platform, wie Cloud Computing funktioniert, was die Windows Azure Platform leisten kann und wie Sie davon profitieren. Insbesondere geht er auf die Themen Betriebssystem für die Cloud, Personal Computing, Integration, Datenspeicherung und Software-plus-Services-Lösungen ein. Zudem werden Parallelen zu etablierten Microsoft-Technologien wie SQL Server und erklärt, wie man Azure auch mit PHP, Java oder Ruby nutzen kann.

Seit der Fertigstellung des Buchmanuskriptes hat es eine Reihe von Änderungen und Erweiterungen an der Plattform gegeben, die in einem Zusatz-Kapitel überblicksartig beschrieben werden. Zusammen mit der gedruckten Version des Buches bildet es ein Gesamtwerk, welches einen Überblick über die aktuelle Version (Stand: Januar 2010) der Windows Azure Platform gibt. Zu einem späteren Zeitpunkt werden die Neuerungen in die betreffenden Kapitel des Buches überführt und dann in einer zweiten Auflage des Buches veröffentlicht.

Kapitel 10: Aktualisierungen in Azure Version 1.0

Buch direkt kaufen:




This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Entwickler-Ressourcen für IE8-Kompatibilität

05.02.2010 18:39:43 | Peter Kirchner

Dd565632.new8(en-us,VS.85)[1] Gute Startpunkte für die Entwicklung für den Internet Explorer 8 und die Berücksichtigung der Kompatibilität zu Vorgängerversionen finden Sie in den folgenden drei Portalen, die ich Ihnen empfehlen möchte.

Entwicklerinformationsindex für Internet Explorer 8

Dieser Informationsindex bietet Ihnen eine umfassende Übersicht über die für Internet Explorer 8 für Windows, Windows Server 2003 und Microsoft Vista verfügbaren Informationen. Dieser Informationsindex bietet Ihnen Zugang zu bestimmten Übersichten, Referenzmaterialien, technischen Artikeln und Weblogeinträgen, die für Entwickler hilfreich sind. Die Informationen werden dabei für den einfachen Zugriff nach Themen angeordnet.

Internet Explorer Compatibility Center

Internet Explorer 8: Was muss ich jetzt wissen?

  • Herunterladen von Internet Explorer 8
  • Wie nutze ich die neuen Features in Internet Explorer 8?
  • Meine Website funktioniert nicht richtig. Wie kann ich das Problem beheben?
  • Updates zur Einhaltung von Standards in Internet Explorer 8
Internet Explorer Application Compatibility

Dieses Dokument ist als Begleitmaterial für das Microsoft Application Compatibility Toolkit (ACT) gedacht, das ebenfalls Teil des Internet Explorer Compatibility Test Tool ist. Das Internet Explorer Compatibility Test Tool protokolliert Informationen über Browser-Sitzungen im Internet Explorer. (in Englisch)

ASP.NET Webforms Anwendungen und Ajax (Teil 2) Client Callbacks

05.02.2010 01:20:23 | Andre Kraemer

In meinem letzten Blog Eintrag habe ich erklärt, wie Ajax von Hand mit Hilfe des XMLHttpRequest Objekts implementiert werden kann.

Eine Alternative zu dieser händischen Implementierung ist die Nutzung des ASP.NET Client Callback Frameworks, welches mit der Version 2.0 von ASP.NET erschien.

Um Client Callbacks nutzen zu können muss eine ASP.NET Seite bzw. ein ASP.NET Control das Interface ICallbackEventHandler implementieren. Das Interface definiert die beiden Methoden:

RaiseCallbackEvent ist die Methode, den Aufruf des Clients entgegen nimmt. GetCallbackResult gibt das Ergebnis der serverseitigen Verarbeitung an den Client zurück.

Startet der Client eine Anfrage an eine Seite / ein Control welches ICallBackEventHandler implementiert, wird eine reduzierte Variante des ASP.NET Page Lifecycle / ASP.NET Control Lifecycle ausgeführt. Im wesentlichen entspricht die Callback Variante der "klassichen" Postback Variante, es fehlen jedoch die Methoden, die sich um das Rendering des Outputs kümmern. Außerdem werden keine Postback Events ausgeführt.

Das ganze sieht bezogen auf die Phasen also ungefähr so aus:

04lifecycle

Los gehts

Sehen wir uns das ganze nun einmal an einem konkreten Beispiel an. Als Ausgangsbasis soll eine modifizierte Kopie der Seite des letzten Beispiels mit folgendem Markup dienen:

    1     <div>

    2         <p>

    3             <ahref="#">Hier klicken zum Request einer

    4                 statischen Datei </a>

    5             <br/>

    6             <ahref="#">Hier für Hello World WebService klicken </a>

    7             <br/>

    8             <ahref="#">Hierfür Echo WebService klicken. Geben Sie bitte vorher eine Zahl in nebenstehendem Feld ein: </a>&nbsp;

    9             < asp : TextBox ID ="TextBox1" runat ="server" Width ="40px">4711</asp:TextBox>

   10         </p>

   11     </div>

   12     <divid="content">

   13         Bitte klicken Sie auf einen der Links, damit dieser Bereich gefüllt wird.

   14     </div>

 

Der Server

Auf Serverseite müssen wir nun in unserer Seite das Interface ICallbackEventHandler implementieren. Ausgehend von unserem Markup gilt es drei Operationen zu unterstützen:

  • Zurückgeben des Inhalts einer statischen Datei
  • Aufruf einer parameterlosen Methode eines Webservices, die "Hello World" zurück gibt
  • Aufruf einer Methode Echo eines Webservices, welche einen numerischen Wert entgegen nimmt und einen String zurück gibt.

Welche Operation auszuführen ist, unterscheiden wir anhand des einzigen Arguments der Methode RaiseCallbackEvent: eventArgument.

    1 publicpartialclassTeil2 : Page, ICallbackEventHandler

    2 {

    3     privatestring callbackResult;

    4 

    5     publicvoid RaiseCallbackEvent(string eventArgument)

    6     {

    7         switch (eventArgument)

    8         {

    9             case"static":

   10                 this.ReadStaticFile();

   11                 break;

   12             case"HelloWorld":

   13                 this.CallHelloWorldService();

   14                 break;

   15             case"Echo":

   16                 this.CallEchoService();

   17                 break;

   18             default:

   19                 this.ReturnUnknownOperationError();

   20                 break;

   21         }

   22     }

   23 

   24     publicstring GetCallbackResult()

   25     {

   26         returnthis.callbackResult;

   27     }

Je nach Wert des Arguments eventArgument wird eine andere Methode zur weiteren Verarbeitung aufgerufen. Jede dieser Methoden schreibt ihr Ergebnis wiederum in das Feld callbackResult. Dieses wird wiederum als Ergebnis der Methode GetCallbackResult an den Client zurück gegeben.

Der Inhalt der verarbeitenden Methoden sieht wie folgt aus:

Auslesen der statischen Datei:

    1 privatevoid ReadStaticFile()

    2 {

    3     using (var reader = newStreamReader(Server.MapPath("~/static.html")))

    4     {

    5         this.callbackResult = reader.ReadToEnd();

    6     }

    7 }

Aufruf der Methode HelloWorld des Webservices:

    1 privatevoid CallHelloWorldService()

    2 {

    3     this.callbackResult = newAjaxDemoService().HelloWorld();

    4 }

Aufruf der Methode Echo des Webservices:

    1 privatevoid CallEchoService()

    2 {

    3     int value;

    4     int.TryParse(this.TextBox1.Text, out value);

    5     this.callbackResult = newAjaxDemoService().Echo(value);

    6 }

Wie man beim Aufruf der Webservice Methoden sieht, geschieht dieser Aufruf nun vom Server aus und nicht vom Client. Dadurch dass im Gegensatz zum vorherigen Beispiel der Client nun nicht mehr direkt den Service ruft, musste ich mir einen Proxy auf Serverseite erstellen.

Schön, aber wie komme ich nun auf den Server?

Bisher haben wir zwar geklärt, was auf dem Server alles geschehen muss, damit Client Callbacks funktionieren, offen ist allerdings noch, wie man überhaupt vom Client auf den Server kommt.

Der Aufruf des Servers geschieht über die JavaScript Funktion WebForm_DoCallback. Einen entsprechenden Aufruf der Methode kann man sich über den ClientScriptManager der Seite anhand der Methode GetCallbackEventReference erzeugen lassen. Zeile 5 des folgenden Listing demonstriert dies.

    1 protectedvoid Page_Load(object sender, EventArgs e)

    2 {

    3     var clientScript = Page.ClientScript;

    4     string callbackReference =

    5         clientScript.GetCallbackEventReference(this, "argument", "requestFinished", "context", true);

    6 

    7     string script = string.Format("function sendAjaxRequest(argument, context){{\n {0}; }}", callbackReference);

    8 

    9     if (!clientScript.IsClientScriptBlockRegistered("callback"))

   10     {

   11         clientScript.RegisterClientScriptBlock(this.GetType(), "callback", script, true);

   12     }

   13 }

Die Methode GetCallbackEventReference hat in der höchsten Überladung folgende Parameter:

  Parameter Bedeutung
control Servercontrol, dass den Callback behandelt.
argument Argument, das an die Methode RaiseCallbackEvent des behandelnden Controls geschickt wird.
clientCallback Name der Javascript Funktion, die die Rückgabe des Servers im Erfolgsfall behandelt.
context Javascsript Code, der ausgeführt wird, ehe die Anfrage an den Server geschickt wird. Achtung, hierbei handelt es sich nicht um einen JavaScript String, sondern um einen Befehl / eine Funktion
clientErrorCallback Name der Javascript Funktion, die die Rückgabe des Servers im Fehlerfall behandelt. In meinem Beispiel habe ich diesen Paramter nicht gesetzt.
useAsync Boolscher Wert, der angibt, ob die Anfrage asynchron (true) oder synchron (false) abgesetzt werden soll.

Der Einfachheit halber verpackt man den generierten Aufruf der Methode WebForm_DoCallback in eine eigene JavaScript Funktion, die nur noch die wirklichen variablen Parameter argument und context entgegen nimmt, wie in Zeile 7 geschehen. Anschließend registriert man wie in Zeile 9 - 11 noch einen ClientScriptBlock für diese Funktion, der wie folgt in die Seite gerendert wird.

    1 <scripttype="text/javascript">

    2     //<![CDATA[

    3     function sendAjaxRequest(argument, context) {

    4         WebForm_DoCallback('__Page', argument, requestFinished, context, null, true);

    5     } //]]>

    6 </script>

Die generierte Methode sendAjaxRequest kann man anschließend wie folgt aufrufen:

    1             <ahref="#"onclick="sendAjaxRequest('static', showMessage());">Hier klicken zum Request einer

    2                 statischen Datei </a>

    3             <br/>

    4             <ahref="#"onclick="sendAjaxRequest('HelloWorld', '');">Hier

    5                 für Hello World WebService klicken </a>

    6             <br/>

    7             <ahref="#"onclick="sendAjaxRequest('Echo', null);">Hier

    8                 für Echo WebService klicken. Geben Sie bitte vorher eine Zahl in

    9             nebenstehendem Feld ein: </a>

Zeile 1 zeigt, wie der Parameter context genutzt wird. Ich übergebe einfach die JavaScript Funktion showMessage als Argument. Diese wird nun automatisch aufgerufen, ehe der Request gestartet wird. Dies ist zum Beispiel bei länger dauernden Ajax Aufrufen sinnvoll, bei denen man dem Benutzer einen Hinweis anzeigen möchte, wie folgendes Listing zeigt:

    1 <scripttype="text/javascript">

    2     function showMessage() {

    3         var contentDiv = document.getElementById('content');

    4         contentDiv.innerHTML = 'Lade...';

    5     }

    6 </script>

Wichtig ist, dass der Parameter keinen String entgegen nimmt (wie leider in vielen Beispielen fälschlicherweise gezeigt), sondern eine JavaScript Funktion!

Eigentlich Interessant für unser Beispiel ist jedoch nicht der Parameter context, sonder der Parameter argument. Der Inhalt dieses Parameters (und nur dieser!) wird an die Methode RaiseCallbackEvent des Servers übergeben. Er steuert somit die auszuführende Funktionalität.

Alles beim Alten?

Spielt man nun ein wenig mit der vorgestellten Lösung herum, bemerkt man schnell, dass der Aufruf der Methode Echo stets ausgibt, das man 4711 eingegeben hat - auch wenn der Wert der Textbox zwischenzeitlich geändert wurde.

Ursache hierfür ist, dass ASP.NET Client Callbacks für alle Formularfelder stets die initialen Werte zurücksendet.

Screenshot der Beispielanwendung

Abhilfe schafft folgender JavaScript Code:

    1 __theFormPostData = '';

    2 WebForm_InitCallback();

Diesen packt man einfach in eine JavaScript Funktion, z. B. mit dem Namen repostForm.

Gibt man diese nun als context während des Aufrufs an:

    1 <ahref="#"onclick="sendAjaxRequest('Echo', repostForm());">Hier [...]

werden auch die geänderten Eingaben des Benutzers übertragen.

Screenshot zeigt dass die geänderten Werte übertragen wurden

Fazit

ASP.NET Client Callbacks sind eine schnelle und einfache Lösung um Ajax Funktionalitäten unter ASP.NET ab der Version 2.0 zu implementieren.

Bei aller Einfachheit sollte man jedoch beachten, dass diese Lösung auch einige Schwächen hat:

  1. Auf dem Server wird fast der komplette Page Lifecycle ausgeführt. Daher sollten Codebestandteile, die bei einem Callback nicht zwingend ausgeführt werden müssen immer durch ein if(!Page.IsCallback) ... geklammert werden, um unnötige Wartezeiten zu verhindern.
  2. Bei jedem Callback wird der komplette Viewstate zum Server übertragen. Gerade bei großem Viewstate und schlechter Internetanbindung verlangsamt dieser Umstand die Ajax Anfrage enorm.
  3. Es kann immer nur ein Argument an den Server übergeben werden. Möchte man mehr als eins übergeben, muss man die Werte durch ein Trennzeichen trennen und auf der Serverseite auseinanderpflücken
  4. Das übergebene Argument wird nicht wieder vom Server auf den Client zurück übertragen. Somit ist es in der verarbeitenden Javascript Funktion auf dem Client unmöglich herauszufinden, welche Operation ursprünglich gestartet wurde. Abhilfe schafft auch hier ein zusammengesetzter Rückgabewert, oder aber eine eigene verarbeitende Funktion je Operation.

Hat man diese Schwächen jedoch im Blick, lassen sich mit ASP.NET Client Callbacks wunderbare Ajax Applikationen implementieren.

Unter der Haube arbeiten diese Client Callbacks übrigens genauso wie das händische Beispiel aus dem letzten Blogpost - nämlich mit dem XMLHttpRequest Objekt:

Screenshot des JavaScript Debuggers, zeigt Zugriff auf XMLHttpRequest Objekt



blog.codemurai.de © André Krämer |Impressum | Abonieren

VSOne : Agile Development mit Team Foundation Server 2010

04.02.2010 15:28:03 | Christian Binder

Eigentlich hatte ich am Do dem 25.2 von 16:25 - 17:25 eine reine Developer Session auf der VSOne geplant, da aber Neno kurz vorher eine ähnliche Session macht 13:45 - 14:45 Debugging & Fehlersuche mit Visual Studio 2010, habe ich mich kurzfristig entschieden ein anderes Thema aufzugreifen: 

Agile Development mit Team Foundation Server 2010

Agile Entwicklungsprozesse und Praktiken erfreuen zunehmender Beliebtheit. Vor allem Projekte, die sich durch häufige Änderungen und meinst anfänglich ungenaue Anforderungen kennzeichnen,  profitieren durch diese Methodologie. Im Focus stehen einführend grundlegende Agile Mechanismen am Beispiel von SCRUM und deren Umsetzung im TFS 2010. Hierbei werden unter anderem die neuen Agile Workbooks, als auch das neue Konzept der Workitem Links vorgestellt. Die Session richtet sich vor allem an Einsteiger, die gerne das Thema Agile Prozesse für sich unter die Lupe nehmen wollen, als auch an Alle, die sich für die Neuerungen im TFS 2010 interessieren.

Viel Spass

Chris

Windows 7 – Multitouch

04.02.2010 15:25:25 | Oliver Scheer

Microsoft Surface

Heute habe ich mir für das Video des Tages Unterstützung von unserem User Experience-Evangelisten Clemens Lutsch geholt. Er ist ein Experte auf dem Gebiet der neuartigen Benutzeroberflächen. Er befasst sich seit der ersten Stunde mit Microsoft Surface, einem Tisch, der über eine Oberfläche bzw. eine Tischplatte verfügt, mit der man sämtliche Interaktionen steuern kann. Die gesamte Interaktion wird über grafische Elemente, Bluetooth-fähige Geräte oder aber mit den Händen vorgenommen. Spannend dabei ist, dass man gleichzeitig mit nahezu beliebig vielen Händen und Fingern mit dem Tisch interagieren kann. Ein einfaches Beispiel ist die zeitgleiche Betrachtung von Bildern durch verschiedene Benutzer. Jeder kann Bilder auf dem Tisch ansehen, heranziehen, vergrößern, drehen und sortieren. Im Prinzip fast genauso, wie man es von herkömmlichen Fotoabenden mit Familie und Freunden gewohnt ist. Aber haben sie schon mal versucht ein klassisches Foto auf dem Tisch zu vergrößern, um die Details genauer zu betrachten? Ja, so etwas funktioniert nur mit dem Surface.

surface

Ganz ehrlich, der Surface ist wegen der integrierten Hardware und der enorm wuchtigen Tischplatte, nicht ganz preiswert und derzeit nur über Microsoft direkt zu beziehen – beim Multimedia-Fachhändler um die Ecke steht er also noch nicht zur Verfügung. Allerdings kann ich jedem empfehlen, mal in den O2-Flagship-Store in Köln zu gehen, dort haben Partner von Microsoft eine Lösung für O2 erstellt, die echt „Wow“ ist.

Was hat Surface mit Windows 7 gemeinsam?

Während der Entwicklung von Windows 7 hat man sehr eng mit dem Surface-Team zusammengearbeitet und dieses Know-How in das neue Betriebssystem einfliessen lassen. Das große Geheimnis von Surface ist eigentlich, dass das darunterliegende Betriebssystem „nur“ Windows Vista Business ist, angereichert mit einigen Kameras für die Erkennung der Finger, Hände oder sonstigen Eingabegeräte. Zusätzlich gibt es noch diverse Treiber für die Eingabe sowie Software, die die Oberfläche von Surface ausmacht. Diese Software ist, etwas einfach formuliert, nur WPF (Windows Presentation Foundation) mit speziellen Steuerelementen. Für den „normalen“ Entwickler heißt das, er kann eigentlich sofort für Surface programmieren. Die Entwicklungswerkzeuge sind die gleichen, wie für Silverlight und WPF, nämlich Expression Studio und/oder Visual Studio.

In Windows 7 ist die Möglichkeit eingeflossen, den Computer über den Bildschirm mit Hilfe von Fingern zu steuern. Es gibt bereits eine Vielzahl von Computern und Notebooks, die sich mit einem Finger steuern lassen. Darüber hinaus gibt es derzeit schon eine überschaubare Anzahl von Computern, die sich schon mit zwei oder mehreren Fingern gleichzeitig steuern lassen. Wieviele gleichzeitige Eingaben unterstützt werden, ist von der Display-Hardware und damit vom Hersteller direkt abhängig.

Was hat man unter Windows 7 von Multitouch?

Eine nette Anekdote zum Thema Multitouch: Die Steuerelemente auf der Taskleiste sind wesentlich größer geworden. Der Grund dafür liegt in der natürlichen Beschaffenheit von menschlichen Fingern. Haben SIe schon einmal probiert, die kleinen Symbole der Windows Vista- oder Windows XP-Oberfläche in der Taskleiste mit dem Finger präzise zu treffen? Selbst mit einem Stift (von Tablet PCs) ist das eher ein Geschicklichkeitsspiel als ein präzises Arbeiten. Jetzt lassen sich die neuen Steuerelemente auch einfach mit dem Finger treffen und steuern.

Anwendungen, die die Basisfunktionen aus dem Betriebssystem unterstützen, wie z.B. das Vergrößern und Verkleinern, sind bereits sehr gut für Mutlitouch ausgelegt. Durch das auseinanderziehen zweier Fingern kann man beliebige Dokumente, die diese Funktion unterstützen, vergrößern oder verkleinern. Hinzu kommt die Fähigkeit der Anwendungen, natürliches Feedback zu geben, gelangt man z.B. an das Ende eines Dokumentes, so „bounced“ dieses (Bouncen heißt so viel wie „kurz über das Ziel hinausfahren und wieder zurückzukommen“). Damit erhält der Benutzer tatsächlich das Gefühl von „Ich bin am Ende des Dokumentes angekommen“. Aber auch die Docking-Funktionen von Windows sind hervoragend auf Multitouch eingestellt: bewegt man ein Fenster mit dem Finger an eine Bildschirmseite, so dockt es dort automatisch an.

Eine andere Anekdote ist, dass sich die Open Source Gemeinde um einen Browser damit rühmt, jetzt auch Multitouch unter Windows 7 zu unterstützen. Leider haben die Kollegen nicht mitbekommen, dass das ein fester Bestandteil von Windows 7 ist und sofort „ohne Code“ von jeder Anwendung automatisch verwendet werden kann.

Es gibt bereits eine Vielzahl von Anwendungen, die Multitouch direkt verwenden. Microsoft selbst liefert ein Beispielpaket aus, das Multitouch Pack, das aus einigen Spielen, Visualisierungsdemonstrationen und Surface Globe besteht. So kann man mit dem Surface Globe sehr leicht die Welt mit den eigenen Fingern erkunden.

image

Anwender ohne ein Multitouch-fähiges Gerät müssen aber nicht zurückstecken, die Anwendungen lassen sich zumindest starten und größtenteils auch mit der Maus steuern, wenn auch nicht ganz so komfortabel.

image


Wie kann man nun eigene Multitouch-fähigen Anwendungen entwickeln?

Auf MSDN-Online gibt es dazu einen sehr guten Webcast.

In diesem Webcast zeigt Ihnen Dariusz Parys, wie Sie Anwendungen für Windows 7 multi-touch-fähig machen. Unter anderem erfahren Sie, wie man einen Emulator installiert, um Multi-Touch zu simulieren, welche Gesten standardmäßig in Windows 7 unterstützt werden und wie man eine WPF-Anwendung um Multi-Touch-Funktionalität erweitert.

Link zum Webcast

Weitere technische Dokumentation zur Multitouch-API gibt es hier:

Yochay Kriaty – Multitouch-Funktionen in Windows 7

Windows 7 – Eigene Explorer basierende Anwendungen entwickeln

04.02.2010 15:11:18 | Oliver Scheer

Heute kommen die Fans des Windows Explorer voll auf ihre Kosten. Er verfügt im Prinzip über alle wichtigen Funktionen, die man für die Navigation durch Ordner, Netze, Dateien, Bibliotheken und Suchen benötigt. Der Windows Explorer ist das Ergebnis jahrelanger Entwicklungsarbeit und spiegelt dabei die Implementierung vieler Bedürfnisse des Standardbenutzers wieder. Wer dennoch Funktionen braucht, die nicht enthalten sind, oder diese gerne auf andere Art und Weise implementieren möchte, darf dies gerne tun.

Die Funktionen des Windows Explorer stehen jedem Entwickler frei zur Verfügung. Dank des Windows API Code Packs lässt sich der Explorer in Windows Forms- oder Windows Presentation Foundation-Anwendungen integrieren.

Die Funktionen und die Visualisierung steht in Form von Steuerelementen direkt in Visual Studio zur Verfügung. Der Name der Steuerelemente ist sowohl in Windows Forms als auch in WPF ExplorerBrowser.

clip_image002

Die Konfiguration ist ebenfalls sehr leicht über das Eigenschaften-Fenster möglich.

Zwei Referenzimplementierungen sind direkt im Windows API Code Pack enthalten. Sie demonstrieren einfach und kompakt die volle Leistungsfähigkeit und sehen dabei sehr technisch aus. Meine Bitte an Sie, bitte bauen sie so etwas nicht, sondern machen sie es dem Benutzer leicht. J

clip_image004

Die WPF-Variante zum Testen der ExplorerBrowser-Funktionen.

clip_image006

Die Windows Forms-Variante zum Testen.

Windows 7 – Suchen über die Windows Shell

04.02.2010 15:01:09 | Oliver Scheer

Ein altes Sprichwort sagt: „Wer suchet, der findet.“. Warum lassen wir nicht unsere eigenen Anwendungen suchen? Windows 7 liefert die notwendige Search API dafür mit.

Um die Search API aus .NET-Code ansprechen zu können, ist wirklich nicht viel nötig. Man muss lediglich das Windows API Code Pack einbinden und schon kann in wenigen Zeilen der eigene Suchclient entwickelt werden.

Was man sucht und vor allem wo man sucht, ist jedem Entwickler selbst überlassen. Die Qualität der Suche hängt aber wesentlich von diversen Kriterien ab: So ist es ziemlich sinnlos nach Liedern ihrer Lieblingsband im System-Ordner von Windows zu suchen. Und Bilder vom letzten Firmenfest werden sie nicht in ihren Musikordnern finden. Es sei denn, sie haben eine sehr interessanten Organisationsstil.

Aus gutem Grund bietet die API daher auch die nötigen Konfigurationswerkzeuge für die Suche an. In welchen Typen von Ordner soll gesucht werden? Was für Daten suchen wir? Sollen alle Suchbegriffe oder zumindest ein Suchbegriff im Dokument gefunden werden? Handelt es sich um aktuelle Daten oder vor langer Zeit angelegte Dokumente?

Eine eigene Suchanwendung ist sehr schnell implementiert. Dafür sind lediglich zwei Bibliotheken aus dem Windows API Code Pack notwendig:

image

Die Methode zum Suchen:

private void StartSearch(string searchText)
{
// Erzeuge Suchbedingungen
SearchCondition searchCondition =
GetSearchCondition(searchText);
// Datum als weiteres Suchkriterium hinzufügen
SearchCondition dateCondition =
SearchConditionFactory.CreateLeafCondition(
SystemProperties.System.Title,
searchText,
SearchConditionOperation.ValueContains);
// Zusammensetzen der Suchbedingungen
SearchCondition finalSearchCondition =
SearchConditionFactory.CreateAndOrCondition(
SearchConditionType.Or,
false,
searchCondition,
dateCondition);

// Erzeuge einen ShellSearchFolder
ShellSearchFolder searchFolder;
if (ShellLibrary.IsPlatformSupported)
{
searchFolder = new ShellSearchFolder(
finalSearchCondition,
(ShellContainer)KnownFolders.DocumentsLibrary,
(ShellContainer)KnownFolders.PicturesLibrary,
(ShellContainer)KnownFolders.VideosLibrary);
}
else
{
searchFolder = new ShellSearchFolder(
finalSearchCondition,
(ShellContainer)KnownFolders.Documents,
(ShellContainer)KnownFolders.Pictures,
(ShellContainer)KnownFolders.Videos);
}

// DataList die die Ergebnisse anzeigt
_result.ItemsSource = searchFolder;
}

Die Methode GetSearchCondition ist folgendermaßen implementiert:

private SearchCondition GetSearchCondition(string searchText)
{
// Einzelne Suchbegriffe aus dem Textbilden
string[] words = searchText.Split(' ');
// Das Suchergebnis ist erstmal leer
SearchCondition combinedPropertyCondition = null;
// Für jedes Word im Suchtext eine Suchbedingung erzeugen
foreach (string word in words)
{
// Erste Suchbedingung --> Suche nach Dateinamen
SearchCondition propertyCondition1 =
SearchConditionFactory.CreateLeafCondition(
SystemProperties.System.FileName,
word,
SearchConditionOperation.ValueContains);
// Zweite Suchbedingung --> Suche nache Keywords/Tags in Datei
SearchCondition propertyCondition2 =
SearchConditionFactory.CreateLeafCondition(
SystemProperties.System.Keywords,
word,
SearchConditionOperation.ValueContains);
// Wir wollen eine Oder-Bedingung für Tags oder Dateiname
SearchCondition tmpCombinedCondition =
SearchConditionFactory.CreateAndOrCondition(
SearchConditionType.Or,
false,
propertyCondition1,
propertyCondition2);

// Falls es bereits eine Suchbedingung gibt,

// verknüpfe die neue und die alten mit AND
if (combinedPropertyCondition != null)
{
combinedPropertyCondition =
SearchConditionFactory.CreateAndOrCondition(
SearchConditionType.And,
false,
combinedPropertyCondition,
tmpCombinedCondition);
}
else
{
combinedPropertyCondition = tmpCombinedCondition;
}
}
return combinedPropertyCondition;
}

Die Suche an sich wird über die Klasse ShellSearchFolder ausgeführt. Die Definition der Suchanfrage erfolgt über die SearchConditions. Welche Ordner durchsucht werden sollen, wird mit Hilfe von „KnownFolders“, so genannten bekannten Ordner definiert.

searchFolder = new ShellSearchFolder(
finalSearchCondition,
(ShellContainer)KnownFolders.DocumentsLibrary,
(ShellContainer)KnownFolders.PicturesLibrary,
(ShellContainer)KnownFolders.VideosLibrary);

Das Suchergebnis kann man nun visualisieren wie man möchte. Ich habe mich in diesem Beispiel auf eine einfache Liste beschränkt. Im Windows API Code Pack steht dazu eine vollwertige WPF-Visualisierung zur Verfügung.

Windows 7 – Restart- und Recovery-API

04.02.2010 14:58:37 | Oliver Scheer

Meine Programme stürzen nicht ab! Nein ganz bestimmt nicht! Versprochen! Großes Indianer-Ehrenwort!

Aber falls es doch mal passiert, dass eine Anwendung „abstürzt“, bzw. einfach nicht das tut, was man von ihr erwartet, dann kann man das jetzt stilvoll und mit einem automatischen Neustart der Anwendung geschehen lassen. Hierbei hilft die Restart-And-Recovery-API, die bereits in Windows Vista eingeführt und nun in Windows 7 erweitert wurde.

Jeder von uns war bestimmt schon einmal in der Situation, dass er lange an einem Dokument gearbeitet hat bis die Anwendung plötzlich einfach abgestürzt ist. Die Anwendung reagiert einfach nicht mehr und alle Daten sind verloren. Vielleicht haben sie es auch schon einmal gesehen, dass einige Anwendungen nach einem Absturz anbieten, direkt wieder neu zu starten. Und im Startvorgang werden dann die verloren geglaubten Daten wiederhergestellt. Benutzer solcher Anwendungen können sich glücklich schätzen.

clip_image002

Die Anwendung läuft noch ….

clip_image004

Ups, die Anwendung funktioniert nicht mehr.

clip_image006

Und startet sich von selbst neu.

clip_image008

Eine quasi sich selbst regenerierende Anwendung kann jeder mit Hilfe der Restart-And-Recovery-API erstellen. Es sind nur wenige Schritte dazu notwendig:

Schritt 1: Registrieren der Anwendung für einen Restart

private void RegisterForRestart()
{
ApplicationRestartRecoveryManager.RegisterForApplicationRestart(
new RestartSettings("/restart",
RestartRestrictions.NotOnReboot | RestartRestrictions.NotOnPatch));
}

Schritt 2: Registrieren der Anwendung für die Wiederherstellung von Daten

private void RegisterForRecovery()
{
RecoveryData data = new RecoveryData(new RecoveryCallback(RecoveryProcedure), null);
RecoverySettings settings = new RecoverySettings(data, 0);
ApplicationRestartRecoveryManager.RegisterForApplicationRecovery(settings);
}

Schritt 3: Implementieren der Recovery-Methode

private int RecoveryProcedure(object state)
{
PingSystem();

File.WriteAllText(RecoveryFile, string.Format("{1}{0}{2}{0}{3}", DataSeparatorString, CurrentFile.Filename, CurrentFile.IsDirty, CurrentFile.Contents));

Debug.WriteLine("File path: " + RecoveryFile);
Debug.WriteLine("File exists: " + File.Exists(RecoveryFile));
Debug.WriteLine("Application shutting down...");

ApplicationRestartRecoveryManager.ApplicationRecoveryFinished(true);
return 0;
}

Schritt 4: Prüfen, ob der Benutzer den Restart abgebrochen hat

private void PingSystem()
{
// Find out if the user canceled recovery.
bool isCanceled = ApplicationRestartRecoveryManager.ApplicationRecoveryInProgress();

if (isCanceled)
{
Console.WriteLine("Recovery has been canceled by user.");
Environment.Exit(2);
}

}

Schritt 5: Daten beim Neustart wiederherstellen

private void RecoverLastSession(string command)
{
if (!File.Exists(RecoveryFile))
{
MessageBox.Show(this, string.Format("Recovery file {0} does not exist", RecoveryFile));
internalLoad = true;
textBox1.Text = "Could not recover the data. Recovery data file does not exist";
internalLoad = false;
UpdateAppTitle();
return;
}

// Perform application state restoration actions here.
string contents = File.ReadAllText(RecoveryFile);
CurrentFile.Filename = contents.Remove(contents.IndexOf(Form1.DataSeparatorString));
contents = contents.Remove(0, contents.IndexOf(Form1.DataSeparatorString) +
Form1.DataSeparatorString.Length);
CurrentFile.IsDirty = contents.Remove(contents.IndexOf(Form1.DataSeparatorString)) == "True" ? true : false;
contents = contents.Remove(0, contents.IndexOf(Form1.DataSeparatorString) + Form1.DataSeparatorString.Length);
CurrentFile.Contents = contents;

// Load our textbox
textBox1.Text = CurrentFile.Contents;

// Update the title
UpdateAppTitle();

// Reset our variable so next title updates we don't show the "recovered" text
recovered = false;
}

Schritt 0: Die eigentliche Anwendung

public Form1()
{
Debug.WriteLine("ARR: Demo started");
InitializeComponent();
UpdateAppTitle();
RegisterForRestart();
RegisterForRecovery();

if (System.Environment.GetCommandLineArgs().Length > 1 && System.Environment.GetCommandLineArgs()[1] == "/restart")
{
RecoverLastSession(System.Environment.GetCommandLineArgs()[1]);
}
}

Das vollständige Codebeispiel befindet sich im Windows API Code Pack.

Windows 7 – Entwickeln mit und für Sensoren

04.02.2010 14:56:42 | Oliver Scheer

Was ist die Windows 7 Sensor API?

Die Windows 7 Sensor API ist eine neue Programmierschnittstelle für die Steuerung von Sensoren. Bei Sensoren kann es sich um interne und externe Erweiterungen des PCs handeln, die dem Computer Informationen über „äußere“ Zustände vermitteln. Die häufigsten Einsatzszenarien sind derzeit die Erkennung der Umgebungshelligkeit, der Beschleunigung des PCs selbst oder des angeschlossenen Sensors. Darüber hinaus kann man Software-Sensoren erstellen, die bestimmte Werte ermitteln und an die API übergeben und damit unseren Anwendungen bereitstellen.

Was kann man tun, wenn man keine Sensoren installiert hat?

Man muss sich nicht unbedingt einen neuen Rechner mit Sensorhardware kaufen, denn es gibt durchaus Alternativen. Das Windows 7 SDK bringt zum Beispiel einen Sensor für Licht mit. Es handelt es sich um einen Lichtsensor-Emulator, den der User über einen einfachen Schieberegler steuern kann.

Um den Treiber dafür erfolgreich im System zu installieren, muss man wie folgt vorgehen:

  1. Eine Kommandozeile mit administrativen Rechten starten (cmd.exe mit „Run as“-Option)
  2. Wechseln in den Windows SDK Bin-Ordner
  3. Eingabe von pnputil -a VirtualLightSensorDriver.inf
  4. Bei einer Nachfrage, ob der Treiber wirklich installiert werden soll, mit Ja antworten
  5. Warten bis die Meldung erscheint, dass der Treiber erfolgreich installiert wurde

Ausführen des virtuellen Lichtsensors

  1. Starten der Anwendung “VirtualLightSensor.exe” aus dem Windows SDK Bin-Ordner
  2. Bestätigen, dass der Sensor gestartet werden soll
  3. Einen Moment lang wird die Meldung „Waiting“ angezeigt. Der virtuelle Lichtssensor wird in diesem Moment als „Gerät“ installiert. Anschließend kann der Schieberegler verwendet werden, um die Lichtstärke in Lux zu simulieren

clip_image002

Programmieren mit Sensor API

Die Funktionen, um auf die Sensoren im Computer zugreifen zu können, sind über die SensorManager-Klasse erreichbar. Sie ist Bestandteil des Windows API Code Pack und kann über die darin enthaltene Bibliothek „Sensors“ eingebunden werden.

Um generell erkennen zu können, ob sich an den Sensoren etwas ändert (Aktivierung und Deaktivierung), reicht das Ereignis SensorsChanged. Um zu erkennen, welche Sensoren im System enthalten sind, kann die Methode GetAllSensors verwendet werden. Diese liefert alle Sensoren zurück, die im System derzeit aktiv sind. Jedes zurückgelieferte Objekt ist von der Klasse Sensor abgeleitet.

private void InitSensors()
{
SensorManager.SensorsChanged += new SensorsChangedEventHandler(SensorManager_SensorsChanged);

foreach (var sensor in SensorManager.GetAllSensors())
{
sensor.DataReportChanged += new DataReportChangedEventHandler(sensor_DataReportChanged);
sensor.StateChanged += new StateChangedEventHandler(sensor_StateChanged);
Debug.WriteLine(sensor.FriendlyName);
}
}

Um mit einem Lichtsensor zu arbeiten, kann man den AmbientLightSensor verwenden. Dieser verfügt über die Eigenschaft CurrentLuminousIntensity, welche die Intensität in Lux zurückliefert. Darüber kann erkannt werden, ob das aktuelle Umgebungslicht hell oder dunkel ist. Das macht besonders dann Sinn, wenn man in wechselnden Umgebungen arbeitet, wie z.B. im ICE (Tunnel, Sonnenlicht, Bahnhof, usw.). Einige Notebookhersteller haben dafür schon Sensoren im Rechner eingebaut und regeln so die Helligkeit des Bildschirms.

SensorList<AmbientLightSensor> alsList = SensorManager.GetSensorsByTypeId<AmbientLightSensor>( );
int ambientLightSensors = 0;

foreach( AmbientLightSensor sensor in alsList )
{
// set intial progress bar value
sensor.TryUpdateData( );
float current = sensor.CurrentLuminousIntensity.Intensity;
pb.Value = Math.Min( (int)current, maxIntensity );

// Set up automatc data report handling.
sensor.AutoUpdateDataReport = true;
sensor.DataReportChanged += new DataReportChangedEventHandler( DataReportChanged );
ambientLightSensors++;
}

if( ambientLightSensors == 0 )
{
// No Sensor found
}
}
catch( SensorPlatformException exc)
{
// This exception will also be hit in the Shown message handler.
}

Das Ereignis DataReportChanged wird immer dann ausgelöst, wenn sich am Sensor etwas verändert. Das geschieht asynchron als Hintergrundprozess und muss daher bei Interaktion mit dem UI-Thread wieder mit diesem synchronisiert werden. Die Umsetzung lässt sich sehr einfach mit der folgenden Ereignisbehandlung realisieren:

void DataReportChanged( Sensor sender, EventArgs e )
{
AmbientLightSensor als = sender as AmbientLightSensor;
BeginInvoke( new MethodInvoker( delegate
{
float current = als.CurrentLuminousIntensity.Intensity;
} ) );
}

Arbeiten mit Bewegungs- bzw. Beschleunigungssensoren

Inzwischen gibt es auch immer mehr Hardware mit so genannten Bewegungssensoren. Diese erkennen Beschleunigung in den drei Bewegungsachsen. Dadurch ergeben sich ganz neue Möglichkeiten der Steuerung.

Ich selbst habe ein externes Sensorboard der Firma Freescale zu Testzwecken an meinem Rechner. Damit verfügt man quasi über einen Joystick, der eine dreidimensionale Steuerung erlaubt.

Um diesen Sensor anzusprechen, benötigt nicht viel mehr Code als für Lichtsensoren.

Das Auslesen der Daten geschieht ebenfalls im DataReportChanged-Ereignis der SensorManager-Klasse:

void sensor_DataReportChanged(Sensor sender, EventArgs e)
{
Debug.WriteLine(sender.FriendlyName);
if (sender is Accelerometer3D)
{
Dispatcher.BeginInvoke(new Action(delegate
{
Accelerometer3D accel = sender as Accelerometer3D;
MoveBall(accel.CurrentAcceleration[AccelerationAxis.X],
accel.CurrentAcceleration[AccelerationAxis.Y],
accel.CurrentAcceleration[AccelerationAxis.Z]);
}));
}
}

Die Methode MoveBall macht nichts anderes als einen Ball um die übergebenen X-,Y- und Z-Koordinaten zu verschieben.

Ein schönes Beispiel ist im Windows API Code Pack enthalten. Dieses visualisiert die aktuelle Beschleunigung des Sensors in X-,Y- und Z-Richtung.

clip_image004

Windows 7 – Entwicklerresourcen

04.02.2010 14:53:58 | Oliver Scheer

Heute möchte ich eine kleine Zusammenfassung für Entwickler bereit stellen – für jeden der schnell und kompakt eine Übersicht über die vielen kostenfreien Angebote von Microsoft haben möchte.

Die folgenden Webseiten bieten kostenfreie Downloads oder Inhalte an, die von jedem genutzt werden dürfen, die sich gerne mit der Windows-Programmierung und im Besonderen mit Windows 7 befassen möchten.

MSDN Online –Microsoft Developer Network

Was kann man bei MSDN Online finden? Im Prinzip ist die Antwort einfach formuliert: Alles! Im Detail heißt das, dass es dort alles zu unseren Programmiersprachen (Visual Basic, Visual C++, Visual C#), unseren Werkzeugen für Entwickler (Visual Studio, Visual Studio Express, Visual Studio Team System) und unseren Betriebssystemen (Windows Client, Windows Server, Windows Mobile, Windows Embedded) zu finden gibt.

Neben Webcasts und Videos, die von Experten auf ihren Gebieten erstellt wurden, finden sich dort auch viele technische Artikel und Downloads. Man kann sich auf MSDN Online aber auch für Newsletter (http://www.microsoft.com/germany/msdn/flash/default.mspx) und RSS-Feeds (http://msdn.microsoft.com/de-de/bb821267.aspx) registrieren, die in regelmäßigen Abständen über aktuelle Themen informieren.

Außerdem findet man dort seit kurzem das sehr spannende und amüsante MSDN TV. Link: http://www.microsoft.com/germany/msdn/msdntv/default.mspx

Wer mehr über die MSDN Subscription erfahren möchte, ist dort ebenfalls hervorragend aufgehoben. Kurz formuliert handelt es sich dabei um ein Abonnement für sämtliche aktuellen und kommenden Microsoft-Produkte und -Technologien, die man uneingeschränkt als Entwickler für sich verwenden kann.
Link: http://msdn.microsoft.com/de-de/subscriptions/default.aspx

Link: http://www.msdn-online.de

Windows 7 Software Development Kit

Beim Microsoft® Windows® SDK handelt es sich um einen Satz von Tools, Codebeispielen, Dokumentationen, Compilern, Headern und Bibliotheken, mit denen Entwickler Anwendungen erstellen können, die unter Microsoft Windows-Betriebssystemen mit systemeigenen (Win32) oder verwalteten (.NET Framework) Programmiermodellen ausgeführt werden.

In den meisten Fällen sollten Sie die neueste Windows SDK-Version verwenden, die mehrere Windows-Betriebssysteme und .NET Framework-Versionen unterstützt

Link: http://msdn.microsoft.com/de-de/windows/bb980924.aspx

Blog des Windows SDK Teams: http://blogs.msdn.com/windowssdk/

Windows API Code Pack for Microsoft .NET Framework

Das Windows API Code Pack for Microsoft .NET Framework bietet eine Quellcodebibliothek an, die es ermöglicht, die neuen Windows 7 Funktionen in .NET-Anwendungen zu verwenden.

Link: http://code.msdn.microsoft.com/WindowsAPICodePack

Windows 7 Training Kit

Das Windows 7 Training Kit beinhaltet Präsentationen, Hands-on-labs und Demos, die dafür entwickelt wurden, die neuen Funktionen von Windows 7 verwenden zu können.

Link: http://www.microsoft.com/downloads/details.aspx?FamilyID=1C333F06-FADB-4D93-9C80-402621C600E7&displaylang=en

Gibt es weitere Quellen habe und die ich vergessen habe? Her damit

Windows 7 – Neun Dinge die jeder Entwickler über Windows 7 wissen sollte

04.02.2010 14:52:38 | Oliver Scheer

1. Windows 7 beinhaltet das .NET Framework 3.5 SP1

Das .NET Framework 3.5 SP1 ist in Windows 7 enthalten. Das sind gute Nachrichten:

  • Softwareverteilung: Für eine Clientanwendung heißt dies bei der Softwareverteilung, dass das .NET Framework schon auf Windows 7 Computern vorhanden ist und nicht zusätzlich installiert werden muss
  • Kompatibilität: Da Windows 7 mit dem .NET Framework 3.5 SP1 bereitgestellt wird, kann man sicher sein, dass sehr viele Integrationstests durchgeführt wurden, um das Funktionieren der .NET Runtime und Bibliotheken mit dem OS zu gewährleisten.

2. Visual Studio 2008 funktioniert problemlos mit Windows 7

Ich benutze Visual Studio 2008 zusammen mit Windows 7 auf meinen Notebook und meinem Entwicklungsdesktop und habe keinerlei Probleme. Wie gewohnt, kann man mit Visual Studio 2008 noch .NET 2.0, .NET 3.0 und .NET 3.5 SP1 Anwendungen für andere OS-Versionen, z.B. Windows XP oder Windows Vista, erstellen.

3. Man kann Anwendungen schreiben, die unter Windows XP bis Windows 7 laufen …

und die Features des Gast-Betriebssystems nutzen. Es gibt eine Beispielanwendung „PhotoView“, die demonstriert, wie man eine .NET-Anwendung schreibt, die von XP bis Windows 7 lauffähig ist und die Features der einzelnen Gast-Betriebssysteme optimal ausnutzt. Den Sourcecode und eine Beschreibung der Anwendung gibt’s unter –> http://code.msdn.microsoft.com/XP2Win7.

4. Man kann heute .NET-Anwendungen schreiben, welche die coolen Features von Windows 7 nutzen

In meinen letzten Blogeintrag habe ich die Windows 7 API Code Packs vorgestellt, mit denen man schon heute über Managed Code auf diese Features zugreifen kann –> http://blogs.msdn.com/mtcmuc/archive/2009/08/13/windows-7-codepack-v1-0-released.aspx.

Eine Reihe von weiteren Beispielen, wie man für Windows 7 entwickelt, gibt es auch im Microsoft Windows SDK for Windows 7 and .NET Framework 3.5 SP1 –> http://www.microsoft.com/downloads/details.aspx?FamilyID=c17ba869-9671-4330-a63e-1fd44e0e2505&displaylang=en

5. Powershell ist Bestandteil von Windows 7

Für komplexe administrative Scripts und der Verwendung von Powershell aus Anwendungen haraus ist die Powershell V2.0 Bestandteil von Windows 7.

6. Es gibt einen ausführlichen Windows 7 UX Guide

Als PDF-Download gibt es einen User Interface Design Guide zu Themen wie Bildschirmauflösungen, DPIs, Windows Sizing, Controlausrichtung und Control Spacing, u.v.a.m. –> http://download.microsoft.com/download/e/1/9/e191fd8c-bce8-4dba-a9d5-2d4e3f3ec1d3/ux%20guide.pdf

7. Freie Kapitel aus Windows 7-Büchern

Es gibt einige kostenfreie Kapitel aus den Büchern "Windows 7 Inside Out", "Windows 7 Resource Kit" und "Windows 7 for Developers" zum Download –> http://www.microsoft.com/learning/en/us/offers/windows-7-chapters-thankyou.aspx

8. Windows 7 Trainingskit für Entwickler

Wie in meinem Blogeintrag http://blogs.msdn.com/mtcmuc/archive/2009/07/08/schnelleinstieg-in-die-windows-7-entwicklung-mit-dem-windows-7-trainingskit.aspx berichtet, gibt es ein Windows 7 Training Kit für Entwickler. Dieses Kit liegt nun in Version 1.0.1 vor und kann unter –->
http://www.microsoft.com/downloads/thankyou.aspx?familyId=1c333f06-fadb-4d93-9c80-402621c600e7&displayLang=en heruntergeladen werden.

9. Deutsche Windows 7 Developer Tipps

Auf http://msdn.microsoft.com/de-de/windows/dd433113.aspx gibt es viele neue Artikel, HowTo Guides, die erste Schritte auf dem neuen Betriebssystem, aber auch komplexere Windows 7-Programmierthemen ansprechen.

Windows 7 – Multifunktionsleiste/Ribbon

04.02.2010 14:50:15 | Oliver Scheer

Die Multifunktionsleiste wurde neu in Windows 7 integriert und entspricht nahezu der Multifunktionsleiste von Office 2007. Nahezu bedeutet dabei, dass sie konsequent weiterentwickelt wurde.

Windows 7 und die Multifunktionsleiste

Die Multifunktionsleiste ist in einige Klassiker eingeflossen: Paint und WordPad. Schade ist, dass sie es nicht auch in Notepad geschafft hat.

image

image

Die Multifunktionsleiste ist ebenso in Windows Live Movie Maker integriert worden. Dieser läuft auch unter Windows Vista und zeigt, dass die Multifunktionsleiste auch auf Vista verfügbar sein wird.

Entwickeln mit der Multifunktionsleiste

Windows 7 führt ein neues natives API für Multifunktionsleisten-basierte Oberflächen ein. Dieses API ist COM-basiert. Das API wird in Zukunft auch für Windows Vista verfügbar sein und nahezu den gleichen Funktionsumfang wie die Office 2007-Multifunktionsleiste haben.

Um als Entwickler die Multifunktionsleiste verwenden zu können, benötigt man das Windows 7 SDK (Link). Im SDK finden Sie unter anderem die Header-Datei (UIRibbon.h), die den Zugriff auf die Multifunktionsleiste bietet.

Die Programmierung der Multifunktionsleiste teilt sich in zwei Bereiche auf: Im Deklarationsteil werden die verschiedenen Elemente, wie z.B. Tabreiter, Gruppierungen oder Kommandos, deklariert und ihr Aussehen beschrieben. Diese Beschreibung kann mit XAML (Extensible Markup Language) geschrieben werden. Die Ausführung der Kommandos und das Wechseln in verschiedene Zustände wird über C++-Code beschrieben, der die Darstellung mit der Anwendungslogik verknüpft, der eigentlichen Anwendungslogik.

image

Dadurch erhält man eine starke Separation in Model, Sicht und Controller, die den Code und das Markup entkoppelt. Die gesamte C++-API dazu ist sehr kompakt gehalten. Sie ist auf Kommandos fokussiert und nicht auf Steuerelemente oder Darstellungsdetails.

Welche Steuerelemente bringt die Multifunktionsleiste mit

Die Multifunktionsleiste verfügt über ein sehr großes Repertoire an Steuerelementen, die wir bereits aus Paint, WordPad und dem Windows Live Movie Maker her kennen.

image

Eine Funktion die nicht direkt in der Multifunktionsleiste integriert ist, sondern an beliebigen Stellen in der Anwendung verwendet werden kann, ist das erweiterte Kontextmenü. In WordPad erscheint dies leicht transparent, wenn man einen Text markiert. Darüber kann man dann zum Beispiel den selektierten Text formatieren. Diese Funktion erspart dem Benutzer, größere Strecken mit der Maus zurückzulegen und somit seinen aktuellen Fokus (den Text) zu verlassen.

image

image

image

image

image

image

image

image

image

image

image

image

image

image

image

Markup der Multifunktionsleiste

Der Markup-Code für die Multifunktionsleiste unterteilt sich in zwei Bereiche: Command-Sektion und Views-Sektion.

Die Command-Sektion beinhaltet die einzelnen Command-Elemente: einen Referenznamen, ein Label, eine eindeutige ID, ein Bild (BMP) und einen Tooltip.

<?xmlversion="1.0" encoding="utf-8"?>
<Applicationxmlns='http://schemas.microsoft.com/windows/2009/Scenic/Intent'>
<Application.Commands>
<CommandName='Home' LabelTitle='Home'/>
<CommandName='HomePage' LabelTitle='HomePage'>
<Command.LargeImages>
<ImageSource='res/HomePageHH.bmp'/>
</Command.LargeImages>
</Command>
</Application.Commands>

Die Views-Sektion legt die Organisation der Kommandos in Tabs, Gruppen, Quick Access-Toolbar und Anwendungsmenü fest. Sie bestimmt außerdem, welches Steuerelement für welches Kommando verantwortlich ist.

<Application.Views>
<Ribbon>
<Ribbon.Tabs>
<Tab CommandName='Home'>
<Group CommandName='GoHomePage' SizeDefinition='OneButton'>
<Button CommandName='HomePage'/>
</Group>
</Tab>
</Ribbon.Tabs>
</Ribbon>
</Application.Views>
</Application>

Die Multifunktionsleiste unterstützt zwei Arten von “Sichten”: die Multifunktionsleisten-Sicht und die kontextuelle UI-Sicht. Die kontextuelle UI-Sicht bietet ein reicheres Kontextsystem als bisherige Kontextmenüs.

Da es sich bei der Multifunktionsleiste um eine native API handelt, muss aus der XAML-Datei erst einmal eine native Ressource erstellt werden. Dies geschieht mit einem Tool aus dem Windows SDK: UICC.exe. Dieses generiert aus der XAML-Datei eine Ressource, die man wiederum in seine Anwendung einbinden kann und dadurch die Multifunktionsleiste als nativen Code vorliegen hat.

UICC.exe konvertiert XAML in ein binäroptimiertes Format und erstellt eine .rc-Datei, welche den binären “blob” mit den verwendeten Ressourcen enthält. Man sollte einen benutzerdefinierten Build-Step für die Erstellung der .rc-Datei mittels UICC.exe in sein Projekt einbauen, damit dieses automatisch während des Erstellens geschieht. Eine .h-Datei, die die #defines für die diversen Command-IDs enthält, wird ebenfalls generiert.

Anwendungsmodi

Durch Anwendugsmodi lässt sich die Darstellung von Elementen an den aktuellen Anwendungszustand koppeln, denn nicht immer soll alles sichtbar sein. In Microsoft Paint wird z.B. der Text-Tab nur angezeigt wenn man Text bearbeitet. Ansonsten wird diese Funktion nicht benötigt. Im Markup-Code definiert man die Anwendungsmodi, in denen die Elemente sichtbar sein sollen. Der Anwendungsmodus wird auf untergeordnete Steuerelemente automatisch vererbt.

<Button CommandName='Paste' ApplicationModes='1,3'/>

Im Code kann man den Modus durch die Funktion IUIFrameworkSetModes ändern.

Die API-Interfaces im Überblick

  • IUIFramework – initialisiert Multifunktionsleiste, lädt Markup-Resourcen, Get und Set für Command-Eigenschaften oder State, Set Application Modes.
  • IUIApplication–Ermittelt User Command-Handler für jedes Command, welches im Markup definiert wurde. Benachrichtigt über View-State-Änderungen.
  • IUICommandHandler –Behandelt Commands und Property-Updates (z.B. Aktivieren und Deaktivieren eines Commands, basierend auf der aktuellen Sicht) .

Codebeispiel: Initialisierung

IUIFramework* g_pFramework = NULL;
::CoCreateInstance(CLSID_UIMultifunktionsleisteFramework, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&g_pFramework));
CComObject<CApplication> *pApp = NULL;
CComObject<CApplication>::CreateInstance(&pApp);
CComPtr<IUIApplication> spApp(pApp);
g_pFramework->Initialize(hWindowFrame, spApp);
g_pFramework->LoadUI(GetModuleHandle(NULL), L"APPLICATION_Multifunktionsleiste");

Codebeispiel: Behandeln von Ereignissen

class CApplication :
public CComObjectRootEx<CComMultiThreadModel>,
public IUIApplication,
public IUICommandHandler
{
public:
BEGIN_COM_MAP(CApplication)
COM_INTERFACE_ENTRY(IUIApplication)
COM_INTERFACE_ENTRY(IUICommandHandler)
END_COM_MAP()

...

STDMETHOD(OnSichtChanged)(UINT32 nSichtID,
__in UI_SichtTYPE typeID, __in IUnknown* pSicht,
UI_SichtVERB verb, INT32 uReasonCode)
{ return E_NOTIMPL; }
STDMETHOD(OnCreateUICommand)(UINT32 nCmdID,
__in UI_COMMANDTYPE typeID,
__deref_outIUICommandHandler** ppCmdHndlr)
{ return QueryInterface(IID_PPV_ARGS(ppCmdHndlr)); }
STDMETHOD(OnDestroyUICommand)(UINT32 commandId,
__in UI_COMMANDTYPE typeID,
__in_optIUICommandHandler* pCommandHandler)
{ return E_NOTIMPL; }
STDMETHODIMP Execute(UINT nCmdID,
UI_EXECUTIONVERB verb,
__in_opt const PROPERTYKEY* key,
__in_opt const PROPVARIANT* ppropvarValue,
__in_optIUISimplePropertySet* pCmdExecProps)
{
if (verb == UI_EXECUTIONVERB_EXECUTE
&& nCmdID == HomePage)
MessageBox(NULL, L"Clicked on HomePagebtn”, L"HomePage Button Execute“, MB_OK);
return S_OK;
}
STDMETHODIMP UpdateProperty(UINT nCmdID,
__in REFPROPERTYKEY key,
__in_opt const PROPVARIANT* ppropvarCurrentValue,
__out PROPVARIANT* ppropvarNewValue)
{
if (key == UI_PKEY_Enabled &&
nCmdID == HomePage && m_bPressed)
{
return UIInitPropertyFromBoolean(
UI_PKEY_Enabled, FALSE, ppropvarNewValue);
}
return E_NOTIMPL;
}

Ein vollständiges Beispiel befindet sich im Windows 7 SDK (Link).

Windows 7 – Entwickeln mit der neuen Taskleiste

04.02.2010 14:48:02 | Oliver Scheer

Die Taskleiste in Windows 7 hat eine lange Geschichte hinter sich.

Geschichte der Taskleiste

In Windows 1 gab es die Taskleiste noch nicht, es gab lediglich einfache Symbole am unteren Rand. Man konnte die Symbole noch nicht einmal verschieben. Aber der Kenner weiß, dass bereits in dieser Version das „Docking“ der Fenster von Microsoft erfunden wurde. Dieses Feature ist zwar in folgenden Versionen verschwunden, aber in Windows 7 „wieder auferstanden“.

image

In Windows 2.x konnte man Anwendungen mit Hilfe des Program Managers starten. Man hangelte sich dabei durch verschiedene Fenster, die innerhalb des Program Managers geöffnet und geschlossen werden konnten. Um schneller auf Anwendungen zugreifen zu können, konnte man bereits „Shortcuts“ auf den Desktop legen.

image

Get Microsoft Silverlight

In Windows 95 hielt die Taskleiste und der Start-Knopf Einzug. Erstmals wurden ausgeführte Anwendungen als Symbole in der Taskleiste angezeigt und konnten darüber hinaus minimiert, maximiert und geschlossen werden. Darin hat sich bis zum heutigen Tage auch wenig verändert.

image

In Windows XP wurde die komplette Taskleiste in ein neues Design überführt.

image

Mit Windows Vista kam zum ersten Mal die Möglichkeit auf, innerhalb des Startmenüs nach Programmen und Funktionen zu suchen bzw. die Suche über den gesamten Computer zu starten. Dieses Feature wurde auch nötig, da die Programmflut im Startmenü dank vieler Zeitschriften mit CD-Beilagen ins Unermessliche gestiegen war ;)

image

In Windows 7 wurde Taskleiste visuell sehr „vereinfacht“ und mit vielen neuen Funktionen erweitert. Gestartete Programme werden in der gleichen Leiste angezeigt wie Verknüpfungen. Lediglich das Aussehen unterscheidet nun zwischen den verschiedenen Status der Anwendung.

Bei diversen Benutzerumfragen wurden folgende Fakten festgestellt:

  • Mehr als 90 % aller Benutzersitzungen haben weniger als 15 gleichzeitig geöffnete Fenster.
  • Mehr als 70 % aller Sessions haben weniger als 10 Fenster gleichzeitig geöffnet.
  • Nicht-Standard-Optionen wurden nur von max. 10 % aller Benutzer überhaupt verwendet.

Die Ziele für die Entwicklung der neuen Taskleiste sind daher wie folgt definiert worden:

  • Eine Startoberfläche für alle Anwendungen und Ziele
  • Die am meisten benutzten Elemente sollen auf „Fingertipp“ bereitstehen
  • Einfach kontrollier- und verwaltbar mit einfachsten Mitteln
  • Sauber, störungsfrei und einfach

Terminologie und Funktionen der neuen Taskleiste

Taskleisten-Schaltflächen
Jede Anwendung, jedes Ziel und jede Verknüpfung wird durch ein Symbol auf der Taskleiste dargestellt. Gestartete bzw. geöffnete Anwendungen und Ziele werden als Schaltfläche dargestellt. Sind mehrere Instanzen ein und derselben Anwendungen geöffnet, werden diese kaskadierend dargestellt. Dies kann aber über die Eigenschaften der Taskleiste nach eigenen Wünschen verändert werden.

Die Schaltflächen lassen sich sehr vielseitig anpassen. Folgende Möglichkeiten hat der Benutzer:

  • Änderung der Darstellung durch Overlays
  • Darstellung mehrfarbiger Fortschrittsbalken
  • Ändern des Hintergrunds

Damit hat man die Möglichkeit den Status der Anwendung innerhalb der Startleiste zu visualisieren. Folgende Szenarien wären denkbar: Läuft die Anwendung, behält sie das normale Symbol. Muss der User eine Interaktion durchführen, lässt man das Symbol pulsieren, liegt ein Problem vor, zeigt man zum Beispiel ein rotes Kreuz an.

image

Sprunglisten, Ziele und Aufgaben
Jedes Symbol in der Taskleiste hat eine so genannte Sprungliste. Innerhalb dieser Sprungliste gibt es Elemente die jede Anwendung besitzt: Öffnen, Alle Fenster schließen und an die Taskleiste heften bzw. von dieser entfernen. Darüber hinaus kann eine Sprungliste noch zusätzliche Dinge anzeigen. Ist eine Anwendung z.B. mit einem bestimmten Dateityp assoziiert, wie z.B. Word mit Doc-Dateien, dann werden diese automatisch unter „Zuletzt verwendet“ in der Sprungliste angezeigt. Möchte man dort vielleicht ein Dokument immer wieder öffnen, so kann man dies „anheften“. Dadurch steht es solange in dieser Liste, bis man es wieder entfernt. Diese Funktionen stehen jeder Anwendung sofort aus dem Stand zur Verfügung, ohne dass dazu Code notwendig ist.
Zusätzlich lassen sich innerhalb der Sprungliste aber auch noch Aufgaben integrieren. Das können beliebige Tätigkeiten sein. Der Windows Live Messenger macht es vor und bietet die folgenden Aufgaben an: MSN Startseite anzeigen, Postfach öffnen, Sofortnachricht senden, Online, Offline, Abwesend, usw. Das neue Outlook 2010 bietet ähnliche Funktionalitäten, so kann man über die Sprungliste sofort eine Email erstellen, einen Termin planen, direkt den Kalender aufrufen, u.v.m. Wenn man dieses Feature einmal verwendet hat, möchte man es nicht mehr missen.

image

Thumbnail-Toolbars
Ein weiteres neues Feature sind die Thumbnail-Toolbars. Als gutes Beispiel geht der Windows Media Player voran. Geht man mit der Maus über das Symbol des laufenden Mediaplayers, sieht man das aktuelle Video oder Musikcover und zusätzlich die Möglichkeit den Player zu starten, ein Element zurück- oder eines vorzuspringen. Dadurch lässt sich der Player direkt aus der Startleiste steuern, ohne dass man ihn erst einmal in den Vordergrund holen muss.

image

Auch die Darstellung der Vorschau in der Taskleiste ist individuell anpassbar. Man hat in der Startleiste und deren Vorschau ja nicht beliebig viel Platz. Daher kann man die Darstellung in der Vorschau nach eigenen Wünschen gestalten und nur das Wesentliche anzeigen lassen.

Verwendung von Managed Code

Die einfachste Art und Weise, um auf die Funktionen der Taskleiste zuzugreifen ist das Windows API Code Pack (http://code.msdn.microsoft.com/WindowsAPICodePack). Dieses wurde bereits vor einigen Tagen vorgestellt. Bindet man dieses in sein eigenes Projekt ein, kann man direkt auf die Funktionen der Taskleiste zugreifen.

Um beispielsweise ein Overlay-Symbol über dem Anwendungssymbol einzublenden, ist der folgende Code notwendig.

windowsTaskbar.SetOverlayIcon(this.Handle, TaskbarDemo.Properties.Resources.Yellow, "Yellow");

Dabei wird auf ein Bild zugegriffen, das im Projekt als Ressource mit dem Namen “Yellow” eingebunden wurde.

Möchte man die zuletzt verwendeten Dokumente in der Sprungliste anzeigen, reicht dieser Code.

jumpList.KnownCategoryToDisplay = JumpListKnownCategoryType.Recent;

Oder

jumpList.KnownCategoryToDisplay = JumpListKnownCategoryType.Frequent;

Möchte man den Fortschritt der Anwendung in der Taskleiste darstellen, ist dieser Code ausreichend.

TaskbarManager.Instance.SetProgressValue(trackBar1.Value, 100);

Was sind Sprunglisten?

Bei den Sprunglisten handelt es sich um eine neue Funktionalität, die es ermöglicht, dem Anwendungssymbol zusätzliche Funktionen hinzuzufügen. Einfach auf dem Symbol die rechte Maustaste drücken und schon erscheint die Sprungliste. Standardmäßig sind die Funktionen zum Öffnen, Schließen und Anheften enthalten. Wenn die Anwendung die Funktionen „Zuletzt verwendete Dokumente“ und „Häufig verwendete Dokumente“ unterstützt, so werden diese Dokumente ebenfalls direkt in der Sprungliste angezeigt. Diese Liste der Dokumente kann für eigene Anwendungen sehr leicht angepasst werden.

Für einen einfachen Zugriff empfiehlt sich die Verwendung des Windows API Code Pack (Link kommt hier rein). Verwendet man diese Bibliothek, dann lässt sich die Liste der Dokumente über die folgenden Zeilen Code steuern:

private JumpListCustomCategory category1 =
new JumpListCustomCategory("Custom Category 1");

// Add shell item to custom category
String path = “mydocument.txt”;
category1.AddJumpListItems(new JumpListItem(path));

image

Möchte man eine eigene Aufgabe zur Taskleiste hinzufügen, die dafür sorgt, dass ein bestimmtes Programm geöffnet wird, so geht dies mit den folgenden Zeilen Code.

// Path to Windows system folder
string systemFolder = Environment.GetFolderPath(Environment.SpecialFolder.System);

// Add our user tasks
jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "notepad.exe"), "Open Notepad")
{
   IconReference = new IconReference(Path.Combine(systemFolder, "notepad.exe"), 0)
});
jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "mspaint.exe"), "Open Paint")
{
  IconReference = new IconReference(Path.Combine(systemFolder, "mspaint.exe"), 0)
});
jumpList.AddUserTasks(new JumpListSeparator());
jumpList.AddUserTasks(new JumpListLink(Path.Combine(systemFolder, "calc.exe"), "Open Calculator")
{
  IconReference = new IconReference(Path.Combine(systemFolder, "calc.exe"), 0)
});

 

Externe Tools für Sprunglisten

Wer gerne Schnellzugriff auf frei konfigurierbare Tools haben möchte, dem kann ich den Jumplist-Launcher empfehlen. Ein kostenfreies Tool, das es hier (Link: http://www.ali.dj/jumplist-launcher/) gibt. Damit lassen sich bis zu 60 Programme frei in der Jumplist konfigurieren.

Windows 7 – Entwickeln mit dem Windows API Code Pack

04.02.2010 14:43:14 | Oliver Scheer

Das Windows API Code Pack for Microsoft .NET Framework ist eine .NET-Bibliothek für die Nutzung einiger der neuen Windows 7-Features sowie Funktionen aus älteren Betriebssystemen. Diese Bibliothek beinhaltet Funktionen, die so heute noch in keinem .NET Framework enthalten sind. Die nächste Version des .NET Framework wird große Teile dieser Bibliothek übernehmen, allerdings dauert das noch eine Weile. Leider kann aber wegen des Open Source-Charakters momentan keine hundertprozentige Gewährleistung gegeben werden, dass die Bibliotheken im .NET Framework genauso aussehen werden, wie im Code Pack.

Das tolle an diesen Bibliotheken ist, dass sie im Quellcode vorliegen und so von jedem erweitert werden können. Dadurch erhält man die Sicherheit, dass die eigenen Anwendungen auch noch mit späteren Versionen des .NET Framework funktionieren werden.

Wo bekommt man das Code Pack her?

Alle notwendigen Ressourcen können in einer einzelnen Datei heruntergeladen werden. Der Download ist hier verfügbar: http://code.msdn.microsoft.com/WindowsAPICodePack

image

Das Code Pack gibt es derzeit in der Version 1 und enthält die folgenden Bestandteile:

  • Windows 7 Taskbar Sprunglisten, Symboloverlays, Fortschrittsbalken, Tabbed Thumbnails und Thumbnail Toolbars.
  • Windows 7-Bibliotheken, bekannte Ordner, Nicht-Filesystem-Container.
  • Windows Shell Search API Support, eine Vielzahl von Shell-Funktionen inkl. Drag und Drop für Shell-Objekte (z.B. Dateien).
  • Explorer Browser Control.
  • Shell-Eigenschaften.
  • Windows Vista- und Windows 7-Dateidialoge, einschließlich benutzerdefinierter Steuerelemente.
  • Windows Vista und Windows 7 Task-Dialoge.
  • Direct3D 11.0, Direct3D 10.1/10.0, DXGI 1.0/1.1, Direct2D 1.0, DirectWrite, Windows Imaging Component (WIC) APIs. (DirectWrite und WIC sind derzeit nur teilweise unterstützt)
  • Sensor Platform APIs
  • Extended Linguistic Services APIs
  • Power Management APIs
  • Application Restart and Recovery APIs
  • Network List Manager APIs
  • Command Link Steuerelement und System-Symbole.
  • Shell Search API support.
  • Support für Direct3D- und Direct2D-Interoperabilität.
  • Support von Typographie und Schriftarten für DirectWrite APIs.

Die Anforderungen des Code Pack

  • .NET Framework 3.5 SP1 Ist mindestens erforderlich
  • Diese Bibliothek adressiert Windows 7 RTM (bereits verfügbar für alle MSDN Subscriber), einige Features funktionieren allerdings auch auf älteren Windows Betriebssystemen.
  • DirectX Features benötigen das Windows SDK für Windows 7 RTM. Zusätzlich benötigen einige Direct3D-Beispiele das DirectX SDK (Version August 2009).

Erstellen und Verwenden der Bibliothek

Um die Bibliothek zu erstellen (ausgenommen die DirectX betreffenden Features), benötigt man Visual Studio 2008. Der gesamte Inhalt des Pakets „WindowsAPICodePack.zip“ sollte dafür in einen neuen Ordner entpackt werden. Darin enthalten ist die Datei „WindowsAPICodePack.sln“, die die gesamte Lösung beinhaltet.

Für das Erstellen der DirectX-Features wird“DirectX.sln“ innerhalb des DirectX-Verzeichnisses benötigt. Eine genauere Beschreibung der Anforderungen ist in der einer Hilfedatei im selben Ordner beschrieben

Welche Beispiele sind im Code Pack enthalten?

Das Code Pack beinhaltet neben den Bibliotheken auch einige Beispielanwendungen, die sofort lauffähig sind, um die Verwendung erfolgreich zu demonstrieren. Jedes Beispiel ist sowohl in C# also auch in Visual Basic .NET verfügbar.

Konkret enthalten sind Beispiele für Explorer-, Netzwerk-, Ribbon-, Startleiste-, Sensor- und Dialog-Bibliotheken.

image

 


Get Microsoft Silverlight

Windows 7 – Entwickeln mit dem Windows Software Development Kit

04.02.2010 14:39:21 | Oliver Scheer

Microsoft bringt für jede Version von Windows ein besonderes Kit für die Entwicklung von Anwendungen heraus. Dieses steht Interessierten kostenfrei zur Verfügung: Das Windows Software Development Kit.

Beim Microsoft Windows SDK handelt es sich um einen Satz von Tools, Codebeispielen, Dokumentationen, Compilern, Headern und Bibliotheken, mit denen Entwickler Anwendungen erstellen können, die unter Windows-Betriebssystemen mit systemeigenen (Win32) oder verwalteten (.NET Framework) Programmiermodellen ausgeführt werden.

Natürlich gibt es dieses SDK auch für Windows 7. Je nach Funktionsumfang ist es zwischen 300 KB und 4 GB groß. Daher kann die Installation je nach Netzwerkverbindung auch mal etwas länger dauern. Im SDK findet sich für jeden Entwickler einiges an hilfreichen Codebeispielen und Werkzeugen für den eigenen Werkzeugkasten.

Windows7SDK

Hier an der Stelle noch mal der sehr wichtiger Hinweis: Das Windows SDK ist ein Kit an Software-Entwicklungshilfen. Es ist teilweise sehr komplex und umfangreich. Da die Dokumentation teilweise direkt von den Entwicklern kommt, sind alle Bestandteile ausnahmslos im Englisch gehalten. Wäre es ganz einfach, dann könnte es ja jeder ;).

Möchte man sehen, welche Version des SDKs für welches Betriebssystem installiert ist, kann man das mit dem Configuration Tool ermitteln und einstellen. Ein wichtiger Einstiegspunkt ist die Dokumentation die mitgeliefert wird.

Wer behauptet, dass sich von Windows Vista zu Windows 7 nicht viel getan hat, der darf sich gerne die folgende Liste mit neuen und erweiterten APIs auf der Zunge zergehen lassen:

  • Active Directory Rights Management Services
  • Biometric Service API
  • COM
  • Core Windows
  • Enhanced Storage
  • Enhanced Taskbar
  • Event Tracing for Windows (ETW)
  • Extended Linguistic Services
  • File Server resource Manager
  • Hardware Counter Profiling
  • Hyper-V
  • Internet Explorer
  • Location API
  • Mobile Broadband
  • Native Wifi
  • Network Share Management
  • Packaging
  • Parental Controls
  • Peer Distribution
  • Performance Counters
  • Power Management
  • Scenic Animation
  • Sensor API
  • Virtual Disk Service
  • Virtual Hard Disk
  • Volume Shadow Copy Service
  • Windows Connect Now
  • Windows Error Reporting
  • Windows Event Log
  • Windows Gadget Platform
  • Windows Installer
  • Windows Scenic Ribbon
  • Windows Touch
  • Windows Troubleshooting Platform
  • Windows Web Services
  • XPS Documents

Einige davon, definitiv nicht alle, werden wir hier noch genauer vorstellen.

Was befindet sich im SDK?

Im SDK befinden sich Beispielanwendungen auf „Hallo Welt“-Niveau für erste Schritte in bestimmten Bereichen bis hin zu sehr komplexen Beispielen, die die Technologien tiefer demonstrieren.

Tools für Managed Code

  • ASPNet_merge.exe (ASP.NET Merge Tool für Assemblies)
  • SqlMetal.exe (Code Generation Tool für SQL Tabellen in .NET-Klassen)
  • Xsltc.exe (XSLT Compiler für XSLT-Style Sheets in Assemblies für eine bessere Performance)

Tools für Native (Win32 und COM) Entwicklung

  • BETest.exe (VSS Backup und Restore Test Tool)
  • Checkv4.exe (IPv6 Compatibility Check Tool, Hilft IPv4-Code aufzuspüren und gibt Tipps für Anpassung auf IPv6)
  • CTRPP.exe (Counter Pre-processor Tool, Performance Counter Generator)
  • Ecmangen.exe (ETW Manifest Generation Tool, Event Tracing für Windows)
  • FiltDump.exe (IFilter Dump)
  • FiltReg.exe (IFilter Registy)
  • GC.exe (SAPI Grammar Compiler, Speech Application Programming Interface, erzeugt Gramatikassemblies aus XML-Dateien)
  • Genmanifest.exe (Generate Manifest Tool)
  • IFiltTst.exe (IFilter Test Tool)
  • Midl.exe (MIDL Compiler, erzeugt eine Bibliothek für Zugriff auf Interface Definition aus der COM-Welt)
  • Sporder.exe (Protocol Reorder Tool)
  • Topoedit.exe (Topology Editor für die Media Foundation)
  • UICC.exe (Ribbon Markup Compiler)
  • Vshadow.exe (VShadow Tool, erzeugt und verwaltet Volumenschattenkopien)
  • VSSAgent.exe VSDiagview.exe (VSS Diagnostic Tools)
    VSSTrace.exe (VSSTrace Tool)
  • Vstorcontrol.exe (VSS Sample Provider Tool)
  • VSWriter.exe (VSS Test Writer Tool)
  • WsdCodeGen.exe (Web Services on Devices Code Generator)
  • Wsddebug_client.exe, Wsddebug_host.exe (Web Services on Devices Debugging Tools)
  • WSTraceDump.exe (Web Services Trace Dump Tool)
  • WSUtil.exe (Web Services Compiler Tool)

Tools für beide Welten

  • AccEvent.exe (Accessible Event Watcher, prüft Anwendungen auf Accessibility-Funktionalitäten)
  • AppVerif.exe (Application Verifier)
  • Bind.exe (Windows NT Image Binder)
  • DeviceSimulatorForWindowsSideShow.msi (Device Simulator for Windows SideShow)
  • FileFormatVerifier.exe (File Format Verifier Tool für registrierte Dateiendungen)
  • FTQuery.exe (FTQuery Tool)
  • Inspect.exe (Inspect Objects Tool)
  • MSIVal2.msi (MSIVal2 Tool, Konsistenzprüfung)
  • Orca.msi (Installer for Orca, Windows Installer Administration für eigene Installer)
  • PKTExtract.exe (Public Key Token Extractor Tool)
  • SDCatalog.Exe (SDCatalog Tool für Windows Troubleshooting Packs)
  • SDMC.Exe (SDMC Tool für Windows Troubleshooting Pack Designer)
  • SetReg.exe (SetReg Tool, Registry für Zertifikate)
  • TSPDesigner.exe (Windows Troubleshooting Pack Designer, erzeugt Windows Troubleshooting Packs)
  • UuidGen.exe (UUID Generator Tool, erzeugt Universal Unique Identifiers, auch als GUIDs bekannt)
  • VirtualLightSensor.exe (Virtual Light Sensor Tool)
  • WinDbg.exe (Debugging Tools for Windows)
  • wpt-x86.msi, wpt-x64.msi, wpt-ia64.msi (Windows Performance Toolkit)
  • XPSAnalyzer.exe (XPS Analyzer)

Weitere Werkzeuge, die man aus dem SDK nach installieren kann

  • Background Intelligent Transfer Service (BITS)
  • CAPICOM (Bietet kryptografische und andere sicherheitsrelevante Dienste an)
  • Debug Help Library (DbgHelp, Treiber- und Anwendungsdebugger)
  • Group Policy Management Console (GPMC)
  • Rights Management Services (RMS)
  • Microsoft Management Console (MMC)
  • Windows InstallerWindows Management Instrumentation (WMI)
  • Windows Remote Management (WinRM)
  • Windows Update Agent (WUA)
  • Real-Time Communications (RTC)
  • Windows Server Update Services (WSUS)

Das Windows SDK wird pro Version übrigens mehr als eine Millionen mal heruntergeladen. Das Team besteht aus 25 Personen und wer könnte da besser das Video des Tages liefern als die Program Managerin Lori Pearce

Get Microsoft Silverlight

Weiterführende Links

Teamblog der Windows SDK Entwickler: http://blogs.msdn.com/windowssdk/

Download-Link für das Windows 7 SDK: http://www.microsoft.com/downloads/details.aspx?FamilyID=c17ba869-9671-4330-a63e-1fd44e0e2505&displaylang=en

ASP NET Custom Control with PersistenceMode.InnerProperty including Server Controls

03.02.2010 20:04:00 | Andreas Mehl

If we want to use a Custom Control with PersistenceMode.InnerProperty. And would like to include some Asp Server Controls we do following:

We create a aspx where the controls to be added:

ObjectArray[] objectArray = DataSet.ToSpecifiedObject<ObjectArray[]>();

public static T ToSpecifiedObject<T>(this DataSet value)
{
    byte[] buf = System.Text.UTF8Encoding.UTF8.GetBytes(value.GetXml());
    MemoryStream ms = new MemoryStream(buf);
    XmlSerializer ser = new XmlSerializer(typeof(T));
    object obj = ser.Deserialize(ms);

    return (T)obj;
}

C# Object Array to DataTable Extension Method

03.02.2010 18:54:00 | Andreas Mehl

DataGrid.DataSource = objectArray.ToDataTable<ObjectType>();

public static DataTable ToDataTable<T>(this object value)
{
    XmlSerializer serializer = new XmlSerializer(value.GetType());
    System.IO.StringWriter sw = new System.IO.StringWriter();
    serializer.Serialize(sw, value);

    DataSet ds = new DataSet();
    System.IO.StringReader reader = new System.IO.StringReader(sw.ToString());
    ds.ReadXml(reader);
    return ds.Tables[0];
}

NEU: Deutsches Microsoft Social Media Portal - alle Ressourcen im Ueberblick

03.02.2010 15:37:49 | Kay Giza

Microsoft und Social Media, das ist ein spannendes Thema wie ich finde. Erstens gibt es tausende Definitionen im Web, was Social Media eigentlich bedeutet. Zweitens gibt es dazu noch tausende Untersuchungen (mit unterschiedlichen Sichtweisen und Ergebnissen), Web 2.0, Social Media, Social Marketing, Social Social Social... Ich werde mal in einem der nächsten Artikel meine Definition von Social Media posten. Ich persönlich glaube, unabhängig von der Definition haben alle Untersuchungen und alle Unternehmen das gleiche Problem: Simplifizierung in alle Richtungen Ich habe letztens selber beim Lesen des Blogartikels 'Theorie und Blog – deutsche IT-Unternehmen und Corporate Blogs (Teil III)' festgestellt, wow - Microsoft kommt ja ganz gut weg beim Thema Social Media. Kommen wir das auch wirklich? Lesen Sie in diesem ausführlich Blogeintrag auf Giza-Blog.de alle Details über das neue Microsoft Social Media Portal von Microsoft Deutschland... [... mehr]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Im Wandel: Microsoft und das Wiener Schnitzel - die maschinelle Uebersetzung von Artikeln

03.02.2010 14:12:24 | Kay Giza

Wer kennt Sie nicht, die Wiener Schnitzel, muttersprachliche Sprachexperte, die Horn-Community-Technologie-Long-Vorschau, wenn Facebook leider gesperrt wird, wenn die Richtung grüßt, usw. usw. Ich lache :-D darüber auch gerne, aber immer auch mit einem ;-). Es gibt keinen Sachverhalt, der in den letzten Jahren mit mir von Entwicklern bzw. IT Professionals häufiger diskutiert wurde, als die Machine Translation (MT) von MSDN Library, MSDN Magazine oder Knowledge Base (KB) Artikeln usw. Dieser Blogartikel liegt schon lange in einer 99,9% Fassung vor, heute konnte ich ihn dann um die letzten Zeilen vervollständigen. Ich persönlich kann manchmal die Aufregung von automatisch, maschinell bzw. computergesteuert bereitgestellten Übersetzungen nicht verstehen... [... mehr Informationen, was Microsoft jetzt anders macht sowie den vollständigen Beitrag in diesem ausführlichen Blogartikel auf Giza-Blog.de]

This post is powered by www.Giza-Blog.de | Giza-Blog.de: RSS Feed
Visit:  MSDN Online | Follow MSDN Online on Twitter | Follow Kay Giza on Twitter
Daily News on MSDN:  MSDN Aktuell
© Copyright 2006-2010 Kay Giza. All rights reserved. Legal
Subscribe

Windows Sidebar Gadgets, Silverlight und 64-Bit Probleme

03.02.2010 11:15:47 | Oliver Scheer

Als Fan von Windows Sidebar-Gadgets stößt man unter 64-Bit-Versionen von Windows schnell auf bestimmte Probleme. Dieser Blogeintrag beschreibt, wie man als Benutzer und Entwickler am besten damit umgehen kann.

Grundsätzlich sind Gadgets (bzw. Miniaturanwendungen) nicht anderes als HTML-Anwendungen. Damit die Sidebar diese Anwendungen darstellen kann, wird der installierte Internet Explorer von Windows verwendet. Auf einem 64-Bit System ist dies automatisch der Internet Explorer in der 64-Bit Version. Dies gilt explizit nur für die Sidebar.

Klickt man auf einen Link in einer Email, oder ruft auch sonst irgendeinem Grund den Internet Explorer auf, so startet standardmäßig der Internet Explorer in der 32-Bit-Version. Nachteile entstehen dem Benutzer dadurch absolut nicht. Einzige Ausnahme bildet hier die Sidebar, diese verwendet automatisch den 64-Bit Internet Explorer, wenn man mit einer 64-Bit Version von Windows arbeitet.

Das hat nun zur Folge, dass Sidebar-Gadgets auch die 64-Bit-Variante verwenden. Leider stellen die wenigsten Hersteller von Browsererweiterungen ihre Plug-Ins in 32- und 64-Bit-Versionen zur Verfügung. Ganz ehrlich, es gibt quasi fast keine 64-Bit-Erweiterungen für 64-Bit Browser. Das liegt vielleicht unter anderem daran, dass außer Microsoft kein Browserhersteller aktuell eine 64-Bit Version eines Browsers für Windows geliefert hat. Weder Google Chrome, noch der Firefox, stehen in einer 64-Bit Version für Windows 64-Bit-Versionen zur Verfügung.

Silverlight und Flash stehen ebenfalls nicht in 64-Bit-Version zur Verfügung. Sie lassen sich dennoch ohne Probleme auf einem 64-Bit-System installieren, keine Sorge. Alles läuft wie gewohnt. Bis auf die Sidebar.

Hat man nun eine Windows 64-Bit Version und verwendet ein Gadget, das auf Flash oder Silverlight basiert bekommt man die Gadgets wie auf dem folgenden Bild dargestellt:

image
Ich habe hier testweise das Channel9-Gadget verwendet.

Wie kann man nun dieses Problem beheben?

Die Sidebar.exe, die Anwendung die für die Darstellung der Gadgets zuständig ist, gibt es auch in zwei Versionen: 32- und 64-Bit.

image

Einmal im Ordner C:\Program Files\Windows Sidebar.

image

Und ein weiteres Mal im Ordner C:\Program Files (x86)\Windows Sidebar.

Um nun seine Silverlight- oder Flash-Gadgets in auf einem 64-Bit System darstellen zu können muss lediglich die 32-Bit-Variante von sidebar.exe beim Starten von Windows aufgerufen werden. Dies geschieht am besten über die Autostart-Funktion von Windows.

Einfach einen Shortcut in den Order C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup hinzufügen, der die Siderbar.exe aus dem Ordner: C:\Program Files (x86)\Windows Sidebar\sidebar.exe verlinkt.

Anschließend wird die Sidebar im 32-Bit-Modus gestartet und verwendet den Internet Explorer in der 32-Bit-Version.

image

Neu : Visual Studio TFS Branching Guide 2010

02.02.2010 10:21:00 | Christian Binder

Eine neues Release des Branching Guides für 2010 ist hier auf Codplex verfügbar. Nachdem die Version 2.0 > 50000 Downloads hat, bietet die neue Version zusätzlich vor allem Infos zu den neuen TFS 2010 Branching und ChangeSet Tracking Funktionen. Das Poster finde ich besonders gelungen, vor allem die Figuren :-)

TFS Branching Guide 2010

Viel Spass

Chris

Neues und neue Termine für den .NET-Stammtisch Konstanz-Kreuzlingen

02.02.2010 03:48:00 | Jürgen Gutsch

Es ist kaum zu glauben, aber es ist schon über ein Jahr vergangen seit Peter und ich den .NET-Stammtisch Konstanz-Kreuzlingen ins Leben gerufen haben.

In diesem Jahr ist Viel passiert: Wir hatten einige Prominente Sprecher da, wie z. B: Michael Schwarz, Albert Weinert, Thomas Schissler, Golo Roden, Gregor Biswanger und Stefan Lieser und wir natürlich selber als Sprecher die ersten Erfahrungen sammeln dürfen. Und mit jedem Treffen ist die Teilnehmerzahl etwas gewachsen.

Viele interessante und interessierte Leute bilden eine bunte Mischung innerhalb des Stammtisches und sorgen für abwechslungsreiche Diskussionen, auch abseits der .NET-Themen.

Leider kann Peter dem Stammtisch, aus beruflichen Gründen, nicht mehr als Group Leader zur Verfügung stehen, weshalb ich innerhalb des Stammtisches nach einer weiteren Unterstützung umschauen musste und zum Glück auch gefunden habe.
Neu im Team sind jetzt Tilo Schinke und Johannes Fritsch.
Ich freue mich sehr, dass sich die beiden bereiterklärt haben den Stammtisch zu unterstützen. Vielen Dank dafür :-)

Desweiteren freue ich mich sehr über die ersten Vorträge die von Mitgliedern des Stammtisches vorgeschlagen und auch gehalten werden.

Somit steht auch die Terminplanung für die nächsten sechs Monate:

  • 10.02.2010 – 12. Treffen
    Peter Bucher mit einer kurzen Einführung in die Entstehung von LightCore
    Jürgen Gutsch mit eine Live Coding Demo zu Dependency Injection mit LighCore
  • 10.03.2010 – 13. Treffen
    Golo Roden mit Visual Studio 2010 / .NET Framework 4.0 und C# 4.0 Neuerungen
  • 19.03.2010 – 14. Treffen (außerhalb der Reihe)
    Robert Meyer mit einem Open Space zu BizTalk Server 2009
  • 14.04.2010 – 15. Treffen
    Tilo Schinke mit Datenmodellierung – Relationales Mapping oder Objektpersistenz
  • 12.05.2010 – 16. Treffen
    Johannes Fritsch mit ASP.NET MVC mit NHibernate unter Mono
  • 09.06.2010 – 17. Treffen
    Jürgen Gutsch mit WebDAV - Die universelle Schnittstelle.

Natürlich Freue ich mich auf ein weiteres erfolgreiches und abwechslungsreiches Jahr mit dem .NET-Stammtisch Konstanz-Kreuzlingen und darauf weitere interessante Menschen kennenzulernen und auch den einen oder anderen prominenten Sprecher bei uns begrüßen zu dürfen.

Für die letzten zwölf Monate bedanke mich herzlich bei allen Teilnehmern und Mitgliedern, ohne die der Stammtisch sicherlich ein schnelles Ende gefunden hätte und natürlich bei allen Sponsoren die für die vielen Give Aways und den Unterhalt der Räumlichkeiten gesorgt haben.

DotNetKicks-DE Image

Visual Studio 2010 Team Foundation Server Requirements Management Guidance

01.02.2010 14:27:47 | Christian Binder

Auf Codeplex wurde vor kurzem ein Guide von den VSTS Rangers zum Thema “Requirements Engineering Best Practices” für Team Foundation Server 2010 veröffentlicht. Der Guide ist umfangreich und spricht unter anderem Themen wie RM Planning, Requirement Traceability, Change Management und Impact Analysis an. Da es hierbei natürlich um Themen geht, die erst mal nicht Tool spezifisch sind, zeigt der Guide aber dennoch die Umsetzung mit dem Team Foundation Server 2010 auf.

Requirements Engineering Guide 

Viel Spass

Chris

Habt keine Furcht vor Besuchern

01.02.2010 12:28:00 | Jan Christian Selke

Vor kurzem habe ich eine Quellcode Passage entdeckt, die mir auf Anhieb Bauchschmerzen bereitete. Sie entpuppte sich dann auch als eines jener Beispiele, die als wunderbares Anti-Pattern Beispiel verwendet werden könnte. Anhand dieses Beispiels lässt sich sehr plastisch aufzeigen, wie schnell gegen fast alle SOLID Prinzipien vom guten alten Onkel Bob verstoßen werden kann. Weitaus schwieriger als den Finger zu heben ist es dann aber einen geeigneten Lösungsansatz zu formulieren.

Das Problemkind

Auf das Wesentliche reduziert, entsprach der gefundene Quellcode dem folgenden Muster.

public abstract class BaseType

    BaseType[] children;

    public virtual bool IsProtected()
    {
        if(this is SubType1 || this is SubType3 || this is SubType5)
        {
            return true;
        }

        return false;
    }

    public virtual bool IsProcessable
    {
        return true;
    }

    public virtual bool Process()
    {
        if(this.IsProcessable)
        {
            foreach(BaseType child in this.children)
            {
                if(child is SubType1
                {
                    if(child.IsProtected) {…}
                }
 
                if(child is SubType2)
                {
                    if(!child.IsProtected) {…}
                }

                child.Process();
            }
        }
    }
}

public class SubType1 { … }
public class SubType2 { … }
public class SubType3 { … }
public class SubType4 { … }
public class SubType5 { … }

Die SOLID Prinzipien, gegen die verstoßen wird, lassen sich sprichwörtlich an fünf bzw. diesmal auch nur vier Fingern abzählen (was aber vor allem daran lag, dass gar keine Schnittstellen existierten ;-)):

  • Single Reponsibility Principle (SRP) - Es gibt nun mehr als einen Grund zum Ändern der Klasse.
  • Open Close Principle (OCP) - Das Verhalten kann nicht mehr erweitert werden, ohne dass die Klasse verändert werden muss.
  • Liskov Substitution Principle (LSP) - Die abgeleitete Klasse kann nicht mehr die Abstraktion ersetzen.
  • Dependency Inversion Principle (DIP) - Die Logik ist abhängig von konkreten Implementierungen und nicht Kontrakten bzw. Abstraktionen.

Die einzelnen Prinzipien hat Uncle Bob bereits ausreichend beschrieben. Weitere Quellen sind sehr schnell gegoogled.

Ich möchte hiermit nicht sagen, dass der Code oben schlecht ist, weil die Prinzipien vorbehaltlos toll sind und sich jeder Entwickler daran halten muss, weil es einfach so ist… Die Prinzipien sind ein Indikator und damit auch ein Garant für stabile, wartbare und erweiterbare Software, da sie vor allem auf das Management von Abhängigkeiten in OOP fokussieren.

Wie kann es sauberer gelöst werden?

An bestehenden Lösungen mäkeln ist Eines, selber aber einen Lösungsansatz entwerfen und umsetzen zu können ist dann schon weitaus schwieriger. Etwas plakativ könnte man einen Lösungsansatz formulieren: Habt keine Angst vor Besuchern! Was soll das aber konkret bedeuten? Es soll bedeuten, dass durch die Anwendung des hierarchischen Visitor Patterns kombiniert mit dem Composite Pattern und einer geeigneten Vererbungshierarchie aus dem obigen Beispiel ein sauberes Design entworfen werden kann.

Das gesamte Modell wirkt nun etwas komplexer.

model

Die gesamte Kommunikation zwischen den Objekten erfolgt jetzt auf Basis von Kontrakten. Es wird keine Implementierung mehr benötigt. Außerdem ist das Modell ohne Anpassungen an den bestehenden Klassen erweiterbar.

Begonnen habe ich mit der Modellierung für die Schnittstelle des Visitors. Der Visitor erhält in die jeweiligen Methodenaufrufe als Eingangsparameter den zu besuchenden, abzuarbeiten LeafNode. Die erfolgt jedoch erst, wie weiter unten beschrieben wird, wenn der LeafNode den Visitor auch akzeptiert hat.

public interface IVisitor
{
    void Visit(ILeafNode node);
    void Visit(Predicate<ILeafNode> filter, ILeafNode node);
}

Ausgehend von der Schnittstelle habe ich eine abstrakte Basisklasse mit virtuellen Methoden für alle LeafVisitor erstellt. Durch Einfach dieses quasi Template Pattern besteht nicht der Bedarf für alle Visitor auch alle durch die Schnittstelle vorgegebenen Methoden implementieren zu müssen (wie das Negativbeispiel des Microsoft MembershipProviders).

public abstract class LeafVisitor : IVisitor
{
    public void VisitLeaf(ILeafNode leaf)
    { 
        leaf.AcceptVisitor(this); 
        foreach (ILeafNode child in leaf.ChildLeaves)
        {
            VisitLeaf(child);
        }
    }

    public virtual void Visit(ILeafNode node)
    {
    }

    public virtual void Visit(Predicate<ILeafNode> filter, ILeafNode node)
    {
    }
}

Die konkrete Implementierung des Visitors erfolgt dann in der Klasse LeafProcessor. Dieser kann dann die beliebige Logik zum Prozessieren der Knoten enthalten bzw. kann bei Bedarf nach Belieben überschrieben werden. Damit etwas passiert, habe ich dem Prozessor noch einen OutputBuilder verschafft, der die Namen der durchlaufenen Klassentypen in die Konsole schreibt.

LeafProcessor implementiert die Schnittstelle  ILeafProcessor. In meinem Beispiel wird hier nichts anderes getan, als basierend auf dem übergeben Knoten Output zu erzeugen.

public interface ILeafProcessor
{
    void CreateOutput(ILeafNode node);
}

Dazu habe ich eine weitere Klasse ConsoleOutputBuilder basierend auf dem Kontrakt IOutputBuilder erstellt. In der Methode CreateOutput(ILeafNode) wird der Name des übergebenen Knotens auf der Konsole ausgegeben.

public class LeafProcessor : LeafVisitor, ILeafProcessor
{
    private readonly IOutputBuilder _output;

    public LeafProcessor()
    {
        this._output = new ConsoleOutputBuilder();
    }

    public LeafProcessor(IOutputBuilder builder)
    {
        this._output = builder;
    }

    public override void Visit(ILeafNode node)
    {
        this.CreateOutput(node);
    }
   
    public override void Visit(Predicate<ILeafNode> filter, ILeafNode node)
    {
        if(filter(node))
        {
            this.CreateOutput(node);
        }
    }

    public void CreateOutput(ILeafNode node)
    {
        this._output.Out(node.ToString());  
    }
}

Der Knoten, der mit Unterstützung des Visitors prozessiert werden soll, muss nun auch wissen, dass er besucht werden darf. Aus diesem Grund gibt es die Schnittstelle IVisitable. Es wird hier lediglich die Methode AcceptVisitor(IVisitor) definiert.

public interface IVisitable
{
    void AcceptVisitor(IVisitor visitor);
}

Der Kontrakt des LeafNodes implementiert diese Schnittstelle und damit ist der Grundstein für die Prozessierung mit einem Visitor gelegt. Innerhalb des Kontrakt wird noch der Zugriff auf die Kind-Elemente in Form eines sehr leichtgewichtigen Composite-Patterns definiert, da auf eine Objekthierarchie zugegriffen wird.

public interface ILeafNode : IVisitable
{
    IEnumerable<ILeafNode> ChildLeaves { get; }
    ILeafNode[] Children { get; }
}

Da jetzt alle Kontrakte aufgesetzt sind, werden als nächstes die LeafNodes mit Leben gefüllt. Als erstes habe ich eine Basisklasse LeafBaseType erstellt, in der virtuelle Basismethoden implementiert wurden. Allen abgeleiteten Typen steht es frei, diese zu Nutzen oder bei Bedarf zu überschreiben.

public class LeafBaseType : ILeafNode
{
    private readonly ILeafNode[] _children;

    public LeafBaseType()
    {
        this._children = new ILeafNode[0];
    }

    public LeafBaseType(ILeafNode[] childs)
    {
        this._children = childs;
    }

    public virtual bool IsProtected()
    {
        return false;
    }

   public virtual bool IsProcessable()
    {
        return true;
    }

    public IEnumerable<ILeafNode> ChildLeaves
    {
        get { return this._children; }
    }

    public ILeafNode[] Children
    {
        get { return this._children; }
    }

    public virtual void AcceptVisitor(IVisitor visitor)
    {
        visitor.Visit(this);
    }
}

Der erste abgeleitete Typ dient als Referenz. Er nutzt vollständig die Funktionalität der Basisklasse. Eine eigene Implementierung der Aufnahme des Visitors ist nicht nötig.

public class LeafSubType1 : LeafBaseType
{
    public LeafSubType1() : base(new ILeafNode[0])
    {
    }

    public LeafSubType1(ILeafNode[] childs)
        : base(childs)
    {
    }
}

Interessanter wird da die Implementierung des zweiten abgeleiteten Typs. Hier soll nun die Annahme des Visitors von einer Bedingung abhängig gemacht werden. Zusätzlich wird dem Visitor noch eine Bedingung mitgegeben, welche die Ausführung direkt im Visitor steuert. Recht elegant ist hierbei die Übergabe des zweiten Filters an den Visitor in Form eines lambda Ausdrucks.

public class LeafSubType2 : LeafBaseType
{
    public LeafSubType2() : base(new ILeafNode[0])
    {
    }

    public LeafSubType2(ILeafNode[] childs) : base(childs)
    {
    }

    public override void AcceptVisitor(IVisitor visitor)
    {
        if(this.IsProcessable)
        {
            visitor.Visit(x => x.IsProcessable(), this);
        }
    }
}

Wie kommt der Visitor aber zu Besuch? Mit Hilfe von Prozesslogik. Was hier und in welcher Reihenfolge prozessiert werden soll ist noch völlig unklar und der Knoten selbst soll es auch gar nicht wissen. Dafür gibt es die Klasse LeafProcessing. Als Eingangsparameter im Konstruktor wird der Basisknoten des Baums übergeben und mit Aufruf der Methode StartProcessing() beginnt die Abarbeitung. Innerhalb dieser Methode wird ein Objekt vom Typ LeafProcessor erstellt und der Basisknoten wird diesem mit Aufruf der Methode VisitLeaf(ILeafNode) zum Start der Abarbeitung aller Knoten übergeben.

public class LeafProcessing : LeafVisitor
{
    private ILeafNode _leafNode;

    public LeafProcessing(ILeafNode rootNode)
    {
        this._leafNode = rootNode;
    }

    public void StartProcessing()
    {
        LeafProcessor processor = new LeafProcessor();
        processor.VisitLeaf(_leafNode);
    }
}

Der Einstieg in den Test erfolgt durch das notorische Button1_Click einer Form. Weitaus mehr von Bedeutung ist der Inhalt der Methode. Es wird ein neuer Basisknoten vom Typ LeafBaseType mit zwei Kind-Elementen erzeugt. Dieser wird dann, wie bereits oben beschrieben, an das LeafProcessing übergeben.

LeafBaseType leafBaseType = new LeafBaseType(
    new ILeafNode[]
    {
        new LeafSubType1(),
        new LeafSubType2()
    });
    
    LeafProcessing processor = new LeafProcessing(leafBaseType);
    processor.StartProcessing();

 

Wird das Programm einmal laufen lassen, sieht der Output dann auch wie erwartet aus:

output

Die Objekte wurden nacheinander, hierarchisch durchlaufen und die Typennamen in die Konsole geschrieben. Und das ohne, dass die Knoten selbst wussten, was von ihnen erwartet wurde. So ist die Datenhaltung und die Verarbeitung vollständig unabhängig voneinander. Darüber hinaus ist es sauber und einfach erweiterbar. Ein neuer SubType3 kann hinzugefügt werden und für dessen Abarbeitung muss dieser nur noch in die Liste aufgenommen werden – Voila – der Rest erfolgt von selbst.

LeafBaseType leafBaseType = new LeafBaseType(
    new ILeafNode[]
    {
        new LeafSubType1(),
        new LeafSubType2(),
        new LeafSubType3()
    });

Das Modell könnte noch etwas optimiert werden, allerdings bin ich mir über die Veränderungen noch unschlüssig…  Vermutlich werde ich noch den Zugriff des OutputBuilders auf Ressourcen des LeafNodes verändern. Die Benennung der einzelnen Methoden des Visitors sind auch noch nicht ganz glücklich.

Wer sich für die Implementierung interessiert kann den Code hier herunter laden.

Wenn Ihr noch Anmerkungen, Kommentare oder Verbesserungsvorschläge habt, sind sie immer willkommen! :-)

Felder vs Eigenschaften

01.02.2010 09:37:00 | Peter Bucher

Am 13. Oktober 2008 haben Golo Roden und ich unter dem Titel Noch Fragen, Roden? Ja, Bucher! angekündigt, jeweils zum ersten eines jeden Monats einen Kommentar zu einem vorab gemeinsam gewählten Thema verfassen zu wollen.

Bisher sind in dieser Reihe folgende Kommentare erschienen:

Heute, am 1. Februar 2010, ist es nun wieder so weit, und unser Thema für diesen Monat lautet:

Felder vs Eigenschaften

So wohl Golo wie auch ich haben uns unabhängig voneinander im Vorfeld unsere Gedanken gemacht, wie wir diesem Thema gegenüberstehen. Golos Kommentar findet sich zeitgleich in seinem Blog, folgend nun mein Kommentar zu diesem Thema:

An mehreren Orten wird debattiert, ob es nun besser sei eine öffentliche Eigenschaft, oder öffentliches Feld zu benutzen.
Teilweise gehen die Meinungen Richtung KISS oder YAGNI, was auch teilweise nachvollziehbar war, als es noch keine automatischen Eigenschaften gab.

Eine Eigenschaft ist jedoch nicht dasselbe wie ein Feld, es hat eine andere Bedeutung.
Während ein Feld nur ein einfacher Datencontainer darstellt, also eine Variable auf Instanzebene, repräsentiert eine Eigenschaft eine Schnittstelle zu Daten jeglicher Art.
Eine Eigenschaft kann bspw. auch Daten aus mehreren Feldern und noch einer zusätzlichen Berechnung haben.

Die Implementierung einer Eigenschaft kann ohne Bedenken geändert werden, ohne das ein Benutzer neu kompilieren muss, es besteht also eine binäre Kompatibilität.
Das ist ein nicht zu unterschätzender Vorteil gegenüber Feldern, der es durchaus Wert ist, mehr Schreibarbeit und Code auf sich zu nehmen.

In den Framework Design Guidelines von Microsoft steht unter anderem auch:

Do not use instance fields that are public

Zu all diesen Vorteilen kommt noch hinzu, das beim Databinding explizit öffentliche Eignschaften gefordert sind.

Der aus meiner Sicht einzige Vorteil von öffentlichen Feldern ist Geschwindigkeit, sie sind definitiv schneller.
Allerdings sollte sowas - nur wenn nötig (Siehe auch Speedfreak) - auch nur in einer internen API so genutzt werden, die unter eigener Kontrolle steht.

Werden alle Vorteile der Eigenschaften zusammengezogen und ist keine Optimierung nötig, sollte immer eine Eigenschaft anstelle eines öffentlichen Feldes genutzt werden.

PS: Das Buch Framework Design Guidelines ist sehr zu empfehlen!

Regeln | Impressum