.NET-Blogs Archiv August 2010

Nutzer des IE 6 sehen sie im Internet immer häufiger: mehr oder weniger diskrete Hinweise, dass der genutzte Browser veraltet wäre und man doch bitte die aktuelle Version einspielen, oder aber einen alternativen Browser einsetzen solle.

Gegen solche Hinweise habe ich nichts einzuwenden. Schließlich ist der IE 6 nun wirklich kein aktueller Browser mehr und aufgrund seiner vielen bekannten Fehler bei der Darstellung von standardkonformen (X)HTML / CSS ist es für den Webdesigner nur unter großem Aufwand möglich, einen Internetauftritt so zu gestallten, dass er sowohl in standardkonformen Browsern und im IE 6 vernünftig aussieht. Außerdem sollte man auch die zum Teil recht eigenwillige Implementierung des DOMs und von JavaScript nicht vergessen, die den IE 6 auch für JavaScript Entwickler schnell zum Alptraum werden lassen.

Türsteher

Heute kam mir jedoch eine sehr restriktive Variante des bekannten “Rette deine Seele und nutze einen moderneren Browser” Hinweises unter: Und zwar wollte ich kurz einen Eintrag auf Jan Welkers Blog lesen, der meine Aufmerksamkeit erregt hatte. (Anmerkung: Ich schätze Jan wirklich sehr! Dieser Beitrag soll sich nicht persönlich gegen ihn richten!) Nach dem Öffnen des Beitrags im Browser bekam ich jedoch nicht die gewünschte Information zugesicht, sondern wurde automatisch auf eine Seite weitergeleitet, die mir freundlich erklärte, dass man meinen Browser nicht möge und ich doch bitte mit einem neueren oder anderen Browser wieder kommen soll. Ab diesem Augenblick war ich also ausgesperrt. Ausgesperrt, weil der Rechner an dem ich saß (es war nicht mein Rechner) von der dortigen IT Abteilung nur den IE 6 installiert bekommen hatte.

Nun wusste ich also endlich, wie sich meine Freunde vor 15 Jahren gefühlt haben müssen, als der Türsteher vor der Disco sagte “Du kommst hier nicht rein! Deine Klamotten gefallen mir nicht!”. Tja, damals lachte ich noch über die Jungs, die die Kleidung noch morgens von ihrer Mutter herausgelegt bekamen und mit diesem Outfit dann halt nicht in die Disco kamen. Heute war ich es jedoch, der im wahrsten Sinne des Wortes dumm aus der Wäsche guckte.

Gegenwind

Etwas missmutig über das gerade geschehene wechselte ich auf Twitter – wo ich im Übrigen nur einen Hinweis “your browser is outdated” erhielt – und fragte Jan, oder die Idee mit dem Aussperren wirklich für so gut hält.

Leider bekam ich bis jetzt noch keine Antwort Jan, dafür aber von anderen bekannten Gesicherten der Community, die zu meiner Verwunderung Jans Strategie vollstens unterstützten und zum Teil sogar das gleiche taten.

Grob zusammengefasst lauteten die Argumente:

• Wenn mehr große Webseiten genauso agieren würden, wäre der IE 6 endlich weg
• Der Aufwand für ein IE 6 konformes Layout ist im Vergleich zum Nutzen viel zu groß

Beide Argumente kann ich sehr gut nachvollziehen – und um eines ganz klar zu stellen: Ich bin kein Fan des IE 6. Auch mich hat er, wie wahrscheinlich die meisten Webentwickler bereits viel Zeit, Nerven und Haare (nein, Haare nicht: die waren schon vor dem IE 6 weg ;-) gekostet.

Wie denn sonst?

Trotzdem halte ich wenig vom aktiven Aussperren von interessierten Nutzern (m)einer Website. Für weitaus besser und vor allem anwenderfreundlicher halte ich es in den meisten Fällen, im Falle des IE 6 einen Hinweis einzublenden, dass der genutzte Browser nicht aktuell ist, was dazu führen könnte, dass sowohl Darstellungs-, als auch Funktionsfehler auftreten.

Über diesen Weg habe ich niemanden den Zugriff auf die von mir bereitgestellten Informationen verwehrt und Nutzer veralteter Browser trotzdem über mögliche Fehler auf der Seite, welche durch ihn verschuldet sind, informiert.

Wenn ich nämlich kurz überlege, warum jemand noch den IE 6 einsetzen könnte, dann fallen mir folgende Gründe ein:

1. Geringe Computerkenntnisse:
   Der IE 6 war vorinstalliert und der Anwender ist sich entweder nicht bewusst, dass er updaten sollte, oder aber traut sich dies nicht zu.
2. Falsche Informationen:
   Ein befreundeter “Computerspezialist” hat dem (laienhaften) Anwender erzählt, dass der IE 6 der schnellste Browser sei, weil er schon so alt ist und deshalb auf moderner Hardware besonders schnell läuft.
3. Faulheit:
   Der Anwender weiss zwar, dass der IE 6 fehlerhaft ist, hat ihn aber aus dem selben Grund noch installiert, aus dem er auch keine regelmäßigen Backups macht und keinen bzw. keinen aktuellen Virenscanner hat.
4. Gewohnheit:
   Der Anwender nutzt den IE 6 bereits seit Jahren, kommt gut mit ihm zurecht und will deshalb gar nicht updaten.
5. Abhängigkeiten von alten, aber wichtigen Intranet Anwendungen:
   Der Anwender würde gerne updaten, kann es aber nicht, weil seine geschäftskritische Intranetanwendung nur vernünftig unter dem IE 6 läuft (ja, das soll es auch geben ;-)).
6. Die IT-Abteilung:
   Der Anwender würde gerne upgraden, hat gar keine Rechte dies zu tun. Die IT-Abteilung hingegen weigert sich gegen das Update, weil sie dann vielleicht eine Liste unzähliger Intranetanwendungen auf Kompatibilität testen und den neueren IE direkt auf unmengen von Clients ausrollen müsste.

Wenn ich nun auf diese Liste Blicke frage ich mich, welche Kategorie ich wirklich von meinem Internetangebot ausschließen möchte. Drei und Vier wären vielleicht geeignete Kandidaten, der ganze Rest jedoch eigentlich nicht. Und selbst bei drei und vier frage ich mich, ob man hier nicht doch die Freiheit gewähren sollte mit einem Browser der Wahl zu arbeiten.

Wenn das Ergebnis dann anschließend nicht vernünftig aussieht: Selber schuld!

Mein Appell

Mein Aufruf an die Betreiber von Webangeboten lautet daher: Schließt keine interessierten Anwender aus! Informiert lieber dezent, dass der Browser und somit das Ergebnis nicht optimal ist, aber lasst IE 6 User nicht draußen warten!

Denn wenn wir tief in uns gehen und uns ehrlich fragen, ob durch das Aussperren des IE 6

• die Welt besser wird?
• das Web besser wird?
• Der IE 6 schneller aussterben wird

dann müssen wir, oder zumindest ich diese Fragen wohl mit nein beantworten. Dies ist übrigens die gleiche Antwort, die man wahrscheinlich auf die Frage:

• Wird der User den ich eben wegen seines Browsers ausgesperrt habe jemals wieder kommen?

In diesem Sinne: http://saveie6.com/ ;-)

Natürlich lasse ich mich aber auch gerne vom Gegenteil überzeugen. Sprich: Eure Meinung zu diesem Thema interessiert mich sehr.

This post is powered by www.Giza-Blog.de |
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

Das INETA Deutschland Speakers Bureau hat erneut eine Spende von Microsoft Deutschland erhalten! :-)

Nach nun über 3 Jahren (gegründet im April 2008) hat sich das Speakers Bureau etabliert. Als erster Sponsor war Microsoft Deutschland dabei, darum freut es mich unheimlich, dass wir zum dritten Mal Sponsoring von Microsoft Deutschland bekommen! Somit können wir auch weiterhin diesen Service für die INETA Deutschland User Groups aufrecht erhalten. Mittlerweile haben wir 63 mal Sprecher zu verschiedenen User Groups schicken können, auch die Sprecherliste ist auf 22 Sprecher angewachsen.

Da bleibt mir einfach nur DANKE für die Unterstützung zu sagen!

Wie du einen Sprecher für deine User Group anfordern kannst, steht hier.

Aktuelle Sprecherliste des INETA Deutschland Speaker Bureau:

• Schissler, Thomas
• Lorenz, Patrick A.
• Keller, Lars
• Weigelt, Roland
• Raacke, Mathias
• Schwichtenberg, Dr. Holger
• Weinert, Albert
• Weber, Torsten
• Sommer, Oliver
• Klein, Constantin
• Dobermann, Mirko
• Lieser, Stefan
• Biswanger, Gregor
• Forkmann, Steffen
• Freiberger, Jörg
• Jaros, Gerhard
• Samaschke, Karsten
• Fisher, Daniel
• Neumann, Jörg
• Golo Roden
• Damir Dobric
• Thorsten Kansy

Weitere deutsche Speakers gibt es auch im INETA Europe Speaker Bureau, welches von der INETA Europe verwaltet wird.

Das INETA Deutschland Speakers Bureau sucht noch weitere Sponsoren! Interesse? Dann schicken Sie mir gern eine E-Mail und wir sprechen über die Möglichkeiten: keller [at] ineta-germany [dot] org

Neben der wpzone, welche bereits einiges an WP7 Informationen und Hilfe zum Thema Entwicklung und Co bietet, gesellt sich seit heute das offizielle deutsche WP7 MSDN Forum dazu. Somit wird das bereits bestehenden Windows Mobile MSDN Forum und Windows Embedded MSDN Forum komplettiert.

Am 10.09. findet wieder einmal die NRW Conf in diesem Jahr in Wuppertal statt.

Auch ich darf dieses Jahr mit dabei sein und haben einen Leckerbissen für euch dabei: Sofern ihr bereits eine WP7 Anwendung habt, die mal auf einem echten WP7-Gerät getestet werden soll, so habt ihr hier die exklusive und meines Wissens nach erste deutsche Möglichkeit dazu. Die Session hierzu findet zwischen 10 und 11 Uhr statt.

Ich freue mich bereits auf euch.

Update: Teilnehmer der NRW Conf haben die Möglichkeit jeweils ein von 2 Gutscheinen für unser kommend erscheinendes Buch zu gewinnen. Mitmachen lohnt sich also.

This post is powered by www.Giza-Blog.de |
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

If you are using different assemblies for your Windows Phone 7 application and your data / model which you wnat to be thomstoned then you get a “using unknown type” exception, if you come back to your Windows Phone 7 application. The reason for this ist, that the current Windows Phone 7 SDK has the bug that after thombstoning only the application assembly will be loaded. This bug will be fixed in the release :-)

The workaround for this problem is to put your data / model classes which will be used for thombstoning in the Windows Phone 7 application assembly.

Hope this tip will help anybody – it costs me nearly a day……

Last week I met Jeff Wilcox from Microsoft in my new Windows Phone 7 project for a big Telephone company in Germany. He gave us the following tip for improving performance of Silverlight applications concerning the often using NotifyPropertyChanged method. The tip is to store the event arguments in a dictionary to avoid the recreation every time.

   1: private static Dictionary<string, PropertyChangedEventArgs> _argumentInstances = new Dictionary<string, PropertyChangedEventArgs>(); 

   2:        

   3:        protected void NotifyPropertyChanged(String propertyName)

   4:        {

   5:            PropertyChangedEventHandler handler = PropertyChanged;

   6:  

   7:            if (null != handler)

   8:            {

   9:                PropertyChangedEventArgs args;

  10:  

  11:                if (!_argumentInstances.TryGetValue(propertyName, out args))

  12:                {

  13:                    args = new PropertyChangedEventArgs(propertyName);

  14:                    _argumentInstances[propertyName] = args;

  15:                }

  16:                

  17:                handler(this, args);

  18:            }

  19:        }

Die Vortragsfolien zu meinem gestrigen Vortrag auf der See# Party in Kreuzlingen stehen nun zum Download als PDF bereit:

• Grundlagen
• Gestaltung
• User Experience
• Verschiedenes
• Anhang (Buchempfehlungen u.ä.)

An dieser Stelle ein Dankeschön an die Organisatoren – ich kann nachvollziehen, wieviel Arbeit in einer solchen Community-Konferenz steckt.

Und auch ein Dankeschön an meine Zuschauer, die trotz des schwierigen Termins direkt nach dem Mittagessen wach geblieben sind und nach Abschluss des eigentlich geplanten Teils sich mit überwältigender Mehrheit für eine kleine Zugabe ausgesprochen haben.

Nach dem Vortrag gab es dann noch eine Ganze Reihe interessanter Gespräche, die mir sehr viel Spaß gemacht haben. Das positive Feedback ist eine schöne Belohnung für die Vorbereitung, die sich als deutlich zeitraubender als geplant herausgestellt hat.

Ich werde den Vortrag übrigens in nächster Zeit nochmal in diversen User Groups halten, entsprechende Ankündigungen folgen.

Die erste See# Party ist für dieses Jahr vorbei und die Leser dieses Beitrages – welche die wunderbare Session von Rainer Stropek nicht gesehen haben – werden sich vielleicht wundern was das für ein blöder Titel ist ;-)

(“LINQ ist wie eine Taube…” und Extension Methods sind die “Kuckuckseier” die anderen Klassen untergejubelt werden können)

Wie habe ich die See# Party erlebt?

Es waren für uns drei Tage pure Action :-) Insgesamt gesehen hat es – trotz aller Pannen, die es aus meiner Sicht gab – dennoch irgendwie Spaß gemacht. Aber ich werde mich nicht nochmal überreden lassen eine eigene Session zu machen, wenn ich eine solche Veranstaltung organisiere. Mit dem Kopf bei der Veranstaltung, aber nicht bei der Session zu sein, ist sowohl anstrengend für die Besucher der Session, als auch für den Speaker…

Die Erfahrung war es allerdings absolut wert diese Veranstaltung zu machen. Den Spaß an der Sache hatte ich aber bei den Gesprächen mit den Teilnehmern und Speakern. Spaß macht es auch wenn hochkarätige Speaker wie Laurend Bugnion tatsächlich den Weg auf sich nehmen um auf der See# Party zu sprechen. Wenn Speaker aus der deutschsprachigen Community kommen um Vorträge zu halten. Und auch wenn neue Speaker die Möglichkeit nutzen, ihre erste Session auf einer Konferenz zu halten.

Spaß macht es auch, wenn man gerade zur rechten Zeit in eine Session kommt, in der Reiner Stropek LINQ zu einer Taube mit Kuckuckseiern macht. (@Rainer: ich finde den Vergleich sowohl absolut passend als lustig) Spass macht es auch, wenn Golo Roden die KeyNote zu ALT.NET genau so hält, wie man sie sich vorgestellt hat. (Es gab keine Absprache über das WIE, nur das Thema selber)

Bestätigt wird man auch, wenn Thomas Scheuermann trotz Sintflut in Nürnberg und überschwemmten Keller, die Reise auf sich nimmt um seine Session zu halten und anschließend wieder nach Hause fährt um den Keller wieder in Ordnung zu bringen. (@Thomas: vielen, vielen, vielen Dank dafür. Mehr weiß ich einfach nicht zu sagen *sprachlos*)

Leider habe ich nicht alle Sessions besuchen können... Aber dem Feedback nach, hätten sehr viele Leute gerne mehr als nur vier Sessions besucht. Auch das ist eine Bestätigung dass die Auswahl der Themen und der Sprecher tatsächlich gelungen ist. Auch das wurde mir immer wieder gesagt. Leider konnte ich auch keine der Sessions komplett besuchen, sondern bin mit meiner kleinen Kamera von einer Session zu anderen um noch ein paar Erinnerungen aufzufangen (Die Bilder werde ich in einer Wochen auf der Website publizieren)

#ssp2011?

Wie man aus dem obigen Text vielleicht lesen mag, geht der Trent zu einer See# Party 2011: Einer .NET Community Konferenz für den südlichen Raum der deutschsprachigen .NET Community (Süddeutschland, die Schweiz, Vorarlberg und Liechtenstein)

Darüber werde ich in den nächsten Tagen ausführlich nachdenken. Diese See# Party war durch die viel zu kurze Planungszeit enorm schwierig und chaotisch. Auch wurden unsere Erwartungen dadurch an manchen Stellen nicht komplett erfüllt. (Vor allem durch die viel kleiner Teilnehmerzahl wird es enorm schwierig sein die Kosten zu decken)

Es gibt auf jeden Fall eine große Liste mit Dingen die beim nächsten Mal besser gemacht werden können und müssen.

In acht Tagen werden wir uns wieder zusammensetzen und darüber reden, wie diese allererste See# Party war und wie es mit weiteren See# Partys weiter gehen könnte. Bis dahin bin ich auf einer Berghütte in der Schweiz, ohne Strom, ohne Internet und ohne Telefon. :-)

This post is powered by www.Giza-Blog.de |
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

Ein Hinweis in eigener Sache, auch weil viele Anfragen dazu in letzter Zeit mich erreicht haben: In Microsofts offiziellen Community Guide findet man ja bereits viele Social Media-Angebote von Microsoft, seien es Portale, Blogs, Twitter, Facebook- oder Xing-Gruppen, Foren oder RSS-Feeds. Sollten Sie Mitglied im sozialen Netzwerk LinkedIn sein, möchte ich Sie herzlich einladen, unsere brandneue offizielle MSDN-Gruppe bei LinkedIn zu besuchen. Wir würden uns sehr über einen Austausch und Dialog dort mit Ihnen freuen!

Folgen Sie uns auf LinkedIn:

Folgen Sie uns auf Twitter:


Hier finden Sie weitere Social Media-Angebote von Microsoft.

This post is powered by www.Giza-Blog.de |
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

Das geht? Na ja – es könnten schon mal 5 oder 10 Zeilen werden, aber 3 haben wir auch schon gesehen :-) Wie einfach man mit bzw. für Windows 7 Software entwickeln kann, zeigen eine Reihe von ausgewählten Artikel im Microsoft Developer Network (MSDN). Sie zeigen wie Sie mit wenig Aufwand (und wirklich fast ohne Code) nützliche „Windows 7“-Funktionen in Ihre Anwendungen einbauen können. Für alle vorgestellten Beispiele finden Sie in den Tutorials auch gleich lauffähige Projekte für Visual Studio 2010 zum Herunterladen, die Sie nur noch entpacken und aufrufen müssen:

Erste Schritte mit der WPF Ribbon in Visual Studio
Mit Microsoft Office 2007 wurde ein neues Konzept für die Steuerung von Anwendungen eingeführt. Das Ribbon ist ein „Gummi-Band“, in das sich die Funktionen einer Anwendung dynamisch einordnen lassen. Damit dient das Ribbon als eine Alternative zur herkömmlichen Menüleiste.

Erste Schritte mit der Startleiste
Die neue Startleiste in Windows 7 bringt sehr viele neue Funktionen mit sich. Früher verbarg sich auf dem Kontextmenü eines Symbols in der Startleiste ein schnörkelloses Kontextmenü. Mit Windows 7 hat man dieses vollständig renoviert und mit vielen neuen Funktionen versehen.

Multi-Touch mit Microsoft Surface Touch Toolkit
Das Microsoft Surface Toolkit for Windows Touch ermöglicht es WPF-Entwicklern, eigene Multi-Touch-Anwendungen zu erstellen, die genauso einfach entwickelt werden können wie „echte“ Surface-Anwendungen. Wichtig: Um das Toolkit verwenden und aktiv einsetzen zu können, benötigt man keinen Surface-Tisch!

Suchen im lokalen Netzwerk und auf dem lokalen Rechner
In Windows 7 befinden sich sehr mächtige und granular steuerbare Suchfunktionen. Das Einbinden dieser Funktionen in eigene Visual C#- oder Visual Basic-Anwendungen ist dank des Windows API Code Packs sehr einfach.

Energieeffiziente Anwendungen mit Windows 7 entwickeln
In Windows 7 wurden diverse Mechanismen für verbessertes Energiemanagement integriert. Über die Systemsteuerung kann der Benutzer sein persönliches Energieschema einstellen, das je nach Stromzufuhr (Batterie oder Netzteil) mehr oder weniger Ressourcen benötigt.

Weiterführende Informationen, wie Sie innovative Windows 7-Funktionen praktisch „out of the box“ in Ihre Anwendungen einbauen können, finden Sie in unserem MSDN Windows 7 Developer Center. Zahlreiche kostenfrei zugängliche deutschsprachige Webcasts und CodeClips finden Sie im MSDN Finder.

Immer wieder wurde es angedeutet, doch heute darf ich es offiziell sagen: Patrick Getzmann, Simon Hackfort und ich schreiben ein Entwicklerbuch. Wie sollte es denn dann auch anders sein, dass es sich um das Thema Entwicklung mit dem Windows Phone 7 handeln wird, an dem wir bereits seit mehren Monaten arbeiten. Natürlich wird es dabei um Silverlight für Windows Phone 7 und das XNA Framework gehen, doch schweigen wir uns noch ein wenig über den exakten Inhalt aus. Soviel sei bereits gesagt: Es werden Themen enthalten sein, die man in anderen Büchern so nicht finden wird. Als kleinen Leckerbissen wird es bereits gegen Ende September eine kleine Preview geben.

Erscheinen wird das ca. 650 Seiten umfassende Buch bei der MS Press. Erscheinen wird es im Dezember.
Es ist bereits auf Amazon vorbestellbar:

Bezugsquelle: Amazon.de
ISBN-10: 3866454627
ISBN-13: 978-3866454620

Preis: 39,90 €

Kleiner Tipp am Rande: Wer die NRW-Conf am 10.09.2010 besucht, hat die Möglichkeit 1 von 2 Gutscheinen für dieses Buch zu gewinnen.

Und weiter geht es mit dem Schreiben…

In diesem Tipp geht es um das Umschalten zwischen einer Debug- und Release-Ansicht im XAML Designer.

Zusammenfassung

Während man im Code mit #if DEBUG zwischen Debug- und Release-Build unterscheiden kann, gibt es etwas Vergleichbares in XAML nicht. Mit Hilfe eines geeigneten Value Converters kann jedoch Abhilfe geschaffen werden.

Beschreibung

Mit dem #if pragma im Quellcode zwischen verschiedenen Builds zu unterscheiden hat wohl jeder Entwickler schon einmal gemacht. Diese Möglichkeit fehlt mir in XAML, da ich beispielsweise bei komplexeren Layouts während der Entwurfsphase gerne mal bestimmte Bereiche unterschiedlich einfärbe. So kann man viel besser erkennen, ob Margins, Paddings etc. stimmen. Ärgerlich dabei ist, dass man so ein buntes Layout zumindest nicht jedem Kunden zeigen kann und es schön wäre, dieses "Debug Layout" im Release-Build einfach abzuschalten zu können.

Natürlich kann man das mit etwas C#-Code einfach hinbekommen, aber eigentlich will ich die Unterschiede der Builds bereits im Designer sehen. Mit Hilfe des Value Converters ConditionalConverter kann man das erreichen. Das folgende XAML-Fragment zeigt exemplarisch ein Grid, welches im Debug-Build rot und im Release-Build blau ist. Natürlich auch zur Laufzeit, aber vor allem im XAML Designer. Durch den Wechsel des Builds in Visual Studio verändert sich die Anzeige des Designs entsprechend:

<Grid Background="{Binding Converter={StaticResource ConditionalConverter}, ConverterParameter='Red|Blue'}"/>

Der ConditionalConverter liefert je nach Build den ersten oder den zweiten Teil des Parameter-Strings zurück. Das funktioniert natürlich auch mit Zahlen, Texten, Margins etc. Zwar liefert der Converter immer nur Strings, aber diese werden beim Zuweisen an die Property von deren Type Converter entsprechend in den richtigen Typ umgewandelt. Wie das in XAML üblich ist.

Auffällig ist, dass das Binding keinen Path hat. Er wird jedoch auch nicht benötigt, denn das Ergebnis hängt nur von ConverterParameter ab. Die Implementierung ist relativ einfach:

public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
  string result = null;
  if (parameter is string)
  {
    var param = ((string)parameter).Split('|');
 
#if DEBUG
    result = param[0];
#else
    if (param.Length >= 2)
      result = param[1];
#endif
  }
 
  // "x:Null" represents the markup extension "{x:Null}".
  if (result == "x:Null")
    result = null;
 
  return result;
}

Das Binding wird zur Designzeit allerdings nur dann ausgeführt, wenn die Property DataContext des Target Objekts und die Source-Property des Bindings nicht beide Null sind, denn in diesem Fall wird der Value Converter gar nicht erst aufgerufen. Sollte dies so sein, kann man die Source-Property im Binding einfach auf irgendeinen Wert setzen, denn da der Path nicht definiert ist, wird sie nicht verwendet. Sie darf nur nicht Null sein:

<Grid Background="{Binding Converter={StaticResource ConditionalConverter},
    Source=xyz,
    ConverterParameter='Red|Blue'}"/>

So ist Source nicht mehr Null und das Binding funktioniert.

Man muss noch beachten, mit dem ConditionalConverter keine Properties zu setzen, die eigentlich durch einen Style gesetzt werden sollten. Das Binding hat Vorrang und der Style kommt nicht zur Anwendung.

Eine weitere theoretische Möglichkeit wäre es, den ConditionalConverter in einem Style zu verwenden, z.B. so:

<Style TargetType="Border">
  <Setter Property="Background"
      Value="{Binding Source=_, ConverterParameter='#FF0000|#00FF00',
      Converter={StaticResource ConditionalConverter}}"/>
</Style>

Das funktioniert aber nicht. Während es in WPF durchaus üblich ist Bindings in Styles zu verwenden, ist diese Funktionalität in Silverlight leider noch nicht implementiert. (Genauer gesagt ist sie bisher nur im Designer implementiert. Das Binding im Style funktioniert bei Silverlight zur Designzeit; wenn man aber die Anwendung startet, gibt es eine Fehlermeldung.)

Expression Blend

In Blend funktioniert das Ganze im Prinzip genauso, allerdings muss hier beachtet werden, dass Blend aktuell ausschließlich Debug-Builds erzeugen kann. Wenn man also in Blend die Release-Ansicht betrachten möchte, muss man vorübergehend die Implementierung von ConditionalConverter ändern. Es reicht, einfach Underscore an #if DEBUG anzufügen und damit die Abfrage umzudrehen.

Code-Beispiel

Zum direkten Ausprobieren gibt es hier noch ein Beispiel: Die MainPage.xaml im Designer öffnen und dann zwischen Debug- und Release-Build hin- und herschalten. Vorher beide Builds einmal compilieren.

ConditionalConverter.zip (16 kB)

Hier geht's zum nächsten Tipp.

This post is powered by www.Giza-Blog.de |
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

This post is powered by www.Giza-Blog.de |
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

With Windows Phone 7 you can integrate your own application seamlessly into the Windows Phone built-in photo viewer. The key to this feature is the Extras.xml file.

You have to place a new xml file with the name Extras.xml to your Windows Phone 7 project root. Set the properties to Copy to Output Directory and select Copy always.

   1: <Extras>

   2:   <PhotosExtrasApplication>

   3:     <Enabled>true</Enabled>

   4:     <StorageFolder>Incoming</StorageFolder>

   5:   </PhotosExtrasApplication>

   6: </Extras>

For the StorageFolder attribute you can choose your own name.

More informations you could find here: How to: Create a Photo Extras Application for Windows Phone

Download:

MSDN download site. 

The major highlight of this release is the addition of the PDO_SQLSRV driver, which adds support for PHP Data Objects (PDO).

Comparison SQLSRV driver and PDO_SQLSRV driver:

SQLSRV driver:

<?php

  $serverName = "(local)\sqlexpress"; 
  $connectionOptions = array( "Database"=>"AdventureWorks" );

  /* Connect to SQL Server using Windows Authentication. */ 
  $conn = sqlsrv_connect( $serverName, $connectionOptions );

  /* Get products by querying against the product name.*/ 
  $tsql = "SELECT ProductID, Name, Color, Size, ListPrice FROM Production.Product";

  /* Execute the query. */ 
  $getProducts = sqlsrv_query( $conn, $tsql );

  /* Loop thru recordset and display each record. */ 
  while( $row = sqlsrv_fetch_array( $getProducts, SQLSRV_FETCH_ASSOC ) ) 
  { 
    print_r( $row ); 
  }

  /* Free the statement and connection resource. */
  sqlsrv_free_stmt( $getProducts );
  sqlsrv_close( $conn );

?>

PDO_SQLSRV driver:

<?php

  $serverName = "(local)\sqlexpress"; 

  /* Connect to SQL Server using Windows Authentication. */ 
  $conn = new PDO( “sqlsrv:server=$serverName;Database=AdventureWorks" );

  /* Get products by querying against the product name.*/ 
  $tsql = "SELECT ProductID, Name, Color, Size, ListPrice FROM Production.Product";

  /* Execute the query. */ 
  $getProducts = $conn->query( $tsql );

  /* Loop thru recordset and display each record. */ 
  while( $row = $getProducts->fetch( PDO::FETCH_ASSOC ) ) 
  { 
    print_r( $row ); 
  }

  /* Free the statement and connection resource. */
  $getProducts = NULL;
  $conn = NULL;

?>

Installation see Here

More Infos: Here

One fantastic feature of Silverlight is that you can "virtualize" the UI objects needed to render a list, reducing the amount of memory and CPU necessary to load large lists. So you can bind a ListBox to 1.000.000 items, but you create only ListBoxItems for the first 100 items. This helps you to make your Windows Phone 7 App a little bit quicker if you want to work with large data lists.

The only thing you have to do is to derive your data source from IList. This fact triggers Silverlight to do data virtualization.

More informations about this feature you can found at Peter Torr’s Blog:

Virtualizing Data in Windows Phone 7 Silverlight Applications - Peter Torr's Blog - Site Home - MSDN Blogs

Letzte Ausgabe von „msdn tv“ vor der Sommerpause - heute mit Studiogast Prof. Dr. Saug sowie Anne, Cortessa, Jessica, Jan und Max, aber ohne den nötigen Ernst.
Statt der üblichen Bits und Bytes erwarten Sie diesmal Prosecco, Sandkuchen und angeregte Gespräche mit einem ganzen Feuerwerk an Themen - in 16:40 Minuten geht’s ohne Sinn und VerstandPunkt und Komma rund um den Microsoft Software Strategy Summit im Oktober in Köln, rote Teppiche, den Keynote-Speaker Steve Ballmer, einen Visual Studio Werbeclip, um Möpsebegehbare Kleiderschränke, Windows Phone 7, Interface Design, Silverlight, XNA, Mobile Gaming, den Windows Marketplace for Mobile, Windows Phone Developer Tools, Tipps zur App-Entwicklung im Weblog von Oliver Scheer und im neuen MSDN Windows Phone Developer Center, um Styleguides für Windows Phone-Entwickler, Xbox Live Avatare, Zune, Windows Azure, steigende Akzeptanz von Cloud Services bei Unternehmen, virtuelle Shopping-Trips, Fitness-Studio, die Xbox-Bewegungssteuerung Kinect, Malibu-Strände, dem tierischen Kinectimals-Game mit Tigern und Möpsen, um Windows Live Skydrive mit 25 Gigabyte kostenlosem Speicherplatz auf Ihrer Online-Festplatte, um häufigen Datenaustausch mit wechselnden Partnern, Schuhkauf, Messenger sowie Anziehtipps. Und um Möpse. Ende der Durchsage.

Anmerkung der Redaktion: alle Darsteller sind voll zurechnungsfähigvolljährig und erhalten im Rahmen des Projekts „Betreutes Arbeiten“ regelmäßige Zuwendungen von Microsoft Deutschland.

msdn tv ist ein neues Video-Nachrichtenformat, und hat seinen Ursprung auf MSDN Online (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.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.

Jürgen Gutsch und ich haben bekanntlich ja den grenzübergreifenden (CH / DE) .NET Stammtisch Konstanz-Kreuzlingen gegründet.
Ich bin leider nicht mehr dort lokalisiert aber natürlich immer noch sehr daran interessiert, das es gut läuft.

Das neue Team rund um Jürgen Gutsch und Tilo Schinke hat eine riesen Arbeit geleistet und stellte in kurzer Zeit eine Konferenz in Kreuzlingen (CH) auf die Beine.
Dabei sind sehr viele bekannte Sprecher, wie beispielsweise Stefan Lieser, Albert Weinert, Ken Cascada uvm, die sehr interessante Vorträge halten werden.

Offizielle Ankündigung:

Es würde mich freuen, euch dort zu sehen! :-)

For quite some time I’m using a tool a co-worker has written to convert some text into “websafe” text. That’s implying the convertion of special characters into html entities wherever possible, otherwise in their corresponding unicode notation (&#0000;), replacing more then one space in a row with non-breaking spaces (&nbsp;), replacing single line-breaks with the corresponding html-tag (<br />) and also enclosing paragraphs with their html-tag (<p>…</p>). Texts converted in this manner are having less or even no encoding problems in any webbrowsers and you don’t have to fiddle around with manual adding those paragraph tags.

I’m using this tool a lot when working with html files directly in Notepad++ or a similar texteditor. But since that time I’m now mainly working within Visual Studio. You may argue that you can add the text in the design-view and Visual Studio is converting it for you. But not all special chars are converted and when the text is some kind of rich edit (e.g. from Word) you get a lot of unwanted formatting, too! So you could paste it into a plain-text editor, copy it back to the clipboardf and then paste it into Vis…. For God’s sake! Let’s abadon this thought immediately before someone will really do it this way! Saying it with a borrowed term: There’s an app for that!

First you have to make a tough decission: Go straight to the Visual Studio Gallery, download, install and just use my “Unicode Converter”-Extension. Or you read on and I will explain a few things about how I solved some problems. Oh, and just in case: there is a link to the sourcecode of the extension at the end of this article!

I started with a new “Shared Add-In”-project, entered all the standard stuff and took a look at the created files. Great, there are a lot of comments and even if you never had created a Visual Studio extension before (like me!) you quickly grasp the base-correlations. So, first step was to implement the main logic: The convertion of a given string. I was allowed to use the prepared hashtables with the html-entities and other special strings, after all a 1.5MB ressource-file. To avoid using the ResourceReader-class I converted that .rersource-file into a .resx-file with the Resource File Generator (Resgen.exe). Filling my hastables with the data from the resource-file starts in the Initialize() method of the extension, right after adding my command to the Visual Studio menu:

protected override void Initialize() {
    base.Initialize();
    OleMenuCommandService mcs =
        GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    if (null != mcs) {
        CommandID menuCommandID =
            new CommandID(
                GuidList.guidUnicodeConverterCmdSet,
                (int)PkgCmdIDList.cmdidUnicode);
        MenuCommand menuItem =
            new MenuCommand(MenuItemCallback, menuCommandID);
        mcs.AddCommand(menuItem);
    }
    fillHash();
}

The actual convertion is happening in three foreach-loops, nothing special here. So let’s take a look at the MenuItemCallback() method that is called whenever my command is started. Let’s enumerate what we want to do here:

1. Get the currently selected text from the editor
2. Convert this text
3. Write the converted text back to the editor, replacing the original one

Sounds pretty easy, doesn’t it? Well, step 1 and 2 are not quite difficult, but step 3 needs some considerations because our Span with the selected text is a readonly-property. So we lookup the index of our selected text, delete the old Span and insert a newly created span with our converted text at the very same position. Phew, that wasn’t that hard, was it? Here we go:

private void MenuItemCallback(object sender, EventArgs e) {
    IVsUIShell uiShell =
        (IVsUIShell)GetService(typeof(SVsUIShell));
    Guid clsid = Guid.Empty;
    IWpfTextView view = GetActiveTextView();
    String selectedText =
        view.Selection.SelectedSpans[0].GetText();
    var allText = view.TextSnapshot.GetText();
    int pos = allText.IndexOf(selectedText);
    OptionPageGrid page =
        (OptionPageGrid)GetDialogPage(typeof(OptionPageGrid));

    convertUnicode(ref selectedText);
    if (page.replaceSpaces)
        replaceDoubleSpace(ref selectedText);
    if (page.replaceNewline)
        replaceNewLine(ref selectedText);

    Span deleteSpan = view.Selection.SelectedSpans[0];
    view.TextBuffer.Delete(deleteSpan);
    view.TextBuffer.Insert(pos, selectedText);
}

Before I did a first test-run I wanted to add my new command to the context menu of the Visual Studio editor instead of creating a new menu entry. So, next stop: The Visual Studio Command Table, a XML-file with the extension .vsct. It took a few minutes until I understood what happend in there. But after some Bing’ing (gosh, that sounds awfull! ) I found the lines I need to change to place my command into the context menu:

<Group guid="guidUnicodeConverterCmdSet" id="UnicodeMenuGroup" priority="0x0600">
    <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_CODEWIN"/>
</Group>

Compiling, installing the Add-In, restarting Visual Studio and… where is my context menu entry?! I opened a simple html file and tried to convert some text in it, but my extension didn’t show up. Well, actually it DID show up but I searched for it at the wrong place: When in a codefile (.cs) I could happily see my context menu entry and it worked like a charm. But why did it only appears in the code editor and not in the html code-view?

I was Bing’ing again like “Big Ben” (knee-slapper…) but all I found were some cryptical information about .h-files with a C++ syntax. There were some GUIDs similiar to those I saw in my command table but when I tried using them as a parent I got some compile-errors. Some time-consuming investigations later (I did not found a hint even in the msdn) I found a small tool, the VSCT PowerToy in the MSDN Code Gallery. It’s “a read-only viewer for Visual Studio 2010 that you can use to explore the commands associated with a VSPackage, and with Visual Studio itself. You can quickly search for any existing commands in the Visual Studio IDE. By browsing through the command groups, GUIDs and IDs, priorities, and other properties of existing commands, you can more easily place and integrate the commands of your own VSPackage.” – sounds pretty good to me: I have no clue how to do it, so I look at others how they accomplished it!

After playing around with the tool for a while I found what I was looking for, the GUIDs and IDs of the context menu used by the html-, aspx-, aspx.cs-, … editors. Yepp, all those editors have their own context menu. It’s even splitted to html in aspx-files, inline-c# in aspx-files and inline-vb in aspx-files. That’s pretty cool when you want to make an extension that’s only working with a subset of all editors or languages! To test my newly found GUIDs and IDs (CMDSETID_HtmEdGrp & IDMX_HTM_SOURCE_HTML) I added them as “parent” to my group and… my build failed again. This GUID and ID are unknown – corresponding to the compiler. Wait, there was a section within my .vsct-file to define my own command-names with their GUID. Perhaps I can add a few more..?

There you are! Even if those GUIDs and IDs are internally used by Visual Studio you have to define them for your extension first. The VSCT PowerToy can switch the view and instead of the name I get the corresponding GUIDs and IDs. After defining them as a GuidSymbol my project compiled without an error and it even showed my context menu entry in the html-editor. Strike!

<GuidSymbol name="CMDSETID_HtmEdGrp"
            value="{d7e8c5e1-bdb8-11d0-9c88-0000f8040a53}">
    <IDSymbol name="IDMX_HTM_SOURCE_BASIC" value="0x32" />
    <IDSymbol name="IDMX_HTM_SOURCE_HTML" value="0x33" />
    <IDSymbol name="IDMX_HTM_SOURCE_SCRIPT" value="0x34" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASPX" value="0x35" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASAX" value="0x3B" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASPX_CODE" value="0x36" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASAX_CODE" value="0x3C" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASPX_CODE_VB" value="0x37" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASAX_CODE_VB" value="0x3D" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASMX_CODE" value="0x38" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASMX_CODE_VB" value="0x39" />
</GuidSymbol>

The next challenge was a no-brainer compared to the last one: I want my extension show up in the context menu not only of the code editor or the html-editor but in several of them at once. A solution was quickly found: With CommandPlacements you can add a command to several places so I added my extension to a few of them in case they make sense to me (“Where could you have some text that has to be websafe?”).

<CommandPlacements>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_CODEWIN"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_HTML"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_SCRIPT"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_ASPX"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_ASAX"/>
    </CommandPlacement>
</CommandPlacements>

And thats it! I didn’t made a step-by-step tutorial how to make a new extension for Visual Studio. There are a lot of other articles and examples around for that. But I thought I show you what problems I was confronted with and how I finally circumnavigate them so that you can learn from my researches.

Last but not least you can take a look at my sourcecode. I’m publishing it under the MS-PL so you are free to use and change it for your purposes but of course it would be great if you could give me a hint in that case. All feedback is greatly appreciated, so leave me a comment or write a message via email, facebook, twitter, … whatever you like

Thanks for reading!

Unicode Converter Sourcecode (691 KB)

In der Vergangenheit habe ich in vielen Projekten, vielen Anwendungen und auch hier im Forum immer wieder die gleichen Fehler bei der Fehlerbehandlung gesehen, was mich dazu veranlasst diesen Beitrag hier zu schreiben.

Im Grunde ist es immer folgender Fehler der beim Try&Catch gemacht wird:

try
{
    [do some errors]
}
Catch (Exception ex)
{
    log.Error(“Meine super duper Fehlermeldung”);
    throw ex;
}

Das ist dann keine Fehlerbehandlung, sondern eher Fehler verstecken!

Oftmals wird dieses Konstrukt (“Fehlerbehandlung” mochte ich es nicht nennen) in jeder Methode genutzt die aufgerufen wird. Das hat dann den Effekt, dass dieses Konstrukt logisch wie folgt verschachtelt wird:

try
{
    try
    {
        try
       {
            try
           {
                [do some errors]
          }
           Catch (Exception ex)
            {
                log.Error(“Meine erste super duper Fehlermeldung”);
                throw ex;
           }
       }
        Catch (Exception ex)
        {
            log.Error(“Meine zweite super duper Fehlermeldung”);
           throw ex;
       }
    }
    Catch (Exception ex)
    {
       log.Error(“Meine dritte super duper Fehlermeldung”);
        throw ex;
    }
}
Catch (Exception ex)
{
    log.Error(“Meine vierte super duper Fehlermeldung”);
    throw ex;
}

Oftmals wird wenigstens die aktuelle Exception dem Logger übergeben:

Catch (Exception ex)
{
    log.Error(“Meine vierte super duper Fehlermeldung”, ex);
    throw ex;
}

Aber auch das ist nur die halbe Miete.

Was soll da falsch sein ?

Schauen wir uns nochmal das erst Stück Code an. Angenommen es passiert ein Fehler und das Programm, springt in den Catch-Teil. Jetzt geht der Unsinn los:

1. Es wird eine Unsinnige Fehlermeldung ausgegeben!
   Warum?
   Falls die Meldung noch relevant sein sollte, enthält sie keine weiteren Informationen zu der eigentlichen Exception. Im Normalfall wurde der Code allerdings im Laufe der projektphase immer wieder geändert, was zur Folge hat, das die Nachricht längst nicht mehr stimmt oder es gibt inzwischen mehrere mögliche Fehlerquellen.
2. throw ex ist der nächste grobe Fehler: es wird zwar die selbe Exception noch einmal geworfen, mit der selben Fehlermeldung, allerdings wird der immens Wichtige StackTrace abgeschnitten (“breaking the stack”). Der StackTrace beginnt ab der Methode in der throw ex aufgerufen wird. Sollte der Fehler in einer aufgerufenen Komponente auftauchen, kann das nicht mehr ermittelt werden. Es wird immer so aussehen, als wäre der Fehler in der aktuelle Methode aufgetreten, und zwar genau dort, wo thro ex aufgerufen worden ist. Genauso wie der StackTrace geht auch die InnerEception verloren (Danke an Peter für den Hinweis.)
3. Selbst wenn die Exception an den Logger übergeben wird ist die Fehlerbehandlung unvollständig, denn es wird nur ein unvollständiger StackTrace gelogt.

Im Falle der verschachtelten Try&Catches sieht das so aus, dass 1. keine relevanten Fehlerinformationen geloggt werden und 2. jedes Mal der StackTrace bei jedem Catch von neuem beginnt.

Diese Fehlerbehandlung ist somit keine, sondern eine Selbsttäuschung.

Das wird man spätestens dann merken, wenn man als Entwickler vom Support die Meldung über einen Fehler bekommt und dann das Log-File analysieren muss. Ich wette das viele Fehler nicht per Log-File gefunden werden können.

Was ist zu tun?

Im ersten Schritt sollten alle throw ex Aufrufe durch ein einfaches throw ersetzt werden. Das führt dazu, dass die aufgetretene Exception genau so wie sie ist, nach “oben” weitergeleitet wird. Dann sollte das Logging angepasst werden: Bei einem einfachen Try&Catch sollte das Logging – wenn möglich – so geändert werden, dass die Exception an den Logger übergeben wird (Die meisten Logger sollten das Unterstützen):

try
{
    [do some errors]
}
Catch (Exception ex)
{
    log.Error(ex);
    throw;
}

Im Fall der Verschachtelten Try&Catches wird nun noch an jeder Stelle in das Log geschrieben. Das ist nicht sinnvoll, das dadurch das Log sehr groß werden kann und die Informationen mehrfach im Log vorhanden sind. Es sollte also nur an einer Stelle geloggt werden und zwar am besten ganz oben, beim letzten Try&Catch.

In ASP.NET kann das sogar in der global.asax bei Application_Error gemacht werden.

Die verschachtelten TryCatches sehen dann logisch wie folgt aus:

try
{
    try
    {
        try
       {
           try
           {
                [do some errors]
           }
           Catch (Exception ex)
           {
                throw;
           }
        }
        Catch (Exception ex)
        {
           throw;
        }
    }
    Catch (Exception ex)
    {
        throw;
    }
}
Catch (Exception ex)
{
    log.Error(ex);
    HandleTheException();
}

Im letzten Catch wird dann die eigentliche Fehlerbehandlung gemacht: Es wird dem Benutzer eine sinnvolle Meldung ausgegeben (Nicht die Fehlermeldung, mit der kann der Benutzer nichts anfangen!)

Nach diesem Refactoring, sollte man sich  fragen welche Try&Catches dann noch Sinn machen, wen nichts anderes Passiert, als die Exceptions durchzureichen. Ich bin ganz sicher, dass man einige nun Entfernen könnte.

Generell sollte man nicht grundlos alle möglichen Fehler abfangen, sondern in erster Linie Fehler vermeiden. Natürlich gibt es Stellen, bei denen man Fehler nicht Verhindern kann, das ist immer dann der Fall, wenn man aus seiner Anwendung raus auf etwas zugreift: Datenbank und Dateizugriffe, Web- und Webservice-Zugriffe, COM, etc.

Auf diese Art hat man nun schon mal eine relativ saubere Fehlerbehandlung.

Aber es geht immer noch besser:

An Stellen, an denen mögliche Fehler nicht verhindert werden können, können diese abgefangen und mit einer eigenen Exception nach “oben” weitergeben werden. Die ursprüngliche Exception wird dabei als InnerException mitgegeben:

Catch (Exception ex)
{
    throw new MyVeryOwnHttpException(ex)
}

So kann man in der Darstellungsschicht individuell auf die Fehler reagieren und dem Benutzer einen entsprechenden Hinweis geben:

Catch (MyVeryOwnHttpException ex)
{
    log.Error(ex.InnerException);
    HandleTheVeryOwnHttpException(“Die Verbindung zum Server konnte nicht hergestellt werden.\n Bitte prüfen Sie ob Sie mit dem Internet Verbunden sind.\nUnd so weiter und so fort”, ex);
}

Man kann so spezielle Arten von Ausnahmen zusammenfassen und entsprechend drauf reagieren. Es ist dem Anwender in der Regel egal, was der genaue Fehler ist. Ob das jetzt ein Verbindungsfehler ist oder der Server einen Fehler zurückgibt ist egal. Wichtig ist, dass in diesem Fall die Anwendung nicht mit dem Server kommunizieren kann.

In der Log-File steht auf jeden Fall der konkrete Fehler mit dem kompletten StackTrace und die Fehlersuche wird dadurch wesentlich vereinfacht.

For quite some time I’m using a tool a co-worker has written to convert some text into “websafe” text. That’s implying the convertion of special characters into html entities wherever possible, otherwise in their corresponding unicode notation (&#0000;), replacing more then one space in a row with non-breaking spaces (&nbsp;), replacing single line-breaks with the corresponding html-tag (<br />) and also enclosing paragraphs with their html-tag (<p>…</p>). Texts converted in this manner are having less or even no encoding problems in any webbrowsers and you don’t have to fiddle around with manual adding those paragraph tags.

I’m using this tool a lot when working with html files directly in Notepad++ or a similar texteditor. But since that time I’m now mainly working within Visual Studio. You may argue that you can add the text in the design-view and Visual Studio is converting it for you. But not all special chars are converted and when the text is some kind of rich edit (e.g. from Word) you get a lot of unwanted formatting, too! So you could paste it into a plain-text editor, copy it back to the clipboardf and then paste it into Vis…. For God’s sake! Let’s abadon this thought immediately before someone will really do it this way! Saying it with a borrowed term: There’s an app for that!

First you have to make a tough decission: Go straight to the Visual Studio Gallery, download, install and just use my “Unicode Converter”-Extension. Or you read on and I will explain a few things about how I solved some problems. Oh, and just in case: there is a link to the sourcecode of the extension at the end of this article!

I started with a new “Shared Add-In”-project, entered all the standard stuff and took a look at the created files. Great, there are a lot of comments and even if you never had created a Visual Studio extension before (like me!) you quickly grasp the base-correlations. So, first step was to implement the main logic: The convertion of a given string. I was allowed to use the prepared hashtables with the html-entities and other special strings, after all a 1.5MB ressource-file. To avoid using the ResourceReader-class I converted that .rersource-file into a .resx-file with the Resource File Generator (Resgen.exe). Filling my hastables with the data from the resource-file starts in the Initialize() method of the extension, right after adding my command to the Visual Studio menu:

protected override void Initialize() {
    base.Initialize();
    OleMenuCommandService mcs =
        GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    if (null != mcs) {
        CommandID menuCommandID =
            new CommandID(
                GuidList.guidUnicodeConverterCmdSet,
                (int)PkgCmdIDList.cmdidUnicode);
        MenuCommand menuItem =
            new MenuCommand(MenuItemCallback, menuCommandID);
        mcs.AddCommand(menuItem);
    }
    fillHash();
}

The actual convertion is happening in three foreach-loops, nothing special here. So let’s take a look at the MenuItemCallback() method that is called whenever my command is started. Let’s enumerate what we want to do here:

1. Get the currently selected text from the editor
2. Convert this text
3. Write the converted text back to the editor, replacing the original one

Sounds pretty easy, doesn’t it? Well, step 1 and 2 are not quite difficult, but step 3 needs some considerations because our Span with the selected text is a readonly-property. So we lookup the index of our selected text, delete the old Span and insert a newly created span with our converted text at the very same position. Phew, that wasn’t that hard, was it? Here we go:

private void MenuItemCallback(object sender, EventArgs e) {
    IVsUIShell uiShell =
        (IVsUIShell)GetService(typeof(SVsUIShell));
    Guid clsid = Guid.Empty;
    IWpfTextView view = GetActiveTextView();
    String selectedText =
        view.Selection.SelectedSpans[0].GetText();
    var allText = view.TextSnapshot.GetText();
    int pos = allText.IndexOf(selectedText);
    OptionPageGrid page =
        (OptionPageGrid)GetDialogPage(typeof(OptionPageGrid));

    convertUnicode(ref selectedText);
    if (page.replaceSpaces)
        replaceDoubleSpace(ref selectedText);
    if (page.replaceNewline)
        replaceNewLine(ref selectedText);

    Span deleteSpan = view.Selection.SelectedSpans[0];
    view.TextBuffer.Delete(deleteSpan);
    view.TextBuffer.Insert(pos, selectedText);
}

Before I did a first test-run I wanted to add my new command to the context menu of the Visual Studio editor instead of creating a new menu entry. So, next stop: The Visual Studio Command Table, a XML-file with the extension .vsct. It took a few minutes until I understood what happend in there. But after some Bing’ing (gosh, that sounds awfull! ) I found the lines I need to change to place my command into the context menu:

<Group guid="guidUnicodeConverterCmdSet" id="UnicodeMenuGroup" priority="0x0600">
    <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_CODEWIN"/>
</Group>

Compiling, installing the Add-In, restarting Visual Studio and… where is my context menu entry?! I opened a simple html file and tried to convert some text in it, but my extension didn’t show up. Well, actually it DID show up but I searched for it at the wrong place: When in a codefile (.cs) I could happily see my context menu entry and it worked like a charm. But why did it only appears in the code editor and not in the html code-view?

I was Bing’ing again like “Big Ben” (knee-slapper…) but all I found were some cryptical information about .h-files with a C++ syntax. There were some GUIDs similiar to those I saw in my command table but when I tried using them as a parent I got some compile-errors. Some time-consuming investigations later (I did not found a hint even in the msdn) I found a small tool, the VSCT PowerToy in the MSDN Code Gallery. It’s “a read-only viewer for Visual Studio 2010 that you can use to explore the commands associated with a VSPackage, and with Visual Studio itself. You can quickly search for any existing commands in the Visual Studio IDE. By browsing through the command groups, GUIDs and IDs, priorities, and other properties of existing commands, you can more easily place and integrate the commands of your own VSPackage.” – sounds pretty good to me: I have no clue how to do it, so I look at others how they accomplished it!

After playing around with the tool for a while I found what I was looking for, the GUIDs and IDs of the context menu used by the html-, aspx-, aspx.cs-, … editors. Yepp, all those editors have their own context menu. It’s even splitted to html in aspx-files, inline-c# in aspx-files and inline-vb in aspx-files. That’s pretty cool when you want to make an extension that’s only working with a subset of all editors or languages! To test my newly found GUIDs and IDs (CMDSETID_HtmEdGrp & IDMX_HTM_SOURCE_HTML) I added them as “parent” to my group and… my build failed again. This GUID and ID are unknown – corresponding to the compiler. Wait, there was a section within my .vsct-file to define my own command-names with their GUID. Perhaps I can add a few more..?

There you are! Even if those GUIDs and IDs are internally used by Visual Studio you have to define them for your extension first. The VSCT PowerToy can switch the view and instead of the name I get the corresponding GUIDs and IDs. After defining them as a GuidSymbol my project compiled without an error and it even showed my context menu entry in the html-editor. Strike!

<GuidSymbol name="CMDSETID_HtmEdGrp"
            value="{d7e8c5e1-bdb8-11d0-9c88-0000f8040a53}">
    <IDSymbol name="IDMX_HTM_SOURCE_BASIC" value="0x32" />
    <IDSymbol name="IDMX_HTM_SOURCE_HTML" value="0x33" />
    <IDSymbol name="IDMX_HTM_SOURCE_SCRIPT" value="0x34" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASPX" value="0x35" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASAX" value="0x3B" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASPX_CODE" value="0x36" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASAX_CODE" value="0x3C" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASPX_CODE_VB" value="0x37" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASAX_CODE_VB" value="0x3D" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASMX_CODE" value="0x38" />
    <IDSymbol name="IDMX_HTM_SOURCE_ASMX_CODE_VB" value="0x39" />
</GuidSymbol>

The next challenge was a no-brainer compared to the last one: I want my extension show up in the context menu not only of the code editor or the html-editor but in several of them at once. A solution was quickly found: With CommandPlacements you can add a command to several places so I added my extension to a few of them in case they make sense to me (“Where could you have some text that has to be websafe?”).

<CommandPlacements>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="guidSHLMainMenu" id="IDM_VS_CTXT_CODEWIN"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_HTML"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_SCRIPT"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_ASPX"/>
    </CommandPlacement>
    <CommandPlacement guid="guidUnicodeConverterCmdSet"
                      id="UnicodeMenuGroup" priority="0x0300">
        <Parent guid="CMDSETID_HtmEdGrp" id="IDMX_HTM_SOURCE_ASAX"/>
    </CommandPlacement>
</CommandPlacements>

And thats it! I didn’t made a step-by-step tutorial how to make a new extension for Visual Studio. There are a lot of other articles and examples around for that. But I thought I show you what problems I was confronted with and how I finally circumnavigate them so that you can learn from my researches.

Last but not least you can take a look at my sourcecode. I’m publishing it under the MS-PL so you are free to use and change it for your purposes but of course it would be great if you could give me a hint in that case. All feedback is greatly appreciated, so leave me a comment or write a message via email, facebook, twitter, … whatever you like

Thanks for reading!

Unicode Converter Sourcecode (691 KB)

In den vergangen Monaten habe ich einiges theoretisches über Event Based Components (kurz EBCs) gelesen. Das meiste von Ralf Westphal, in seinem Blog oder aus seiner Feder in der dotnetpro. Auch Golo Roden schrieb in seinem Blog über das Thema.

Verwirrung

Angespornt durch die Beiträge habe ich in den letzten Wochen selber versucht EBCs zu schreiben und zu entwickeln und bin zuerst gescheitert. Sobald ich die ersten Komponenten geschrieben und “zusammengesteckt” hatte, verlor ich relativ schnell den Überblick über die Komponenten und deren Verbindungen.

Woran lag das?

Golo wies mich auf die fehlerhafte Benennung der Events in Ralf Westphals Beispielen hin, die entgegen dem .NET Framework mit dem Präfix “On” begannen.

Ich habe also von vorne begonnen und die Events wie im .NET-Framework üblich benannt.

Beispiel:

public event Action<Customer> EntitySaving (wird vor dem Speichern ausgelöst)
public event Action<Customer> EntitySaved (wird nach den Speichern ausgelöst)

Und siehe da: die Verwirrung war beseitigt :-)

Vorteile

Die Vorteile der EBCs sind klar und wurden in den oben genannten Beiträgen auch oft genug angesprochen. Die zwei größten Vorteile sind – aus meiner Sicht – zum einen die isolierte Testbarkeit der Komponenten und die flexible Möglichkeit die Komponenten zusammenzuführen.

Refactoring

In den letzten Wochen habe ich also meinen angehenden Lizenz-Manager, einem großen Refactoring unterzogen und auf EBCs umgebaut. Ich habe allerdings vorerst meine Service-Klassen nicht komplett auseinandergerissen. Also nicht fürs Speichern, Löschen und Lesen separate Komponenten gebaut (das wäre dann der nächste schritt), sondern es bei jeweils einer Komponente mit standardmäßig drei Input- und drei Output-Pins belassen. Ich habe lediglich die generische Validierung komplett entkoppelt und dafür eine weitere Komponente angelegt, die vor jedem Speichern “eingesteckt” werden kann.

Die vorhandenen Unit-Tests musste ich leicht anpassen. Die Tests für die Servies, die hauptsächlich die Validierung getestet haben konnte ich entfernen und in die Test für die Validator-Komponente aufnehmen. Die Tests sind alle kleiner geworden, da Abhängigkeiten gar nicht mehr berücksichtigt werden müssen, wenn sie nicht zusammengesteckt worden sind. Beispiel: Die Service-Methode zum Speichern, muss keine Validierung mehr testen. Und die Tests der Validierung ist unabhängig vom Speichervorgang.



[TestFixture]
[Category("GO.LicenceManager.Services.ModelValidator")]
public class Wenn_ein_Kunde_validiert_wird
{
    [Test]
    public void darf_der_Vorname_nicht_fehlen()
    {
        Customer customer = new Customer
                                {
                                    [….]
                                };

        IModelValidator<Customer> modelValidator = new ModelValidator<Customer>();
        Assert.Throws<PropertyNotSetException<Customer>>(
            () => modelValidator.Validate(customer),
            "'Name' must not be null or empty");
    }
}

public class ModelValidator<T> : IModelValidator<T> where T : IEntity
{
    public void Validate(T model)
    {
        Type type = typeof(T); 
        IEnumerable<PropertyInfo> propertyInfos = type
                .GetProperties(BindingFlags.Public | BindingFlags.Instance); 
        [….]
    }
}

public class CustomerService : ICustomerService
{
    private readonly ICustomerRepository _customerRepository; 
    public CustomerService(ICustomerRepository customerRepository)
    {
        _customerRepository = customerRepository;
    } 
    public void Save(Customer customer)
    {
       OnEntitySaving(customer); 
       if(customer.Id==Guid.Empty)
       {
           customer.Id = Guid.NewGuid();
       } 
        _customerRepository.Save(customer);
    } 
    public event Action<Customer> EntitySaving;
    public void OnEntitySaving(Customer entity)
    {
        var entitySaving = EntitySaving;
        if (entitySaving != null)
        {
            entitySaving(entity);
        }
    }

    [….]
}

Zusammenstecken:

Customer customer = new Customer
                                    {
                                        [….]
                                    }; 
IModelValidator<Customer> validator = new ModelValidator<Customer>();
ICustomerService customerService = new CustomerService(customerRepository);
customerService.EntitySaving += validator.Validate; // <== zusammenstecken
customerService.Save(customer);

Die Tests hätten wir damit vereinfacht, die Komponenten müssen sich nicht mehr kennen und sind komplett entkoppelt. Die Komponenten müssen aber irgendwie und irgendwo zusammengeführt werden, um zu funktionieren.

Die Komponenten müssen “zusammensteckt” werden.

Dabei ist entweder Handarbeit und eine gute Dokumentation gefordert, oder man versucht das zu automatisieren. Ralf Westphal hat dafür einen EBC-Binder geschrieben, der allerdings nur funktioniert, wenn gewisse Konventionen eingehalten werden: Unter anderem müssen die Events eben mit dem Präfix “On” beginnen…

Ich werde hierfür wahrscheinlich eine Art Binding-Datei anlegen die im XML-Format nicht nur das Binding selber regelt, sondern dieses auch dokumentiert. Mal sehen, was sich so machen lässt :-)

Vorerst werde ich im Lizenz-Manager allerdings noch die Repositories und die verschiedenen Views implementieren müssen. Bis zur See# Party werde ich wohl aber nicht mehr dazu kommen…

.NET unterscheidet zwischen Referenz-Typen und Wert-Typen. Was bei vielen Entwicklern, die das nicht wissen oder beachten, zu kleineren Verwirrungen führen kann.

Aber zuerst einmal die Definition:

Werte-Typen sind zum Beispiel System.Int32 und System.Boolean welche im .NET-Framework vordefiniert sind. Eigene Structs und Enums sind ebenfalls Wertetypen. Strukturen sind auch dann Werte-Typen, wenn sie selber Referenz-Typen beinhalten.

Referenz-Typen sind Objekte mit Klassen oder Interfaces deklariert werden.
Wichtig: Referenz-Typen halten immer nur einen Zeiger auf die eigentlichen Werte

Lektüre:
Referenz- und Wertetypen
Werttypen im allgemeinen Typsystem
Arbeiten mit .NET: Grundlagen: Wertetypen und Verweistypen
Referenz- und Wert-Typen: Was ist der Unterschied in .NET?

Da Referenz-Typen nur Zeiger sind, kommt es zur Verwirrung, wenn Referenz-Typen als Wert (VB.NET: ByVal) an Funktionen und Methoden übergeben werden. Da lediglich der Zeiger übergeben wird, kann das Objekt auch außerhalb er aufzurufenden Methode verändert werden. Das hat das gleiche Verhalten, wie bei Werte-Typen die als Referenz (VB.NET: ByRef; C# ref) übergeben werden.

Wieso die Verwirrung?

Da die Schlüsselworte ByRef und ByVal in VB.NET immer explizit angegeben werden müssen, werden sie natürlich auch immer genutzt, sind immer sichtbar. Man nutzt ByRef deshalb viel zu oft, ohne zu wissen, dass es oftmals gar nicht nötig ist.

In C# muss das Schlüsselwort ref dagegen nur angegeben werden, wenn wirklich etwas als Referenz übergeben werden muss. Das hat zur Folge, dass dieses Schlüsselwort nicht permanent sichtbar ist, man macht sich weniger Gedanken über die Art der zu übergebenden Parameter.

Also merken: In VB.NET kann ByVal eben auch ByRef sein, wenn es sich bei dem TypParameter um einen Referenz-Typ handelt! ;-)

In diesem Tipp geht es um das Caching von Silverlight XAP-Dateien durch den Browser oder einen Proxy-Server.

Zusammenfassung

Manchmal werden XAP-Dateien zu lange zwischengespeichert und der Anwender arbeitet mit einer älteren Version der Silverlight Anwendung, obwohl auf dem Server bereits eine neuere XAP-Datei vorliegt. Man kann dies verhindern, indem man an die URL der XAP-Datei einen kurzen Parameter anfügt, dessen Wert vom letzten Änderungsdatum der XAP-Datei abhängt.

Beschreibung

Normalerweise braucht man sich über das Caching der XAP-Dateien, in denen sich die gesamte Silverlight Anwendung befindet, keine Gedanken machen. Wenn jedoch beispielsweise ein Kunde in seinem Intranet einen ISA Server als Proxy verwendet, kann es passieren, dass der Kunde die vom Entwickler gerade frisch auf dem Server aktualisierte Silverlight Anwendung nicht verwenden kann, weil ihm sein Proxy-Server die zwischengespeicherte Vorgängerversion der XAP-Datei liefert.

Neu laden der Webseite im Browser bringt da leider gar nichts. Und das Unterdrücken des Cachings der Webseite, in der die Silverlight Anwendung eingebettet ist, hat natürlich auch keinen Erfolg, denn das Problem liegt im Caching der XAP-Datei auf dem Proxy-Server. Aus der Sicht eines Browsers oder Proxy-Servers ist eine XAP-Datei auch nur eine binäre Ressource wie beispielsweise eine PNG- oder JPEP-Datei. Daher wird sie genauso zwischengespeichert.

Im HTML-Element <object>, welches die Silverlight Anwendung beschreibt, gibt es einen Parameter, der die URL der XAP-Datei festlegt. Dieser sieht beispielsweise so aus:

<param name="source" value="ClientBin/MySilverlightApplication.xap"/>

Eine mögliche Lösung wäre die aktuelle Versionsnummer in den Dateinamen aufzunehmen:

<param name="source" value="ClientBin/MySilverlightApplication-1.2.3.xap"/>

Dies führt zu einer Aktualisierung des Caches, wenn eine neue Version eingespielt wird, da sich dabei die URL ändert. Es kann jedoch zu neuen Problemen kommen, wenn beispielsweise das <param> Element auf der Webseite nicht zum Namen der XAP-Datei auf dem Server passt.

Es ist daher besser, die Versionsnummer als Dummy-Parameter an die URL anzufügen und den eigentlichen Namen der XAP-Datei unverändert zu lassen:

<param name="source" value="ClientBin/MySilverlightApplication.xap?v=1.2.3"/>

Die Silverlight Runtime interessiert der Text rechts vom Fragezeichen nicht. Und bei einer neuen Versionsnummer ändert sich dennoch die URL, sodass der Proxy-Server die XAP-Datei neu vom Web-Server anfordert.

Der Nachteil liegt allerdings darin, dass die Versionsnummer serverseitig immer irgendwie bestimmt werden muss. Daher ist es einfacher, statt der Versionsnummer das letzte Schreibdatum der XAP-Datei als Parameter zu verwenden:

<param name="source" value="ClientBin/MySilverlightApplication.xap?x=2010-08-15_16:17:18"/>

Dieser Wert lässt sich serverseitig mit File.GetLastWriteTime praktisch ohne Overhead ermitteln. Wenn man nicht möchte, dass jeder dieses Datum sieht, kann man es beispielsweise auch einfach in eine Zahl umrechnen. Jetzt muss man nur noch das Caching der Webseite selbst verhindern:

<meta http-equiv="expires" content="0">

Damit haben wir erreicht, dass der Proxy-Server die XAP-Datei zwischenspeichert, solange sie sich nicht ändert, und neu anfordert, sobald sie auf dem Server ausgetauscht wurde.

Diese Methode funktioniert gut mit dem Internet Explorer und dem Firefox in Zusammenhang mit dem ISA Server. Andere Browser haben wir nicht ausreichend getestet. Bei anderen Browsern könnte es beispielsweise sein, dass das Fragezeichen in der URL das Caching im Browser verhindert und die XAP-Datei jetzt jedes Mal neu angefordert wird.

Hier geht's zum nächsten Tipp.

Since Windows 7 the icon of an application can get an overlay bitmap. You can use that to indicate some state of the application, or–like MetroTwit–to show the number of unread items.

Overlay Icon in WPF

In WPF, the API is pretty simple:

<Window.TaskbarItemInfo>
    <TaskbarItemInfo 
        Overlay="{StaticResource ResourceKey=MyOverlayImage}" />
</Window.TaskbarItemInfo>

However, in one of my projects I have to display dynamic text in the overlay, similar to MetroTwit, but above example only shows a static resource.

While searching in the internet I found Pete Brown’s article Creating Dynamic Windows 7 Taskbar Overlay Icons. He uses a WPF DataTemplate to define the content of the overlay, and in his code-behind he takes that template, renders it to a bitmap and assigns it to the TaskbarItemInfo’s Overlay property. See his article for the detailed steps.

Though I think Pete’s solution pretty clever, it lacks the separation of logic and presentation. In my application I don’t want to create images in the code-behind, code-aside, whatever. It follows the MVVM pattern, so the creation of the overlay image shouldn’t be the concern of my viewmodel.

Solution

Extending TaskbarItemInfo doesn’t work because it is sealed. Therefore I took the same route as in my previous post, attaching dependency properties:

public class TaskbarItemOverlay  {
    public static readonly DependencyProperty ContentProperty =
        DependencyProperty.RegisterAttached(
            "Content", 
            typeof(object), 
            typeof(TaskbarItemOverlay), 
            new PropertyMetadata(OnPropertyChanged));

    public static readonly DependencyProperty TemplateProperty =
        DependencyProperty.RegisterAttached(
        "Template", 
        typeof(DataTemplate), 
        typeof(TaskbarItemOverlay), 
        new PropertyMetadata(OnPropertyChanged));


    public static object GetContent(DependencyObject dependencyObject) {
        return dependencyObject.GetValue(ContentProperty);
    }

    public static void SetContent(DependencyObject dependencyObject, object content) {
        dependencyObject.SetValue(ContentProperty, content);
    }

    public static DataTemplate GetTemplate(DependencyObject dependencyObject) {
        return (DataTemplate)dependencyObject.GetValue(TemplateProperty);
    }

    public static void SetTemplate(DependencyObject dependencyObject, DataTemplate template) {
        dependencyObject.SetValue(TemplateProperty, template);
    }

    private static void OnPropertyChanged(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e) {
        var taskbarItemInfo = (TaskbarItemInfo) dependencyObject;
        var content = GetContent(taskbarItemInfo);
        var template = GetTemplate(taskbarItemInfo);

        if (template == null || content == null) {
            taskbarItemInfo.Overlay = null;
            return;
        }

        const int ICON_WIDTH = 16;
        const int ICON_HEIGHT = 16;

        var bmp =
            new RenderTargetBitmap(ICON_WIDTH, ICON_HEIGHT, 96, 96, PixelFormats.Default);
        var root = new ContentControl {
            ContentTemplate = template, 
            Content = content
        };
        root.Arrange(new Rect(0, 0, ICON_WIDTH, ICON_HEIGHT));
        bmp.Render(root);

        taskbarItemInfo.Overlay = bmp;
    }
}

The first lines a boilerplate code to define the attached properties. There are two of them, Content and Template. The former defines, well, the content we’re going to bind to our model. The latter defines the template used to render the content.

The actual work is done in the method OnPropertyChanged. It takes the template together with the content, renders it, and assigns the resulting bitmap to the Overlay property of the TaskbarItemInfo element.

Usage

I have created a small application to demonstrate the use of the attached properties. The XAML of the window is this:

<Window 
    x:Class="WpfApplication1.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:src="clr-namespace:WpfApplication1" 
    Title="MainWindow" Height="350" Width="525">
    <Window.Resources>
        <DataTemplate x:Key="OverlayIcon">
            <Grid Width="16" Height="16">
                <Ellipse 
                    Fill="Red" 
                    Stroke="White" 
                    StrokeThickness=".5" />
                <TextBlock 
                    Text="{Binding}" 
                    TextAlignment="Center" 
                    Foreground="White" 
                    FontWeight="Bold" 
                    Height="16" 
                    VerticalAlignment="Center" 
                    FontSize="10"/>
            </Grid>
        </DataTemplate>
    </Window.Resources>
    <Window.TaskbarItemInfo>
        <TaskbarItemInfo 
            src:TaskbarItemOverlay.Content="{Binding Count}" 
            src:TaskbarItemOverlay.Template="{StaticResource OverlayIcon}" />
    </Window.TaskbarItemInfo>
    <Viewbox>
        <TextBlock Text="{Binding Count}" />
    </Viewbox>
</Window>

In the window’s resources we define the template for the overlay. Notice that the Text is bound! Later you can see the TaskbarItemInfo with the attached properties in action: Content binds to the Count property of my viewmodel, and Template references the DataTemplate defined in the resources.

The code-behind is straight forward. I won’t repeat it here, but you can see it at GitHub. Basically it increments the Count property of the viewmodel every seconds in a background thread. You can see the result in the image to the left.

The source code is attached, but also available at GitHub.

Schon seit einigen Versionen verfügt BlogEngine.NET eine eigentlich recht nützliche Erweiterung zum Protokollieren von aufgetretenen Fehlern. Die Erweiterung ist standardmäßig nicht aktiviert. Zu finden ist sie in den Einstellungen der Erweiterungen unter der lapidaren Bezeichnung Logger.

Wenn die Erweiterung aktiviert wird, tut sie genau das was in der Beschreibung steht:
Wenn ein Log-Ereignis ausgelöst wird, schreibt die Erweiterung alles schön hintereinander in eine Datei.
Am Anfang mag das Ergebnis ja noch überschaubar sein. Aber spätestens nach ein oder zwei Wochen ist die Suche nach einem bestimmten Zeitraum oder Ereignis von heftigem Scrollen begleitet.
Mir persönlich würde eine log-Datei pro Tag am besten gefallen. Das ist schon übersichtlich und die Ereignisse können wesentlich leichter gefunden werden. Mit einer kleinen Anpassung ist dieses Verhalten auch leicht umzusetzen.
Der Code der Erweiterung befindet sich im Ordner App_Code\Extensions in der Datei Logger.cs.

private static string GetFileName()
{
    if (_FileName != null)
        return _FileName;


    string file = "errors-"
        + DateTime.Now.ToString(
            "dd-MM-yyyy",
            CultureInfo.InvariantCulture)
        + ".txt";
    _FileName = HostingEnvironment.MapPath(
        Path.Combine(
            BlogSettings.Instance.StorageLocation + "logs/",
            file));
    return _FileName;
}

Fazit:

Mit der Änderung einer Zeile Code lässt sich auch der Standard-Logger von Blogengine.NET dazu überreden, seine Log-Dateien benutzerfreundlich und organisiert zu erzeugen.

Ben Gracewood from New Zealand released a few weeks ago a One time image cacher. I liked the basic idea, but having static images only being downloaded one time, was too static. It shall be checking for updates periodically.
Thinking about a social networks, those include often profile pictures, which get updated from time to time, but can stay under the same file name.

Working with the ETag

Requesting Images from a webserver includes often a ETag HTTP Response Header, which is a type of a ID. I was pointed to this by Ingo Rammer from Thinktecture.
If requesting the same picture again, including a If-None-Match HTTP Header within the WebRequest the Server returns a HTTP Status 304 (not modified) with nearly no data, or the picture itself, if modified.
Requesting the same picture all the time wouldn’t make much sense. Therefore the Expires Header is checked as well. If not present, on a per day basis the image is checked for modification.
The best thing about this is, that the information on when requesting is persisted as well.

The code

I liked Bens idea on using a ValueConverter for caching those images. It enables the possibility on including this functionality even with Blend and no additional line of sourcecode:

<phone:PhoneApplicationPage 


x:Class="WPImageCacher.MainPage"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"

xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"

xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

xmlns:ic="clr-namespace:WPImageCaching;assembly=WPImageCaching"

FontFamily="{StaticResource PhoneFontFamilyNormal}"

FontSize="{StaticResource PhoneFontSizeNormal}"

Foreground="{StaticResource PhoneForegroundBrush}"

SupportedOrientations="Portrait" Orientation="Portrait"

mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"

shell:SystemTray.IsVisible="True">



<phone:PhoneApplicationPage.Resources>

 <ic:ImageCacheConverter x:Key="imageCacheConverter"
/>

<BitmapImage x:Key="imageSource" UriSource="http://www.microsoft.com/austria/athome/works/images/w_home-head.jpg"
/>

</phone:PhoneApplicationPage.Resources>

<!--LayoutRoot contains the root grid where all other page content is placed-->

...

<Image HorizontalAlignment="Left"

Margin="0"

Name="image1"

Stretch="Uniform"

VerticalAlignment="Top"

Grid.Row="1"

Source="{Binding Source={StaticResource imageSource},Converter={StaticResource
imageCacheConverter}}" />


... 

As you can see for using this – it is pretty simple.

But what happens behind the scenes?
An additional Store contains the info, which images have already been loaded, including an experation value as well as an ID from the ETag, if included and of course the URL.
The images get stored with a hashed file name. The reason for this is, that you could have multiple sites using the same image name.

The downside of using a ValueConverter is, that the call has to be completed synchronous. Downloading the image via WebRequest is only possible asynchronously. Therefore using a little bit of a trick with a transfer object and the BitmapImage itself helps to get the functionality working.

The attached Sourcecode includes german annotations. Sorry for that.

So langsam geht es bei der See# Party in die Endphase und wir haben tatsächlich noch ein paar freie Plätze, für die man sich noch unbedingt anmelden sollte, wenn man die tollen Themen nicht verpassen möchte (Das war ein Befehl, keine Bitte!). Um die Sache noch spannender zu machen haben wir uns entschlossen eine kleine Blog-Parade zu starten und hiermit auch eine Gewinnspielaktion und eine Blog-Parade anzukündigen.

Gewinnspielaktion

Wer sich am Mittwoch den 18. August 2010 ab 09:00 Uhr zur See# Party anmeldet, hat die Möglichkeit

• eines von sechs See# Party T-Shirts und
• einen freien Zugang zur See# Party zu gewinnen

Die ersten sechs Anmeldungen erhalten jeweils ein See# Party T-Shirt, wobei die erste Anmeldung zusätzlich den freien Zugang zur See# Party erhält.

Wer meint das sei es nicht wert, sollte die Agenda nochmal ganz genau studieren ;-)

Sobald die Gewinne vergeben sind, werden die Gewinner hier auf meinem Blog veröffentlicht und per E-Mail benachrichtigt.

Blog- und Twitter-Parade

Unter allen Bloggern und Twitterern, die sich auch zur See# Party anmelden verlosen wir zwei freie Zugänge zur See# Party unter allen anderen werden wir zwei See# Party T-Shirts verlosen.

Die beiden Paraden enden am Mittwoch den 18. August um 12:00 Uhr Mittags.

Die Gewinner werden per Zufallsgenerator ausgelost und hier auf meinem Blog veröffentlicht.

Blog-Parade:

Für die Blog-Parade ist nichts anderes zu tun, als auf die kommende See# Party (wenn möglich mit Banner) und diese Gewinnspielaktion hinzuweisen. Dafür kann der obige Text einfach kopiert und entsprechend angepasst werden.

Wie üblich müssen die Blog-Beiträge auch auf den ursprünglichen Beitrag (also hier her) verlinken.

Sollte aus irgendeinem Grund kein automatischer Link in den Kommentaren eingefügt werden, schreibt einfach selber einen Kommentar mit einem Link auf euren Beitrag rein, oder schickt mir eine kurze E-Mail mit dem Hinweis auf euren Artikel (in diesem Fall setze ich den Kommentar persönlich)

Twitter-Parade:

Wer nicht mehr als 140 Zeichen am Stück hinbekommt, kann auch gerne per Twitter an der Parade Teilnehmen. Dazu einfach folgenden Text kopieren und twittern:

Gewinnspiel zur See# Party: Sechs T-Shirts und ein freier Eintritt zu gewinnen: http://tinyurl.com/26rjesq #ssp2010 #parade

Erklärungen und Kleingedrucktes

1. Teilnahmeberechtigt an der Verlosung und der Blog- und Twitter-Parade ist jeder, ausgenommen die Veranstalter der See# Party und deren Angehörige.
2. Jeder Teilnehmer darf mehrmals teilnehmen. Die Chancen für die Verlosung erhöhen sich dadurch allerdings nicht.
3. Alle Gewinner werden per E-Mail benachrichtigt.
4. Die Zustellung des Gewinns der T-Shirts aus der Blog- und Twitter-Parade erfolgt auf dem Postweg auf eigene Gewähr. Eine korrekte Angabe der Adressdaten ist Voraussetzung für die korrekte Zustellung im Falle eines Gewinns.
5. Die Zustellung der Gewinns der T-Shirts aus dem Gewinnspiel erfolgt persönlich beim Empfang der See# Party
6. Die Gewinner erklären sich mit einer Veröffentlichung Ihrer Vornamen und des Anfangsbuchstabens des Nachnamens in diesem Blog einverstanden.
7. Die Ausbezahlung der Preise in bar ist nicht möglich.
8. Der Rechtsweg ist ausgeschlossen.
9. Gewährleistungsansprüche hinsichtlich der Gewinne sind ausgeschlossen.

Ich wünsche allen Teilnehmern viel Spass und viel Glück, auf das man sich auf der See# Party trifft. :-)

Gestern fand das 19. Treffen des .NET-Stammtisch Konstanz-Kreuzlingen statt. Zu Gast war diesmal Thorsten Hans der IronRuby vorstellte, nach einer Einführung in die Sprache Ruby ging es auch schon los mit Demos zu .NET Programmierung mir IronRuby

Was mich persönlich erstaunt hat und womit ich eigentlich nicht gerechnet hatte ist, dass IronRuby nicht nur eine Spielerei von Microsoft Geeks ist, sondern tatsächlich in Business Anwendungen und Szenarien eingesetzt werden. Dadurch das IronRuby in herkömmlichen Anwendungen gehostet werden kann und im IronRuby das komplette .NET Framework zur Verfügung steht, ist es möglich die eigene Anwendung an bestimmten Stellen so flexibel zu halten, dass zur Laufzeit kundenspezifische Anpassungen durchgeführt werden können.

Thorsten zeigte dazu eine Demo, in der er die Validierung eines DTOs in ein IronRuby-Script auslagerte und so zur Laufzeit beliebig ändern könnte ohne das die Anwendung neu kompiliert werden muss.

Aber das ist nur eines der vielen möglichen Anwendungsgebiete von IronRuby.

Ich weiß auf jeden Fall, dass ich in nächster Zeit etwas damit herumspielen werden.

Im Namen aller Anwesenden bedanke ich mich hiermit nochmal bei Thorsten Hans für die sehr spannende Einführung in IronRuby. :-)

Eben habe ich gemerkt, das Thorsten mit einem Blog-Beitrag schneller war als ich: Siehe

Auch im Blog des .NET-Stammtisch wird es immer wieder Berichte zu den jeweiligen Treffen geben. Stefan Zybarth von der Combit wird sich hier austoben :-)

Es hat eigentlich viel zu lange gedauert, doch endlich haben wir eine Liste der uns zur Zeit bekannten Methoden und Plug-Ins zusammengestellt, wie ihr den “Kick-It”-Button automatisiert in euer Blog, CMS oder auch einfache html-Seiten einbinden könnt. Den Link zur Liste findet ihr auf unserer Seite http.//dotnet-kicks.de rechts oben oder einfach hier.

Mit dabei sind bekannte Vertreter wie die BlogEngine.NET, Wordpress, dasBlog, Blogspot von Google, SubText und andere. Auch diverse andere Programme oder Services wie Feedburner und der Windows Live Writer werden natürlich von uns versorgt. Wenn ihr noch ein weiteres Plug-In kennt oder für eine bestimmte Plattform noch eines vermisst dann setzt euch einfach mit uns per E-Mail oder Twitter in Verbindung (Jan Welker, Klaus Bock, Gordon Breuer). Wir würden eure Vorschläge und Anregungen gerne hören, natürlich auch zu anderen Bereichen! :-)

Wie kommen die Leute eigentlich immer auf diese Namen? “Flickr”, “Flattr”, … habe ich ein Memo verpasst und mehr als ein Vokal pro Name sind “uncool”? Eigentlich verwunderlich, dass es nicht auch “Twittr” heißt. Aber ich schweife – noch ehe ich angefangen habe – ab!

Seit März dieses Jahres ist Flattr in einer Beta-Phase online. Dabei handelt es sich um ein (weiteres) soziales Netzwerk, auf dem man beispielsweise Blogartikel, aber auch andere Onlinebeiträge, Musik, Bilder und Videos “pushen” kann. Doch anders als bei Diensten wie “Digg” steckt hinter jedem positiven Voting bares Geld! Wer bereit ist monatlich mindestens 2 Euro auszugeben kann sich – momentan noch einen gültigen Beta-Key vorausgesetzt – anmelden und ab sofort Beiträge mit einem entsprechenden Button flattrn… flattern… flattren… was auch immer. Am Ende des Monats wird die Anzahl meiner Klicks addiert und die Summe, die ich bereit war auszugeben, gleichmäßig auf alle geklickten Inhalte verteilt. Klingt komisch, also hier ein kurzes Beispiel:

Pro Monat zur Verfügung gestellter Betrag: 2,00 EUR
In diesem Monat angeklickte Flattr-Buttons: 17
Jeder meiner Klicks war also rund 11 Cent wert, denn 10% behält der Anbieter.

Dabei kann man einen Button pro Monat nur einmal anklicken. Der jeweilige Empfänger kann übrigens nicht sehen, wer ihn angeklickt hat – doch anonym ist man dennoch nicht, da Flattr selbst natürlich alle Transaktionen (und Klicks) detailiert protokolliert.

Möchte man nun Inhalte wie beispielsweise Blogpostings oder Online-Artikel für Flattr-Klicks verfügbar machen, muss man selbst ebenfalls einen aktiven Account haben. Das wiederum setzt voraus, dass man mindestens 2 EUR im Monat bezahlt. Dann jedoch kann man theoretisch beliebig viele “Klicks” von anderen erhalten. Bleibt also nur noch die Frage, ob sich der Dienst für die eigene Seite überhaupt lohnt.

Wenn man mal ganz objektiv nachrechnet lohnt sich Flattr eigentlich erst und nur dann, wenn man über den Dienst mehr als die eigenen monatlichen Kosten wieder rein bekommt. Doch das muss (und soll!) meiner Meinung nach nicht die Hauptmotivation sein. Ich sehe Flattr vielmehr als eine art freiwillige Spende oder – wer ungerne als digitale Version des “Bettlers in der Fußgängerzone” betrachtet werden möchte – ein schnelles und unkompliziertes “Danke”.

In Amerika ist es u.a. in vielen Blogs schon lange üblich einen Paypal-Button zu haben mit der Aufforderung “Du bist dran mit Kaffee holen!” oder ähnlichem. Wenn uns jemand behilflich war bedanken wir uns normalerweise und jemanden auf einen Kaffee einzuladen ist einfach, unverbindlich und macht keine großen Umstände. Und genau diese Mentalität wird hier versucht auch auf die digitale Welt zu übertragen: Wenn ich dir geholfen habe und dir vielleicht sogar Zeit und Ärger erspart habe freut mich das! Und wenn du dich revanchieren möchtest gib mir einfach “einen Kaffee” aus bzw. das monetäre Äquivalent hierzu, also vielleicht 1$. Nur zu gerne vergisst man, dass den Leuten, die anderen freiwillig und oft uneigennützig im Internet mit Artikeln helfen, durchaus reale Kosten entstehen: Die Zeit die man zum Schreiben benötigt, das Webhosting mit Traffic, die eigene Domain… und dennoch machen es viele, einfach weil es ihnen Spaß macht.

Der “Kaffee” über Paypal ist eine Möglichkeit, aber es ist auch aufwändig: Einloggen (dafür den Passwort-Manager starten),  einen plausiblen Betrag überlegen, Zahlungsmethode auswählen, Bestätigen, … selbst wenn die eigentlichen Gebühren nur wenige Cent betragen, der damit verbundene Zeitaufwand ist mir dann doch oft zu hoch. Deshalb mag ich Flattr: Gefällt mir ein Inhalt und ich möchte dem Autor “Danke” sagen, klicke ich auf den Flattr-Button und … fertig! Selbst die Kosten kann ich bequem über einen Schieberegler für einen Monat festlegen, und wenn ich einmal besonders viele Sachen toll fand ist es auch kein Problem kurzfristig mal den monatlichen Betrag zu erhöhen damit alle auch ein wenig mehr bekommen.

Klar, ich habe Flattr auch bei mir im Blog eingebunden. Und ich freue mich natürlich auch, dass mir im ersten Monat 0,91 EUR gutgeschrieben wurden. Ganz unabhängig von dem Geld, dass ich selbst ausgab: Es gab Leute denen das was ich geschrieben habe eine (symbolische) Kleinigkeit wert war!
Klar, große Inhaltsanbieter werden viel größere Summen monatlich erzielen, wie beispielsweise die TAZ, und im Gegenzug vermutlich nur wenig an die Community zurückgeben. Meine Hoffnung ist, dass es dennoch auch für andere Betreiber sowohl ein Ansporn ist qualitativ hochwertige Inhalte zu produzieren, als auch die Arbeit derer zu belohnen die sich hierfür die nötige Zeit nehmen, auch ohne etwas dafür zu fordern.

Einfach mal “Danke” sagen! :-)

Ich habe ja heute meinen ersten offiziellen Screencast aufgenommen, zu Ehren der Erwerbs von diverser Hardware zur Ton-Aufzeichnung. Eine Anschaffung eines richtigen Mikrofons zur Aufnahme von Ton hatte ich schon lange vor, doch was kauft man, in was investiert man und man möchte vielleicht nicht soviel zum spielen ausgeben.

Da kam mir der Blog-Artikel von James Kovacs gerade recht in dem er beschreibt was er nutzt. Er nutzt das Audio-Technica AT2020. Dies gibt es hier in Deutschland für so um 99€. In Anlehnung seines Blogs mit Qualitätsvergleich mache ich dies nun auch. Von der Technik habe ich keine Ahnung, sie muss funktionieren. Technisches kann man bei James nachlesen.

Bestellung

Nun habe ich mich am Sonntag dann in den Online Musikladen meines Vertrauens gestürzt und ein wenig gestöbert was ich denn für mich so brauchen könnte. Da kam schon was zusammen, natürlich erstmal das Mikrofon. Dies gab es als USB und als XLR Ausführung. USB hätte den Vorteil ich kann es direkt am Rechner anschließen, der Nachteil ist ich kann es nur am Rechner anschließen. Dies ist etwas was ich nicht möchte da ich es auch woanders verwenden kann (ich denke da an Podcasts, Interviews, auch mal Unterwegs) und dann vielleicht zu eingeschränkt bin bei möglicher weiterer Hardware (z.B. Mehrspurrekorder).

Also kommt nur die XLR Ausführung in Frage, die braucht jedoch 48V Phantomspeisung. Dafür gibt es mehrere Lösungen, Vorverstärker, USB A/B Wandler. Ich habe mich für der Einfachheithalber für ein Set entschieden wo so ein Microport XLR/USB Wandler dabei war. Keine Ahnung ob der was taugt, aber ist im Set also wird’s schon passen dachte ich mir.

Dazu kam dann noch ein Mikrofonhalter, eine Spinne die das Mikro von schlägen auf dem Tisch entkoppelt, ein Tischarm für’s Mikrofon und ein Popp-Schutz.

Lieferung

Heute brauchte der UPS Mensch das Paket mit allen Inhalten vorbei, bis auf die Spinne funktioniert alles, die habe ich wohl eine Nummer zu eng gekauft, ich bekomme das Mikrofon da nicht rein.

Entäuschung

Nachdem ich das dann alles in Betrieb genommen hatte habe ich den Screencast aufgenommen. Und es wurde zurecht eine nicht ganz so gute Tonqualität vernommen, als ob ich zu weit wegwäre. Ich war schon was unzufrieden, da ganze Geld und dann sowas. Somit schob ich es auf die Software. Aber die war nicht an allem Schuld.

Ganz wichtig bei so einem Semi-Pro mit Nierencharakteristik ist das man es auch an die richtige Stelle beschallt. Dies habe nich nicht gemacht, ich habe oben hineingesprochen, was für dieses nicht ganz so gut war. Es gibt welche da funktioniert dies.

Ok, ich verspreche nun immer seitlich reinzusprechen, aber auch nur von vorne.

Alles wieder gut

Nachdem mir nun bekannt es von welcher Stelle ich das Mikrofon zu beschallen habe ich nun auch den Qualitätsvergleich gemacht. Mir stehen nun 3 externe Mikrofone zu Verfügung.

1. Microsoft WebCam LifeCam VX-7000
2. Logitech Premium Notebook Headset USB
3. Audio-Technica AT220

Mit dem Headset war ich so zufrieden, es macht seinen Job war nicht teuer und für LiveMeetings und so hat es gereicht. War das gerade nicht greifbar wurde auf das Mikro der WebCam zurückgriefen (Messenger & Skype). Ich musste mich ja nicht hören.

Zur Test Aufnahme habe ich also das Headset aufgezogen, und mich so vor das neue Mikro positioniert wie ich auch am Rechner arbeite und in Standard WebCam abstand bin. Dann habe ich die Pegel aller Mikrofone auf einen ähnlichen Stand gebracht um eine gleiche Lautstärke zu haben.

Mit der Software MixPad (Mehrspur Aufnahme) habe ich dann in einem Take alle drei Mikrofone im Kasten gehabt. Somit gibt es keine Betonungsunterschiede.

Hier nun kleine Miniplayer zum abhören. Das Getöse im Hintergrund ist wohl die Dockingstation, kommt mir hier im Betrieb nicht SOO laut vor. Aber heute ist es hier auch was wärmer. Bis auf die Umwandlung in MP3 wurde die Aufnahme nicht nachbearbeitet.

Microsoft WebCam LifeCam VX 7000

Logitech Premium Notebook Headset USB

Audio-Technica AT2020

Und alle drei zusammen

Ein Urteil kann sich nun jeder selbst bilden, entäuscht bin ich jedenfalls nicht mehr. Zumal durch die Nierencharakteristik die Hintergrundgeräusche gut gefiltert werden.

Für den XLR/USB Adapter braucht man keine Treiber (Windows7/Vista), auch bietet er auch noch einen Kopfhörer-Anschluss an den der Rechner die Soundausgabe schicken kann.

Wie kommen die Leute eigentlich immer auf diese Namen? “Flickr”, “Flattr”, … habe ich ein Memo verpasst und mehr als ein Vokal pro Name sind “uncool”? Eigentlich verwunderlich, dass es nicht auch “Twittr” heißt. Aber ich schweife – noch ehe ich angefangen habe – ab!

Seit März dieses Jahres ist Flattr in einer Beta-Phase online. Dabei handelt es sich um ein (weiteres) soziales Netzwerk, auf dem man beispielsweise Blogartikel, aber auch andere Onlinebeiträge, Musik, Bilder und Videos “pushen” kann. Doch anders als bei Diensten wie “Digg” steckt hinter jedem positiven Voting bares Geld! Wer bereit ist monatlich mindestens 2 Euro auszugeben kann sich – momentan noch einen gültigen Beta-Key vorausgesetzt – anmelden und ab sofort Beiträge mit einem entsprechenden Button flattrn… flattern… flattren… was auch immer. Am Ende des Monats wird die Anzahl meiner Klicks addiert und die Summe, die ich bereit war auszugeben, gleichmäßig auf alle geklickten Inhalte verteilt. Klingt komisch, also hier ein kurzes Beispiel:

Pro Monat zur Verfügung gestellter Betrag: 2,00 EUR
In diesem Monat angeklickte Flattr-Buttons: 17
Jeder meiner Klicks war also rund 11 Cent wert, denn 10% behält der Anbieter.

Dabei kann man einen Button pro Monat nur einmal anklicken. Der jeweilige Empfänger kann übrigens nicht sehen, wer ihn angeklickt hat – doch anonym ist man dennoch nicht, da Flattr selbst natürlich alle Transaktionen (und Klicks) detailiert protokolliert.

Möchte man nun Inhalte wie beispielsweise Blogpostings oder Online-Artikel für Flattr-Klicks verfügbar machen, muss man selbst ebenfalls einen aktiven Account haben. Das wiederum setzt voraus, dass man mindestens 2 EUR im Monat bezahlt. Dann jedoch kann man theoretisch beliebig viele “Klicks” von anderen erhalten. Bleibt also nur noch die Frage, ob sich der Dienst für die eigene Seite überhaupt lohnt.

Wenn man mal ganz objektiv nachrechnet lohnt sich Flattr eigentlich erst und nur dann, wenn man über den Dienst mehr als die eigenen monatlichen Kosten wieder rein bekommt. Doch das muss (und soll!) meiner Meinung nach nicht die Hauptmotivation sein. Ich sehe Flattr vielmehr als eine art freiwillige Spende oder – wer ungerne als digitale Version des “Bettlers in der Fußgängerzone” betrachtet werden möchte – ein schnelles und unkompliziertes “Danke”.

In Amerika ist es u.a. in vielen Blogs schon lange üblich einen Paypal-Button zu haben mit der Aufforderung “Du bist dran mit Kaffee holen!” oder ähnlichem. Wenn uns jemand behilflich war bedanken wir uns normalerweise und jemanden auf einen Kaffee einzuladen ist einfach, unverbindlich und macht keine großen Umstände. Und genau diese Mentalität wird hier versucht auch auf die digitale Welt zu übertragen: Wenn ich dir geholfen habe und dir vielleicht sogar Zeit und Ärger erspart habe freut mich das! Und wenn du dich revanchieren möchtest gib mir einfach “einen Kaffee” aus bzw. das monetäre Äquivalent hierzu, also vielleicht 1$. Nur zu gerne vergisst man, dass den Leuten, die anderen freiwillig und oft uneigennützig im Internet mit Artikeln helfen, durchaus reale Kosten entstehen: Die Zeit die man zum Schreiben benötigt, das Webhosting mit Traffic, die eigene Domain… und dennoch machen es viele, einfach weil es ihnen Spaß macht.

Der “Kaffee” über Paypal ist eine Möglichkeit, aber es ist auch aufwändig: Einloggen (dafür den Passwort-Manager starten),  einen plausiblen Betrag überlegen, Zahlungsmethode auswählen, Bestätigen, … selbst wenn die eigentlichen Gebühren nur wenige Cent betragen, der damit verbundene Zeitaufwand ist mir dann doch oft zu hoch. Deshalb mag ich Flattr: Gefällt mir ein Inhalt und ich möchte dem Autor “Danke” sagen, klicke ich auf den Flattr-Button und … fertig! Selbst die Kosten kann ich bequem über einen Schieberegler für einen Monat festlegen, und wenn ich einmal besonders viele Sachen toll fand ist es auch kein Problem kurzfristig mal den monatlichen Betrag zu erhöhen damit alle auch ein wenig mehr bekommen.

Klar, ich habe Flattr auch bei mir im Blog eingebunden. Und ich freue mich natürlich auch, dass mir im ersten Monat 0,91 EUR gutgeschrieben wurden. Ganz unabhängig von dem Geld, dass ich selbst ausgab: Es gab Leute denen das was ich geschrieben habe eine (symbolische) Kleinigkeit wert war!
Klar, große Inhaltsanbieter werden viel größere Summen monatlich erzielen, wie beispielsweise die TAZ, und im Gegenzug vermutlich nur wenig an die Community zurückgeben. Meine Hoffnung ist, dass es dennoch auch für andere Betreiber sowohl ein Ansporn ist qualitativ hochwertige Inhalte zu produzieren, als auch die Arbeit derer zu belohnen die sich hierfür die nötige Zeit nehmen, auch ohne etwas dafür zu fordern.

Einfach mal “Danke” sagen! :-)

Mir ist aufgefallen das in vielen Open-Source Projekte die .resharper Dateien nicht ins Quelltext-Repository aufgenommen werden. Ich bin der Meinung dies ist nicht gut, und hat auch seinen sinn. Dazu habe ich mal kurz – 3:30m - einen Screencast produziert.

Nunja, auch um mal Camtasia und mein neues Mikrofon mal zu testen Es gibt noch Potential zur Verbesserung, wie ich gemerkt habe. Aber es ist ein Anfang.

Also, *.resharper Dateien mit  ins Repository aufnehmen, aber nicht die *.user (.resharper.user) Dateien,

The Windows Phone 7 emulator has a number of shortcut keys that are good to know about:

The hardware keyboard can be toggled by pressing the Pause key, or opened / closed via the Page Up / Page Down key. The hardware keyboard closes the software one, so you can only use on at a time. When the hardware keyboard is open, a little icon is displayed on the top of the screen:

F1 on the keyboard equals to pressing the back button on the phone.

Pressing the F2 or the Windows key while the emulator has focus acts as if the phone’s Windows key was pressed. Continuously pressing it for a while brings up the voice command / search interface.

F3 works as the third physical button on the phone, bring up the Bing search.

F7 is wired to the physical camera button.

F9 and F10 raise and lower the volume. Pressing these brings up an interesting piece of UI, for controlling the currently playing music or radio, and switching the phone to vibrate.

F11 acts as the play / pause button. It is interesting that such a button is in the emulator as this button is not a required hardware button for Windows Phone 7 (WP7).

Rene Schulte hat wieder zugeschlagen, diesmal bringt er Grafikeffekte auf Windows Phone 7. Im Blog von Coding4Fun hat er dazu einen sehr ausführlichen ersten Artikel veröffentlicht.

Link zum Artikel

Link zum Codeplexprojekt

Viele Entwickler verbringen einen Großteil ihrer Arbeitszeit mit dem Lesen, Verstehen und (Um-)Schreiben von Code innerhalb der IDE ihrer Wahl – Im Falle der .NET-Entwickler zumeist Microsoft Visual Studio. Leider gelten fast alle folgenden Empfehlungen nicht für die Nutzer der kostenfreien Express-Version, da diese keine Plug-Ins von Fremdherstellern unterstützt. Alle anderen sind aber eingeladen weiter zu lesen mit welchen ausgesuchten Helfern ich mir die Arbeit täglich aufs neue erleichtere.

Einige Erweiterungen wird man hier vergeblich suchen, darunter auch den bekanntesten Vertreter aus dem Hause Jetbrains. Nicht, dass ich ReSharper nicht schon selbst benutzt hätte und seine Funktionen den Entwickleralltag stark vereinfachen können. Jedoch soll meine Auflistung hier nur kostenfreie Plug-Ins aufzählen.

Wenn man beispielsweise die Microsoft Gallerie der Visual Studio Plug-Ins durchgeht findet man hunderte von kostenlosen Helfern. Einige sind völlig unbrauchbar, manche fehlerhaft und hinter einigen verstecken sich in Wahrheit Trial-Versionen von oft teuren Vollprodukten. Doch es gibt auch einige besondere Schätze die sich zu finden lohnen. Ich habe mich auf die langwierige Suche nach der Nadel im Nadelhaufen gemacht und hier ist schließlich meine reiche Ausbeute!

AnkhSVN

Autor: Collabnet
URL: http://ankhsvn.open.collab.net/
Beschreibung: Wohl zu den bekanntesten Vertretern der Versionsverwaltungen gehört Subversion. AnkhSVN ist ein Plug-In, dass sich seit Version 2 als SCC-Provider in Visual Studio einträgt und so eine optimale Integration bietet. War AnkhSVN in früheren Versionen noch eher ein Projekt für Experimentierfreudige und Bastler, so ist die nahtlose Integration in die IDE nun wirklich gelungen und bedarf kaum zusätzlicher Arbeitsschritte. Als kostenfreie Alternative zum früher auch von mir eingesetzten VisualSVN definitiv zu empfehlen!

Chirpy

Autor: @weirdmvc
URL: http://chirpy.codeplex.com/
Beschreibung: Das beste an Chirpy? Das Maskotchen ;-) Aber ernsthaft: Das Plugin vereint zahlreiche nützliche Features für Web-Entwickler: Javascript- und CSS-Komprimierung, Verarbeitung von .LESS-Dateien und das automatische Ausführen von T4-Templates. Ich weiss gar nicht wie ich so lange ohne dieses Plug-In auskommen konnte! Naja, schon: Ich habe CSS-Dateien nie minimiert / optimiert und wenn keine minifizierte Version eines Javascripts vorlag dann wurde halt die unkomprimierte verwendet. Man kann zwar auch auf Build-Scripte & co. zurückgreifen, aber ich bevorzuge diese einfache und bequeme Möglichkeit beim Speichern. Dass T4-Scripte wie T4MVC automatisiert beim Speichern ausgeführt werden können ist quasi das Sahnehäubchen.

Color Picker Completion

Autor: Brian Chamberlain [MSFT] (Microsoft)
URL: Visual Studio Gallery
Beschreibung: Ein Bild sagt mehr als tausend Worte. Oder in unserem Fall eine Farbe. Das Plug-In zeigt im Standard-Auswahldialog statt dem Icon die jeweilige Farbe neben dem Namen an, so dass die Auswahl erleichtert wird. Oder könnt ihr euch spontan unter “DarkSalomon” etwas vorstellen? Ich jetzt schon :-)

CSS is Less

Autor: Noah Richards
URL: Visual Studio Gallery
Beschreibung: Passend zu Chirpy hier ein weiteres Plug-In um die .LESS-Unterstützung in Visual Studio zu verbessern. Wer nicht weiß was das überhaupt für Dateien sind darf zunächst hier kurz vorbei schauen. Jedenfalls sorgt diese Erweiterung dafür, dass .less-Dateien mit dem CSS-Editor von Visual Studio geöffnet werden. Das bringt einem zwar Intellisense für CSS und auch Syntax-Highlighting, doch verschachtelte Styles, Variabeln & co. sorgen für ein wenig Durcheinander. Dennoch besser als gar nichts; und bis mein eigenes Plugin fertig ist, welches für eine umfangreiche .less-Unterstützung sorgen soll, ist dieses hier eine gute Zwischenlösung.

devColor

Autor: Mario185 (donmar)
URL: Visual Studio Gallery
Beschreibung: Manche sollen ja den HEX-Code einer Farbe nur kurz ansehen können und haben sofort den genauen Farbton vor Augen. Ich gehöre leider nicht zu diesem erlesenen Kreis und wenn ihr das ebenfalls nicht könnt, nicht weiter schlimm: devColor unterstreicht alle Farbangaben in CSS-Dateien mit der dazugehörigen Farbe. Ausserdem gibt es dazu noch einen Color-Picker, eine Funktion um alle in der Datei verwendeten Farben anzuzeigen und zu ersetzen. Wieder ein Tool aus der Kategorie “Warum kann VS2k10 das nicht schon von Haus aus?!”

VSCommands 2010

Autor: DPStudio
URL: http://vscommands.com/
Beschreibung: Dieses Plug-In ist ein wenig grenzwertig und ich habe überlegt ob ich es überhaupt mit in diese Liste aufnehmen soll da die kostenlose Version doch arg im Funktionsumfang eingeschränkt wurde und viele neue Funktionen aussschließlich in der kostenpflichtigen “Pro”-Version enthalten sind. Schließlich erwähne ich es hier doch und jeder darf sich selbst ein Urteil bilden ob ihm die gebotenen Funktionen eine Installation wert sind. Die für mich nützlichste Funktion ist Group/Ungroup, um mehrere Dateien in einem Projekt (visuell) zusammen zu fassen.

CodeRush Xpress for C# and VB

Autor: http://devexpress.com/
URL: http://devexpress.com/Products/Visual_Studio_Add-in/CodeRushX/
Beschreibung: Der “kleine” Bruder zum kostenpflichtigen Pro-Plug-In von Devexpress braucht sich nicht zu verstecken. Auch in der kostenfreien “Xpress”-Variante werden zahlreiche nützliche Helfer und Refactorings angeboten. Im Prinzip ähnlich wie ReSharper so gibt es vor allem in der Handhabung einige Unterschiede. Auch die visuelle Darstellung mit den Pfeilen und Linien ist am Anfang gewöhnungsbedürftig, dafür aber auch schnell und intuitiv begreifbar. Sicherlich also einen Blick wert!

Export Template Wizard

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Wer eigene Projektstrukturen als Vorlage speichern will um sie im Team oder der Community weiter zu geben, sollte sich dieses Plug-In einmal näher anschauen. Es vereinfacht den Prozess mit hilfe eines Assistenten, unterstützt mehrere Projekte pro Solution, man kann das Ziel-Framework festlegen, … Am Ende hat man eine handliche VSIX-Datei die mit einem einfach Doppelklick schnell überall installiert werden kann.

GhostDoc

Autor: SubMain - CodeIt.Right The First Time!
URL: http://submain.com/products/ghostdoc.aspx
Beschreibung: Es fällt uns meistens leichter einen bestehenden Text einfach nur anzupassen als ihn komplett neu zu schreiben. Nicht nur das es weniger Tipparbeit ist, auch einen Anfang zu finden wird einem abgenommen. In diesem Fall von GhostDoc, welches einem die lästige Arbeit des Erstellens von XML-Kommentaren abnimmt. OK, vielleicht nicht vollständig, aber die Ergebnisse sind oft ganz brauchbar. Wie? Ihr schreibt gar keine XML-Kommentare? Merde…

Hide Main Menu

Autor: Matthew Johnson [MSFT]
URL: Visual Studio Gallery
Beschreibung: Möglichst wenig Ablenkung und viel Platz für das Wichtigste: Den Source-Code! Das muss sich Matthew Johnson gedacht haben als er diese Erweiterung schrieb. Sie blendet analog zum Windows Explorer und Internet Explorer die Menü-Leiste standardmäßig aus und erst wenn man ALT oder ALT + <Shortcut> drückt wird sie wieder eingeblendet. Praktisch!

Lipsum 2010 – Lorem Ipsum Generator

Autor: Auri Rahimzadeh (The Auri Group (www.aurigroup.com))
URL: Visual Studio Gallery
Beschreibung: Während der Umsetzung eines Designs fehlt oft noch der richtige Text. Doch ohne Inhalte kann man ein Design oft nicht sinnvoll testen. Früher nur bei Setzern und Mediengestaltern bekannt, hat fast jeder heute zumindest das übliche “Lorem ipsum dolor sit amet” einmal gelesen/gesehen. Und auch wenn diese Erweiterung eine UI zum Davonlaufen hat (!!!) so habe ich doch keine vergleichbare gefunden und immer erst einen Browser mit einer der zahlreichen Generatoren zu öffnen ist auf Dauer auch etwas mühsam. Daher leicht widerstrebend auch dieses Plug-In in meiner Empfehlungsliste.

Regex Editor

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Manch einer hält sie für schwarze Magie, andere lieben sie (ich!): Reguläre Ausdrücke, kurz RegEx. Die Schar derer, die einen komplexeren Ausdruck ohne Hilfsmittel lesen oder schreiben können schwindet immer mehr, doch für alle anderen kommt diese Erweiterung zur Hilfe mit Intellisense und Syntaxhighlighting. Als Schmankerl legt Microsoft den Quellcode des Plug-Ins noch obendrauf um sie als Beispiel für eigene Erweiterungen herzunehmen.

PowerCommands for Visual Studio 2010

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Und noch eine Erweiterung von Microsoft. Zahlreiche kleine Funktionen wie das Versenden von Code-Schnipseln als E-Mail, ein Undo-Close, Copy-/Paste-Class oder Format document on safe. Über die Optionen lassen sich einzelne Funktionen ein- und ausschalten und die Erweiterung so an die eigenen Bedürfnisse anpassen.

Productivity Power Tools

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Einige Blog-Artikel aus der jüngsten Zeit dieses Plug-In betreffend haben mich eigentlich dazu bewogen diesen Artikel zu schreiben. Denn die Productivity Power Tools habe ich schon seit längerem lieben und schätzen gelernt doch meine Annahme, dass sie allgemein bekannt wären, schien wohl (damals) ein Irrtum gewesen zu sein. Das herausstechendste Merkmal ist wohl der kürzlich hinzugekommene Solution Explorer, aber auch die vielen anderen Extras machen diese Erweiterung besonders empfehlenswert! Schaut sie euch am besten einfach selbst einmal an oder – wenn ihr mir nicht glaubt – lest beispielsweise bei Scott Guthrie weiter :-)

Visual Studio Color Theme Editor

Autor: Matthew Johnson [MSFT]
URL: Visual Studio Gallery
Beschreibung: Für alle denen ein individuelles Farbschema im Editor nicht genug ist gibt es mit diesem Plug-In die Möglichkeit auch den Rest der IDE “anzumalen”. Neben einigen Presets gibt es auch die Möglichkeit die Farben komplett selbst zu bestimmen. WPF sei dank.

Windows 7 Taskbar Extension

Autor: Dmitry Sitnikov (SSS)
URL: Visual Studio Gallery
Beschreibung: Windows 7 verkauft sich ja beinahe von selbst, wenn man den Verkaufszahlen von Microsoft glauben darf. Dennoch ist es eigentlich unverständlich, warum VIsual Studio 2010 nicht ein paar mehr der neuen Features des Betriebssystems nutzt. Dieses Plug-In rüstet ein paar nützliche Buttons und Overlay-Icons für die Windows 7 Taskleiste nach und füllt so die Lücke von Microsoft zumindest provisorisch.

Viele Entwickler verbringen einen Großteil ihrer Arbeitszeit mit dem Lesen, Verstehen und (Um-)Schreiben von Code innerhalb der IDE ihrer Wahl – Im Falle der .NET-Entwickler zumeist Microsoft Visual Studio. Leider gelten fast alle folgenden Empfehlungen nicht für die Nutzer der kostenfreien Express-Version, da diese keine Plug-Ins von Fremdherstellern unterstützt. Alle anderen sind aber eingeladen weiter zu lesen mit welchen ausgesuchten Helfern ich mir die Arbeit täglich aufs neue erleichtere.

Einige Erweiterungen wird man hier vergeblich suchen, darunter auch den bekanntesten Vertreter aus dem Hause Jetbrains. Nicht, dass ich ReSharper nicht schon selbst benutzt hätte und seine Funktionen den Entwickleralltag stark vereinfachen können. Jedoch soll meine Auflistung hier nur kostenfreie Plug-Ins aufzählen.

Wenn man beispielsweise die Microsoft Gallerie der Visual Studio Plug-Ins durchgeht findet man hunderte von kostenlosen Helfern. Einige sind völlig unbrauchbar, manche fehlerhaft und hinter einigen verstecken sich in Wahrheit Trial-Versionen von oft teuren Vollprodukten. Doch es gibt auch einige besondere Schätze die sich zu finden lohnen. Ich habe mich auf die langwierige Suche nach der Nadel im Nadelhaufen gemacht und hier ist schließlich meine reiche Ausbeute!

AnkhSVN

Autor: Collabnet
URL: http://ankhsvn.open.collab.net/
Beschreibung: Wohl zu den bekanntesten Vertretern der Versionsverwaltungen gehört Subversion. AnkhSVN ist ein Plug-In, dass sich seit Version 2 als SCC-Provider in Visual Studio einträgt und so eine optimale Integration bietet. War AnkhSVN in früheren Versionen noch eher ein Projekt für Experimentierfreudige und Bastler, so ist die nahtlose Integration in die IDE nun wirklich gelungen und bedarf kaum zusätzlicher Arbeitsschritte. Als kostenfreie Alternative zum früher auch von mir eingesetzten VisualSVN definitiv zu empfehlen!

Chirpy

Autor: @weirdmvc
URL: http://chirpy.codeplex.com/
Beschreibung: Das beste an Chirpy? Das Maskotchen ;-) Aber ernsthaft: Das Plugin vereint zahlreiche nützliche Features für Web-Entwickler: Javascript- und CSS-Komprimierung, Verarbeitung von .LESS-Dateien und das automatische Ausführen von T4-Templates. Ich weiss gar nicht wie ich so lange ohne dieses Plug-In auskommen konnte! Naja, schon: Ich habe CSS-Dateien nie minimiert / optimiert und wenn keine minifizierte Version eines Javascripts vorlag dann wurde halt die unkomprimierte verwendet. Man kann zwar auch auf Build-Scripte & co. zurückgreifen, aber ich bevorzuge diese einfache und bequeme Möglichkeit beim Speichern. Dass T4-Scripte wie T4MVC automatisiert beim Speichern ausgeführt werden können ist quasi das Sahnehäubchen.

Color Picker Completion

Autor: Brian Chamberlain [MSFT] (Microsoft)
URL: Visual Studio Gallery
Beschreibung: Ein Bild sagt mehr als tausend Worte. Oder in unserem Fall eine Farbe. Das Plug-In zeigt im Standard-Auswahldialog statt dem Icon die jeweilige Farbe neben dem Namen an, so dass die Auswahl erleichtert wird. Oder könnt ihr euch spontan unter “DarkSalomon” etwas vorstellen? Ich jetzt schon :-)

CSS is Less

Autor: Noah Richards
URL: Visual Studio Gallery
Beschreibung: Passend zu Chirpy hier ein weiteres Plug-In um die .LESS-Unterstützung in Visual Studio zu verbessern. Wer nicht weiß was das überhaupt für Dateien sind darf zunächst hier kurz vorbei schauen. Jedenfalls sorgt diese Erweiterung dafür, dass .less-Dateien mit dem CSS-Editor von Visual Studio geöffnet werden. Das bringt einem zwar Intellisense für CSS und auch Syntax-Highlighting, doch verschachtelte Styles, Variabeln & co. sorgen für ein wenig Durcheinander. Dennoch besser als gar nichts; und bis mein eigenes Plugin fertig ist, welches für eine umfangreiche .less-Unterstützung sorgen soll, ist dieses hier eine gute Zwischenlösung.

devColor

Autor: Mario185 (donmar)
URL: Visual Studio Gallery
Beschreibung: Manche sollen ja den HEX-Code einer Farbe nur kurz ansehen können und haben sofort den genauen Farbton vor Augen. Ich gehöre leider nicht zu diesem erlesenen Kreis und wenn ihr das ebenfalls nicht könnt, nicht weiter schlimm: devColor unterstreicht alle Farbangaben in CSS-Dateien mit der dazugehörigen Farbe. Ausserdem gibt es dazu noch einen Color-Picker, eine Funktion um alle in der Datei verwendeten Farben anzuzeigen und zu ersetzen. Wieder ein Tool aus der Kategorie “Warum kann VS2k10 das nicht schon von Haus aus?!”

VSCommands 2010

Autor: DPStudio
URL: http://vscommands.com/
Beschreibung: Dieses Plug-In ist ein wenig grenzwertig und ich habe überlegt ob ich es überhaupt mit in diese Liste aufnehmen soll da die kostenlose Version doch arg im Funktionsumfang eingeschränkt wurde und viele neue Funktionen aussschließlich in der kostenpflichtigen “Pro”-Version enthalten sind. Schließlich erwähne ich es hier doch und jeder darf sich selbst ein Urteil bilden ob ihm die gebotenen Funktionen eine Installation wert sind. Die für mich nützlichste Funktion ist Group/Ungroup, um mehrere Dateien in einem Projekt (visuell) zusammen zu fassen.

CodeRush Xpress for C# and VB

Autor: http://devexpress.com/
URL: http://devexpress.com/Products/Visual_Studio_Add-in/CodeRushX/
Beschreibung: Der “kleine” Bruder zum kostenpflichtigen Pro-Plug-In von Devexpress braucht sich nicht zu verstecken. Auch in der kostenfreien “Xpress”-Variante werden zahlreiche nützliche Helfer und Refactorings angeboten. Im Prinzip ähnlich wie ReSharper so gibt es vor allem in der Handhabung einige Unterschiede. Auch die visuelle Darstellung mit den Pfeilen und Linien ist am Anfang gewöhnungsbedürftig, dafür aber auch schnell und intuitiv begreifbar. Sicherlich also einen Blick wert!

Export Template Wizard

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Wer eigene Projektstrukturen als Vorlage speichern will um sie im Team oder der Community weiter zu geben, sollte sich dieses Plug-In einmal näher anschauen. Es vereinfacht den Prozess mit hilfe eines Assistenten, unterstützt mehrere Projekte pro Solution, man kann das Ziel-Framework festlegen, … Am Ende hat man eine handliche VSIX-Datei die mit einem einfach Doppelklick schnell überall installiert werden kann.

GhostDoc

Autor: SubMain - CodeIt.Right The First Time!
URL: http://submain.com/products/ghostdoc.aspx
Beschreibung: Es fällt uns meistens leichter einen bestehenden Text einfach nur anzupassen als ihn komplett neu zu schreiben. Nicht nur das es weniger Tipparbeit ist, auch einen Anfang zu finden wird einem abgenommen. In diesem Fall von GhostDoc, welches einem die lästige Arbeit des Erstellens von XML-Kommentaren abnimmt. OK, vielleicht nicht vollständig, aber die Ergebnisse sind oft ganz brauchbar. Wie? Ihr schreibt gar keine XML-Kommentare? Merde…

Hide Main Menu

Autor: Matthew Johnson [MSFT]
URL: Visual Studio Gallery
Beschreibung: Möglichst wenig Ablenkung und viel Platz für das Wichtigste: Den Source-Code! Das muss sich Matthew Johnson gedacht haben als er diese Erweiterung schrieb. Sie blendet analog zum Windows Explorer und Internet Explorer die Menü-Leiste standardmäßig aus und erst wenn man ALT oder ALT + <Shortcut> drückt wird sie wieder eingeblendet. Praktisch!

Lipsum 2010 – Lorem Ipsum Generator

Autor: Auri Rahimzadeh (The Auri Group (www.aurigroup.com))
URL: Visual Studio Gallery
Beschreibung: Während der Umsetzung eines Designs fehlt oft noch der richtige Text. Doch ohne Inhalte kann man ein Design oft nicht sinnvoll testen. Früher nur bei Setzern und Mediengestaltern bekannt, hat fast jeder heute zumindest das übliche “Lorem ipsum dolor sit amet” einmal gelesen/gesehen. Und auch wenn diese Erweiterung eine UI zum Davonlaufen hat (!!!) so habe ich doch keine vergleichbare gefunden und immer erst einen Browser mit einer der zahlreichen Generatoren zu öffnen ist auf Dauer auch etwas mühsam. Daher leicht widerstrebend auch dieses Plug-In in meiner Empfehlungsliste.

Regex Editor

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Manch einer hält sie für schwarze Magie, andere lieben sie (ich!): Reguläre Ausdrücke, kurz RegEx. Die Schar derer, die einen komplexeren Ausdruck ohne Hilfsmittel lesen oder schreiben können schwindet immer mehr, doch für alle anderen kommt diese Erweiterung zur Hilfe mit Intellisense und Syntaxhighlighting. Als Schmankerl legt Microsoft den Quellcode des Plug-Ins noch obendrauf um sie als Beispiel für eigene Erweiterungen herzunehmen.

PowerCommands for Visual Studio 2010

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Und noch eine Erweiterung von Microsoft. Zahlreiche kleine Funktionen wie das Versenden von Code-Schnipseln als E-Mail, ein Undo-Close, Copy-/Paste-Class oder Format document on safe. Über die Optionen lassen sich einzelne Funktionen ein- und ausschalten und die Erweiterung so an die eigenen Bedürfnisse anpassen.

Productivity Power Tools

Autor: Microsoft Corp
URL: Visual Studio Gallery
Beschreibung: Einige Blog-Artikel aus der jüngsten Zeit dieses Plug-In betreffend haben mich eigentlich dazu bewogen diesen Artikel zu schreiben. Denn die Productivity Power Tools habe ich schon seit längerem lieben und schätzen gelernt doch meine Annahme, dass sie allgemein bekannt wären, schien wohl (damals) ein Irrtum gewesen zu sein. Das herausstechendste Merkmal ist wohl der kürzlich hinzugekommene Solution Explorer, aber auch die vielen anderen Extras machen diese Erweiterung besonders empfehlenswert! Schaut sie euch am besten einfach selbst einmal an oder – wenn ihr mir nicht glaubt – lest beispielsweise bei Scott Guthrie weiter :-)

Visual Studio Color Theme Editor

Autor: Matthew Johnson [MSFT]
URL: Visual Studio Gallery
Beschreibung: Für alle denen ein individuelles Farbschema im Editor nicht genug ist gibt es mit diesem Plug-In die Möglichkeit auch den Rest der IDE “anzumalen”. Neben einigen Presets gibt es auch die Möglichkeit die Farben komplett selbst zu bestimmen. WPF sei dank.

Windows 7 Taskbar Extension

Autor: Dmitry Sitnikov (SSS)
URL: Visual Studio Gallery
Beschreibung: Windows 7 verkauft sich ja beinahe von selbst, wenn man den Verkaufszahlen von Microsoft glauben darf. Dennoch ist es eigentlich unverständlich, warum VIsual Studio 2010 nicht ein paar mehr der neuen Features des Betriebssystems nutzt. Dieses Plug-In rüstet ein paar nützliche Buttons und Overlay-Icons für die Windows 7 Taskleiste nach und füllt so die Lücke von Microsoft zumindest provisorisch.

Ganz unbemerkt und überraschend habe ich vorgestern den 200. Blogeintrag gepostet. Dafür das mir vor zweieinhalb Jahren, von Stefan Falz, dieser Blog ganz überraschend zur Verfügung gestellt wurde. Und ich am Anfang noch gar nicht wusste, was ich hier eigentlich schreiben soll.

Übrigens war es der olle Schweizer, der mich damals dazu überredet hat, hier hin und wieder mal was mehr oder weniger Sinnvolles zu schreiben ;-)
(Eine weitere Ausnahme ist dieser Beitrag: eher Sinn frei)

PS: Bitte kein unnötiges Lob an dieser Stelle. Andere schreiben um längen mehr, besser und fehlerfreier als ich. Ich war nur recht überrascht von der Zahl 200 und für Twitter ist der Post einfach zu lang. ;-)

Es hat sich einiges getan bei den Vorbereitungen zur See# Party.

Sprecher und Themen

Nicht nur die Sprecher und Themen sind jetzt komplett und auch der schwierigste Part, die Agenda, ist nun seit diesem Wochenende auf der Website veröffentlicht.

Eine kleine Auswahl der Sprecher:

• Golo Roden
• Stefan Lieser
• Laurent Bugnion
• Roland Weigelt
• Albert Weinert
• und 11 weitere…

Eine kleine Auswahl der Themen:

• Building Windows Phone 7 applications with Silverlight
• IronRuby für .NET Developer
• Advanced ASP.NET MVC
• ADO.NET Entity Framework
• TFS 2010 Neuerungen und Highlights
• und 11.weitere…

Agenda

Am ursprünglichen Zeitplan für die Agenda haben wir noch etwas geschraubt. So haben wir die Mittagspause um eine Halbe Stunde verlängert, um Lunch-Sessions versetzt starten zu können. Zusätzlich gibt es nun doch eine Pause von 15 Minuten zwischen der Key Note und der ersten Session *fg*

Weiter zur Agenda

.NET Codeing Dojo

Ein besonderes Special können wir - dank Stefan Lieser - während der Grillparty bieten: Stefan hat sich bereit erklärt am Abend ein .NET Coding Dojo zu leiten. Da die Räumlichkeiten eh zur Verfügung stehen können die auch dafür genutzt werden. So kann ab 19:30 (nach dem Essen) das Dojo starten.

Gewinnspiel

Natürlich gibt es auch etwas mit nach Hause zu nehmen. Neben einem attraktiven Willkommensgeschenk für jeden Teilnehmer gibt es auch hier – dank der Zahlreichen Sponsoren – einiges zu gewinnen. Hier eine kleine Auswahl:

• Viele Fachbücher von MS Press und Entwickler Press
• Einen Team Foundation Server und ein Expression Web von Microsoft
• Zwei Typemock Isolator
• Eine Telerik Premium Collection for .NET
• Zweimal ReSharper und zweimal dotTrace von JetBrains
• Eine Lizenz des TX Text Control .NET Professiona
• Fünfmal Langmeier Backup Small Business
• Fünfmal den tangible T4 Editor
• und vieles mehr...

Twitter, Facebook und Co.

@dotnetkk twittert immer wieder Neuigkeiten zur See# Party unter dem Hashtag #ssp2010
Ebenso auf der Facebook Veranstaltung und auf der Facebook Seite zur .NET User Group Konstanz-Keuzlingen werden News veröffentlicht

Anmeldung

Die Anmeldung für die Teilnehmer ist nur noch bis zum am 21.08.2010 offen. Wer also noch an der See# Party teilnehmen möchte sollte sich beeilen um sich die letzten Plätze zu sichern :-)

Schnell anmelden…

Seit einigen Tagen steht das seit längerem angekündigte Windows Presentation Framework Ribbon Steuerelement nun in der finalen Version zur Verfügung.

Das neue Ribbon-Steuerelement ist kompatibel mit WPF 3.5 Service Pack 1 und WPF 4. Dabei handelt es sich um eine 100% WPF-Implementierung und nicht um einen Wrapper um den nativen Systemcode. Das bedeutet konkret, dass man alle WPF Styling-Fähigkeiten für die neuen Steuerelemente erhält.

Die folgenden Screenshots sind mit dem .NET 4 Client Profile Projektvorlagen erstellt worden.

Hier ein Blick auf einige der interessanten Funktionen.

Ribbon Application Projekt Vorlage

Der Ribbon-Installer beinhaltet eine “WPF Ribbon Application” Projektvorlage für Visual Studio.

Wenn man ein neues Ribbon-Projekt erstellt und anschließend sofort startet erhalt man die folgende Anwendung:

Der XAML-Code für das Standard-Ribbon sieht wie folgt aus:

<ribbon:Ribbon x:Name="Ribbon">

    <ribbon:Ribbon.ApplicationMenu>

        <ribbon:RibbonApplicationMenu SmallImageSource="Images\SmallIcon.png">

            <ribbon:RibbonApplicationMenuItem Header="Hello _Ribbon"

                                              x:Name="MenuItem1"

                                              ImageSource="Images\LargeIcon.png"/>

        </ribbon:RibbonApplicationMenu>

    </ribbon:Ribbon.ApplicationMenu>

    <ribbon:RibbonTab x:Name="HomeTab"

                      Header="Home">

        <ribbon:RibbonGroup x:Name="Group1" 

                            Header="Group1">

            <ribbon:RibbonButton x:Name="Button1"

                                 LargeImageSource="Images\LargeIcon.png"

                                 Label="Button1" />

            <ribbon:RibbonButton x:Name="Button2"

                                 SmallImageSource="Images\SmallIcon.png"

                                 Label="Button2" />

            <ribbon:RibbonButton x:Name="Button3"

                                 SmallImageSource="Images\SmallIcon.png"

                                 Label="Button3" />

            <ribbon:RibbonButton x:Name="Button4"

                                 SmallImageSource="Images\SmallIcon.png"

                                 Label="Button4" />

        </ribbon:RibbonGroup>

    </ribbon:RibbonTab>

</ribbon:Ribbon>

Das Fenster, das das Ribbon beinhaltet ist von der Klasse RibbonWindow abgeleitet. Diese Klasse verwendet nativen Interopcode, der den Zugriff auf die Nicht-Client-Grafikbereich zu erleichtert. Die Verwendung dieser Basisklasse ist absolut optional, solange man auf diese spezielleren Funktionen keinen Zugriff benötigt.

Das Ribbon-Steuerelement hat alle Funktionen die man erwartet: Quick Access Toolbar, Application Menu, Hilfsfunktionen, erweiterte Tooltips, Tastenkürzelvorschau, automatisches Anpassen der Größe und Anordnung, kontextuelle Gruppen, das schicken Windows 7 Look-and-Feel, und vieles mehr.

Kontextuelle Gruppen

Um ein neues RibbonTab (Reiter) in eine kontextuelle Gruppe, wie z.B. die Bildbearbeitungswerkzeuge in Word, zu erstellen, muss man lediglich die gewünschten Elemente im XAML-Code in den Bereich ContextualTabGroup-Bereich einfügen:

<ribbon:RibbonTab x:Name="AwesomeTab"

                  ContextualTabGroupHeader="Awesome Tools"

                  Header="Really Awesome">

    <ribbon:RibbonGroup x:Name="Group2"

                        Header="Group2">

        <ribbon:RibbonButton x:Name="Button21"

                             LargeImageSource="Images\LargeIcon.png"

                             Label="Button21" />

    </ribbon:RibbonGroup>

</ribbon:RibbonTab>

<ribbon:Ribbon.ContextualTabGroups>

    <ribbon:RibbonContextualTabGroup Header="Awesome Tools"

                                     Visibility="Visible"

                                     Background="Green" />

</ribbon:Ribbon.ContextualTabGroups>

Man achte hier auf die grüne Kopfzeile über dem Ribbon.

Quick Access Toolbar

Wie nicht anders zu erwarten, unterstützt das Ribbon auch die Quick Access Toolbar (in der Windows-Titelleiste).

<ribbon:Ribbon.QuickAccessToolBar>

    <ribbon:RibbonQuickAccessToolBar>

        <ribbon:RibbonButton x:Name="ButtonQ1"

                             SmallImageSource="Images\SmallIcon.png"

                             Label="ButtonQ1" />

        <ribbon:RibbonButton x:Name="ButtonQ2"

                             SmallImageSource="Images\SmallIcon.png"

                             Label="ButtonQ2" />

        <ribbon:RibbonButton x:Name="ButtonQ3"

                             SmallImageSource="Images\SmallIcon.png"

                             Label="ButtonQ3" />

    </ribbon:RibbonQuickAccessToolBar>

</ribbon:Ribbon.QuickAccessToolBar>

Dieser Screenshot zeigt zwei der Quick Access Buttons links oben im Fenster, mit dem Pfeil der andeutet, das dort noch mehr Buttons auf einen warten.

Das WPF Ribbon Team hat einen großartigen Job geleistet, dieses Steuerelement zu erstellen und komfortable für Entwickler zu gestalten. Es unterstützt eine Vielzahl von Szenarios und auch den aktuellen Windows 7 UI-Style.

PS: Und ja, der RibbonButton unterstützt auch ICommand.

Links

Download-Link: http://www.microsoft.com/downloads/details.aspx?FamilyID=2BFC3187-74AA-4154-A670-76EF8BC2A0B4&displaylang=en

Dokumentation-Link: http://msdn.microsoft.com/en-us/library/ff799534.aspx

Der Team Foundation Server bietet ein extrem flexibles und leistungsfähiges Konzept zur Definition von Work Items. Damit lassen sich viele Szenarien über eine reine Konfiguration abbilden. Um die Mächtigkeit zu demonstrieren, hier ein paar Beispiele. Diese Beispiele nutzen den Process Template Editor der Bestandteil der kostenlosen Team Foundation Server 2010 Power Tools ist.

1.) Nur bestimmte Benutzer sollen ein Workitem eines bestimmten Typs anlegen dürfen

Ein verbreitetes Szenario ist, dass nur ein bestimmter Personenkreis Workitems eines bestimmten Typs (in diesem Beispiel der Typ Bug) anlegen dürfen, andere Benutzer sollen diese aber weiter bearbeiten können. Auch wenn die Umsetzung nicht ganz ideal ist lässt sich diese Funktion mit dem TFS relativ einfach erreichen.

Wie im Screenshot zu sehen, ist der Status Active für diesen Benutzer ungültig. Damit kann er das Workitem nicht speichern. Wie gesagt, nicht gerade schön aber wirkungsvoll. Wie erreichen wir nun diese Funktion?

Im Process Template Editor sehen wir im Workflow des Bug-WIT eine Transition von nirgendwo nach Active

Diese Transition wird verwendet wenn ein neues Workitem angelegt wird. Auf dieser Transition können wir nun eine Berechtigung einstellen. Dazu geben wir in das Feld “For” eine TFS Gruppe ein die diese Funktion ausführen darf. Alternativ kann bei “Not” eine Gruppe angeben die diese Transition nicht nutzen darf.

Dieses Feature kann natürlich auch für Transitions zwischen zwei Status genutzt werden, also z.B. um zu steuern wer den Bug schließen darf.

2.) Ein Feld muss gefüllt sein wenn ein anderes einen bestimmten Wert hat

In der Praxis kommt es häufiger vor, dass iin Abhängigkeit eines Wertes ein anderes Feld ausgefüllt sein muss. In unserem Beispiel nehmen wir mal an, dass auf dem Bug die Repro-Stepsausgefüllt sein müssen wenn der Bug die Priorität 1 hat.

Dazu stellen wir auf dem Feld Repro Steps eine WHEN-Regel ein

Und sagen wenn diese Bedingung erfüllt ist, dann soll das Feld ein Pflichtfeld sein

3.) Befüllen einer Auswahlliste in Abhängigkeit eines anderen Feldes

Das dritte Beispiel soll uns die Auswahlliste eines Feldes in Abhängigkeit eines anderen Feldes befüllen. In unserem Beispiel soll das Feld Team in Abhängigkeit der Area befüllt werden.

Dazu definieren wir für das Feld Team das wir zuvor hinzugefügt haben 2 When-Regeln

An dieser Stelle verwenden wir für die Regel nicht das Feld AreaPath da hierarchische Felder in Regeln nicht richtig unterstützt werden. Diese produzieren dann beim Import des WIT den Fehler "TF26204: The account you entered is not recognized". Der Umweg über die AreaID umgeht diese Problem.

Dann stellen wir einfach die AllowedValues für die beiden Fälle ein.

Man sieht also, dass der TFS einiges an Flexibiölität zu beieten hat. Es lohnt sich damit mal etwas zu experimentieren. Generell möchte ich aber vor Überregulierung warnen weil dies in der Praxis meist dazu führt, dass die Anwender behindert werden und somit die Akzeptanz des Tools sinkt.

Tech∙Ed Europe 2010 returns to Berlin!

Vom 8. bis 12. November 2010 findet das wichtigste europäische Technologie-Event von Microsoft für Software-Entwickler und IT Pros statt.

Anlässlich dieser Technologie Konferenz veranstaltet dotnet-snippets.de ein Gewinnspiel bei dem es unter anderem ein Ticket für die Tech-Ed zu gewinnen gibt. Weitere Preise sind ein Windows 7 Ultimate (not for resale) und ein Buch für Windows 7 Entwickler.

Das Freiticket für die Tech-Ed hat einen Wert von 1.695,- € (Early Bird bis zum 31.08.2010; Normalpreis 1.895,-€; zzgl. MwSt.)

Das Gewinnspiel beginnt am 9. August 2010 und endet am 22. August 2010.

Hier geht es zum Gewinnspiel…

Bei der WinForms-Entwicklung werden Bindings wie folgt definiert:

public interface IPersonViewModel { 
	string Name { get; set; } 
}

public partial class Form1 : Form, IPersonView { 
	private IPersonViewModel _viewModel;

	public void BindToViewModel(IPersonViewModel viewModel) { 
		_viewModel = viewModel; 

		Binding binding = new Binding(“Text”, _viewModel, “Name”);
		nameTextBox.Bindings.Add(binding);
	}
}

Das ganze funktioniert soweit problemlos.

Allerdings gibt es zwei “Schönheitsfehler”:

1. Hat man Tippfehler im Namen der Property (hier “Text”) oder im Namen des DataMembers (hier “Name”), fällt das erst zur Laufzeit infolge einer Exception auf
2. Refaktorisiert man das Model, bekommt das Binding davon nichts mit – Resultat: siehe 1.

Mithilfe der folgenden ExtensionMethod kann man beide Probleme elegant umschiffen:

public static void SetBinding<TModel>(this Control control, Control childControl, 
						Expression<Func<Control, object>> property, TModel model, 
						Expression<Func<TModel, object>> dataMember) {

	Expression propertyBody = property.Body; 
	Expression dataMemberBody = dataMember.Body;

	if (ExpressionType.MemberAccess == propertyBody.NodeType && ExpressionType.MemberAccess == dataMemberBody.NodeType) { 
  		MemberExpression propertyMemberExpression = propertyBody as MemberExpression; 
		MemberExpression dataMemberExpression = dataMemberBody as MemberExpression;

		Binding binding = new Binding(propertyMemberExpression.Member.Name, model, dataMemberExpression.Member.Name); 
		childControl.DataBindings.Add(binding); 
	} 

	if (ExpressionType.MemberAccess == propertyBody.NodeType && ExpressionType.Convert == dataMemberBody.NodeType) {

		MemberExpression propertyMemberExpression = propertyBody as MemberExpression;
		UnaryExpression unaryExpression = dataMemberBody as UnaryExpression;

		MemberExpression dataMemberExpression = unaryExpression.Operand as MemberExpression;

		Binding binding = new Binding(propertyMemberExpression.Member.Name, model, dataMemberExpression.Member.Name);
		childControl.DataBindings.Add(binding);
	}
}

Aufruf innerhalb der Form oder eines UserControls:

this.SetBinding<IPersonViewModel>(nameTextBox, textbox => textbox.Text, _viewModel, model => model.Name);

Tritt beim Konfigurieren eines Labs das in einer Workgroup betrieben wird (keine Domänenintegration der VMs) folgender Fehler auf, dann fehlt ggf. ein Shadow-Account: 

--------------------------------------------------

Environment message: Type=Warning; Message=TF267042: One or more machines are not ready to run tests. For more information, see the individual machine errors.;

Machine messages:

Machine name: Windows 7 x64 en

Machine message: Type=Error; Message=TF267055: The machine is not ready to run tests because of the following error: Unable to connect to the controller on ---. The agent can connect to the controller but the controller cannot connect to the agent because of following reason: The server has rejected the client credentials.
The logon attempt failed.;

--------------------------------------------------

Damit der Testagent mit dem Testcontroller korrekt zusammenarbeitet, müssen beide mit unterschiedlichen Accounts laufen. Der Testcontroller verwendet dabei typischerweise einen Domänen-Account, der Testagent arbeitet mit einem lokalen Account. Die jeweiligen Accounts müssen als Shadow-Accounts (gleicher Name und Kennwort) lokal bzw. in der Domäne angelegt werden, also für den lokalen Account ein Shadow-Account in der Domäne und für den Domänen-Account ein lokaler Shadow-Account.

Beispiel:

Die oben beschriebene Meldung erhält man, wenn auf der Labmaschine kein lokaler Shadow-Account angelegt wurde. Wenn man das nachholt und dann auf “Repaiur testing capabilities” klickt, dann sollte das Problem behoben sein.

Seit der Version 1.6.0.0 bietet BlogEngine.NET, für Themes die es unterstützen, die Möglichkeit Kommentare und Track- oder Pingbacks gesondert anzuzeigen.
Allerdings scheint die Sortierung nach Kommentaren und Trackbacks bei Blogs die BlogEngine.NET schon länger einsetzen, nicht richtig zu funktionieren. Die Track- und Pingbacks werden zwar in einem eigenen Container angezeigt, werden aber auch gleichzeitig in den Kommentaren dargestellt. Bei neueren BlogEngine.NET Blogs, wie etwa bei Dariusz Parys neuem Blog, scheint dieses Problem nicht zu bestehen.
Ob die fehlerhafte Sortierung tatsächlich an den neested Comments liegt, habe ich nicht weiter geprüft. Aber genau hier fand ich den Fehler, der sich mit einem kleinem Kniff beheben lässt.

In der Methode AddNestedComments der Klasse User_controls_CommentView, zu finden im Ordner User controls, wird stur durch die übergebene Kommentarliste iteriert und jeder als sichtbar markierte Kommentar zu den Kommentaren hinzugefügt. Ganz egal ob es sich dabei tatsächlich um einen Kommentar oder einen Track- oder Pingback handelt.
Mit einer einfachen Abfrage, ob der Kommentar nicht doch vielleicht ein Track- oder Pingback sein könnte, lässt sich die unschöne Darstellung beseitigen.
Wie es sich bei ausgeschalteten neested Comments verhält, habe ich nicht geprüft, da ich nur geschachtelte Kommentare verwende.

Wie gesagt, es muss nur eine Überprüfung auf Track- oder Pingback verwendet werden. Das lässt sich mit einem Zweizeiler bewerkstelligen.

private void AddNestedComments(string path, List<Comment> nestedComments, PlaceHolder phComments)
{
    foreach (Comment comment in nestedComments)
    {
        //HACK: Überprüfen ob der Kommentar ein Track- oder Pingback ist.
        if (comment.Email == "pingback" || comment.Email == "trackback")
        {
            continue;
        }

		// hier der restliche Code der Methode

    }
}

Anschließend wird auch bei älteren BlogEngine.NET Blogs, mit aktivierten geschachtelten Kommentaren, die Ausgabe genauso erzeugt wie sie sein sollte.

Das ich den TFS und die Arbeit mit dem TFS bevorzuge ist kein Geheimnis. Der TFS ist ein sehr flexibles All-In-One-Tool, welches eine moderne Softwareentwicklung unterstützt. Die wichtigsten Stichworte sind Source-Code-Verwaltung, Bug- und Feature-Tracking, sowie Continous-Integration mit Team-Build.

Zwei zusätzliche Features, die in der Vergangenheit bei der Arbeit mit dem TFS lieben gelernt habe, sind zum einen Shelve-Sets und die Verknüpfung der Change-Sets (Check-Ins) mit einem Work-Item (Bug oder Feature):

Die Shelve-Sets bieten eine Möglichkeit, Source Code einzuchecken und somit zentral zu sicher, ohne dass der Code im Haupt-Branch und somit im Build berücksichtigt wird. Der Entwickler hat so die Möglichkeit Änderungen zwischen zu speichern.

Mit der Verknüpfung zwischen Work-Items und Change-Sets lässt sich auf die Zeile genau feststellen, welcher Code mit zu welchem Zweck geändert oder erstellt wurde.

Das war der TFS2008. Der TFS2010 bietet eine ganze Reihe weiterer interessanter Features. Angefangen bei der wesentlich verbesserten Unterstützung für Tester, bis hin zur den lang ersehnten hierarchischen Work-Items.

Privat nutze ich allerdings folgende Konstellation um meine Projekte zu entwickeln:

• Visual SVN Server für die Source Code Verwaltung
• Hudson als Build Server
• Tortoise als SVN Client unter Windows
• Visual SVN als Client im Visual Studio

Seit einiger Zeit suche ich eine Möglichkeit, mit der agile Softwareentwicklung durch Software unterstützt, optimal betrieben werden kann. Bei meinem Besuch auf der BASTA! Spring 2010 besuchte ich eine Session zu Agilen Tools. Neben Hudson als Continous Integration Server (den ich sehr empfehlen kann) wurde auch Agilo vorgestellt. Agilo ist ein (in der Grundversion) kostenloses Tool von agile42 (http://www.agile42.com) welches auf Trac basiert, zur Verwaltung von Anforderungen, Backlogs, Teams, mit Integriertem Wiki. Scrum und XP lassen sich damit hervorragend abbilden und managen.

Mit dem TFS lässt sich (mit dem Template „MSF for Agile“) ebenfalls agil arbeiten, allerdings war bisher die Unterstützung für Scrum, durch Anpassung des Templates nicht so umfangreich wie es mit Agilo der Fall ist. Zum Management von agilen Projekten war Handarbeit oder die Verwendung von zusätzlichen Tools erforderlich.

Seit kurzem (22. Juli 2010) gibt es allerdings für den 2010 eine Unterstützung für Scrum, welches die Best Practices der Scrum Community abbildet und die Scrum-Sprache benutzt. Eine kurze Einführung ist auch auf dem Blog von Brian Harry zu finden: http://blogs.msdn.com/b/bharry/archive/2010/06/07/a-scrum-process-template-for-tfs.aspx Zusätzlich zu neuen und geänderten Work-Items können BurnDown und Velocity-Cahrts im zugehörigen Sharepoint visualisiert werden. Das Process Template kann von hier (http://visualstudiogallery.msdn.microsoft.com/en-us/59ac03e3-df99-4776-be39-1917cbfc5d8e) heruntergeladen werden.

Bei der Installation des MSI-Pakets des Templates stößt man auf eine kleine Schwierigkeit, falls man die Readme-Datei nicht gelesen hat: Das Process-Template ist nach der Installation noch nicht im TFS verfügbar und muss dort erst hochgeladen werden. Den Anweisungen der Readme (im Installationsordner) sollte man folgen. Nach dem Upload des Process-Templates kein ein neues Teamprojekt anhand dieses Templates erzeugt werden.

Um alle Team-Member beteiligen zu können, sollte SharePoint angebunden werden. Ich habe nur die Basic Konfiguration (ohne SharePoint) testen können und kann so leider nichts Genaueres zum Portal schreiben.

Eine Übersicht über die neuen Work Item Typen ist hier zu finden: http://msdn.microsoft.com/en-us/library/ff731587.aspx

Ach ja: Den TFS Web Access des vergangenen Versionen habe ich nur einmal sehr flüchtig angeschaut und kann also nicht mehr viel darüber erzählen, aber der Web Access des TFS2010 ist nicht über. Natürlich nicht vergleichbar mit den Oberflächen die Agilo und Hudson mit sich bringen, aber diese Tools sind natürlich komplett webbasiert.

Aber ich möchte den TFS nicht durchweg loben. Der Grund warum ich privat weiter mit den oben genannten Tools weiter fahren möchte ist nicht nur eine Lizenzfrage, sondern auch eine Ressourcenfrage. Der TFS benötigt einen eigenen, separaten Server, da er (je nach Teamgröße) relativ viel Prozessorzeit und Arbeitsspeicher beansprucht. Je nach Teamgröße wird mit Continous Integration sogar empfohlen, Team Build auf einem weiteren separaten Server laufen zu lassen.

Agilo, Hudson und Visual SVN Server benötigen dagegen alle zusammen weniger Ressourcen als der TFS alleine. Allerdings sind alle drei Tools natürlich nicht so stark verbunden, wie alle Komponenten des TFS.

Da ich aber nur einen kleinen, gehosteten Virtuellen Server habe und auf diesem auch noch einige Webs laufen sollten, kann ich mir den TFS produktiv und auf diesem Server leider nicht leisten. Dennoch denke ich, dass ich im Geschäfft eher für den TFS entscheiden werde.

Bei ASP.NET MVC ist es Best Practice wenn man für den Datenbank Zugriff eine Transaction beim Start der Action öffnet und zum Ende wieder schließt.

Ich habe die eine oder andere “Lösung” dazu gesehen, die sich jedoch meist in den Request-LifeCycle der Application einklinken und somit “irgendwie” außerhalb der MVC Konzeptes sind und somit auch beim Zugriff auf andere Seiten oder gar statischen Resourcen auch Connection/Transactionen öffnen. Auch ich nutzte dies … aber nun nicht mehr.

Die beste Lösung (jedenfalls aus meiner Sicht) ist ein eigener IActionInvoker der diese Aufgabe übernimm,. damit ist auch exakt den Gültigkeitsbereich der Transaktion definiert.

public interface IActionInvoker
{
    bool InvokeAction(ControllerContext controllerContext, string actionName);
}

    protected virtual IActionInvoker CreateActionInvoker()
    {
      return new ControllerActionInvoker();
    }

public class TransactionalActionInvoker : IActionInvoker
{
    private readonly IDatabaseTransaction transaction;
    private readonly IActionInvoker baseActionInvoker;

    public TransactionalActionInvoker(IDatabaseTransaction transaction,
                                        IActionInvoker baseActionInvoker)
    {
        this.transaction = transaction;
        this.baseActionInvoker = baseActionInvoker;
    }

    public bool InvokeAction(ControllerContext controllerContext, string actionName)
    {
        bool result;
        try
        {
            transaction.BeginTransaction();
            result = baseActionInvoker.InvokeAction(controllerContext, actionName);
        }
        catch (Exception)
        {
            transaction.ExceptionWhileTransaction();
            throw;
        }
        finally
        {
            transaction.EndTransaction();
        }
        return result;
    }
}

IDatabaseConnection ist ein eigenes Interface, darüber kann man die Transaction öffnen, und wieder schließen sowie mitteilen ob es im Ablauf der Action ein Problem gab.  Da die Implementierung Datenbankabhängig ist gehe ich hier nicht Groß darauf ein, nur der Hinweis das bei EndTransaction() bei einem Problem die Transaction mit einem Rollback() beendet wird sonst mit einem Commit().

public interface IDatabaseTransaction 
{
    void BeginTransaction();
    void EndTransaction();
    void ExceptionWhileTransaction();
}

public abstract class TransactionController : Controller
{
    public IDatabaseTransaction Transaction { get; set; }

    protected override IActionInvoker CreateActionInvoker()
    {
        return new TransactionalActionInvoker(Transaction,base.CreateActionInvoker());
    }

    protected override void OnException(ExceptionContext filterContext)
    {
        base.OnException(filterContext);
        Transaction.ExceptionWhileTransaction();
    }
}

Nicht viel besonderes, es wird eine Instanz vom TransactionActionInvoker erzeugt und ihr die IDatabaseTransaction sowie der ursprüngliche IActionInvoker übergeben.

Wichtig ist es OnException() zu überschreiben um der IDatabaseTransaction mitzuteilen das eine Exception innerhalb der Action aufgetreten ist.

Die IDatabaseTransaction muss natürlich auch irgendwie in den Controller kommen, dies wird in diesem Fall vom IoC-Container gemacht und zwar per Property-Injection. Ich habe hier der Property-Injection gegenüber der Konstruktor Injection den Vorzug gegeben damit ich die die Abhängigkeit nicht bei jedem zu implementierenden Controller “manuell” bedienen muss. Dies kann man jedoch machen wie man möchte, ein Lookup über den Container oder IServiceLocator wäre auch möglich.

Den Lebenszyklus von IDatabaseTransaction habe ich über den IoC-Container auf pro HttpRequest festgelegt. Dies ist erforderlich, auch ist es erforderlich dass die eigenen Datenbank Session/Connection auf pro HttpRequest festgelegt ist. Es muss sichergestellt werden dass alle Datenbank Aufrufe innerhalb der Action mit derselben Connection bzw. Session aufgerufen werden.

Wie? Sie haben von der WP Zone noch nichts gehört?
Ist auch nicht verwunderlich: Die WP Zone ist ja auch erst einen Tag alt, bzw. 2 Tage, wenn man von der Idee aus geht.

Was ist die Idee hinter der WP Zone?
Schaut man sich aktuell in Deutschland zum Thema Windows Phone 7 um, ist der verbreitete Inhalt rar und zerstreut. Hier mal etwas aus Twitter, da mal was im Facebook, dort mal etwas in einem Blog, den man nicht abonniert hat. Und wen spricht man eigentlich an, wenn man eine Frage hat? Oftmals kennt man die Personen vielleicht auch gar nicht.

Die Idee hinter der WP Zone ist schnell beschrieben: Es geht um Zentralisierung. WP Zone, so der Gedanke, soll eine zentrale Anlaufstelle rund um das Thema Windows Phone 7 in Deutschland werden. Das ist eigentlich auch schon die Idee, um nicht in den weiten des Internets suchen zu müssen.

Was bringt mir die WP Zone?
Es gibt aktuell verschiedene Ideen. So sollen nicht nur WP 7 spezifische Blogs von Experten entstehen, sondern auch Tutorials, Hilfestellungen und vieles, vieles mehr. Um das zu erreichen haben sich schon viele bekannte Experten gefunden, die hier mithelfen wollen.
Ganz besonders ist auch die Idee von Coding Dojos hervorzuheben, in welcher es darum gehen soll, eigenständig oder mit Hilfe von Forenmitgliedern zu lösen.
Doch auch hier muss man bedenken: Nicht nur das Bereitstellen von Informationen ist hier gefragt – auch Sie können etwas beitragen, denn eine Community lebt auch nur vom Mitmachen. Dies soll mittels Wiki dann ganz einfach möglich sein. Auch Snippets und eigene Tutorials werden gern gesehen.

Was bietet die WP Zone bereits?
Kurzum: Es gibt bisher ein Forum. Wer mich kennt, kennt auch den Begriff “entwicklerschön”, was bedeutet, dass das Forum aktuell bereits existiert und funktional ist, jedoch optisch noch aufgewertet werden muss. Dies ist aber bereits in Arbeit. Doch genau das ist die Chance: Sagen Sie uns, was Sie sich wünschen. Noch ist alle warm und frisch und wir können flexibel auf viele Wünsche eingehen.

Wo finde ich die WP Zone?
Nichts einfacher als das: http://www.wpzone.de/forum
Unter Twitter findet man die WP Zone uch unter @wpzone_de, sowie unter Facebook, ebenfalls unter der WP Zone.

An dieser Stelle mag ich mich noch bei Karsten Samaschke bedanken, welcher das Thema so schnell aus dem Boden gestampft hat.

Das Microsoft Word nicht zuletzt auch aufgrund der Unterstützung des transienten Schemas recht fehlertolerant ist, ist bekannt. Einen besonders interessanten Effekt, der bei fehlerhafter Dokumentstruktur auftreten kann, habe ich vor Kurzem zu Augen bekommen.

Es begann damit, dass wir ein neues Dokument erzeugt haben. Dabei haben wir den Fehler begangen, dass der Inhalt eines ContentControls auf body Ebene vollständig geleert wurde.

Die Folge war nun, dass nach dem ersten Bearbeiten und Speichern des Dokuments, die Struktur innerhalb des Dokuments verschoben wurde. Der Unterschied kann bereits in der Entwicklungsansicht in Word ausgemacht werden.

Was genau passierte hier aber?

Word korrigierte das Dokument selbstständig, indem der nächst folgende Paragraf in das leere ContentControl verschoben wurde. In diesem Fall handelt es sich dabei um den Paragrafen mit dem Text Textparagraf nach dem leeren ContentControl.

Nach dem Speichern weist das Dokument jetzt folgende Struktur auf.

Fazit

Word ist in der Tat sehr Fehlertolerant, allerdings werden mit dem Speichern automatische Korrekturen vorgenommen, die zum Teil nur schwer erkannt werden können. Diese Korrekturen können aber erhebliche Veränderungen in der Dokumentstruktur nach sich ziehen, die eine automatische Weiterverarbeitung der Dokumente unter Umständen stark beeinträchtigen können.

In diesem Tipp geht es um das richtige Einbinden von lokalisierten Ressource-Dateien beispielsweise aus dem Silverlight Toolkit.

Zusammenfassung

Das Control DataPager zeigt auch unter einem deutschsprachigen Windows den Text "Page ... of ..." anstatt "Seite ... von ..." an, wenn man nicht manuell in der Projektdatei das Element <SupportedCultures> manuell anpasst.

Beschreibung

Bei manchen Controls kann es vorkommen, dass der angezeigte Content sprachabhängig ist. Das Control DataPager beispielsweise zeigt "Page ... of ..." an, selbst wenn Windows und Browser Deutsch sind. Ein kurzer Blick mit dem Debugger auf den aktuellen Thread zeigt, dass sowohl CurrentCulture als auch CurrentUICulture wie erwartet auf "de" stehen. Auch die DataPager Property Language im XAML Code auf "de" zu setzen bringt keine Veränderung - der Text bleibt englisch.

Das Problem kennen viele und im Web finden sich diverse Lösungsversuche: Von DataPager eine eigene Klasse ableiten und dann mittels Control Template eine eigene TextBox anlegen oder auch von der Assembly System.Windows.Controls.Data.dll die Strong Name Signatur entfernen und dann mit einem externen Resource Editor den String "Page" auf "Seite" ändern. Das ist aber alles unnötig, denn Microsoft hat sämtlich Controls für die von Silverlight unterstützten Sprachen lokalisiert. Man muss die Verwendung der für die jeweiligen Sprachen vorhandenen Satellite Assemblies nur aktivieren.

Der richtige Weg ist eher unerwartet: Die Projektdatei ist mit einem XML-Editor zu öffnen und im Element SupportedCultures sind die benötigten Sprachen einzutragen, beispielsweise so:

<SupportedCultures>en;de;fr</SupportedCultures>

Dieser Eintrag führt dazu, das beim Build für alle im Projekt referenzierten Assemblies geprüft wird, ob es dazu zusätzliche deutsche bzw. französische Satellite Assemblies gibt. Alle diese zusätzlichen Assemblies werden mit in die XAP-Datei gepackt. Zur Laufzeit werden sie dann von der Klasse ResourceManager automatisch verwendet, sofern die aktuelle Culture Einstellung des Browsers dazu passt. Im Detail ist das hier beschrieben: How to: Create a Build that Targets a Specific Culture

Wenn man genauer darüber nachdenkt, ist es eigentlich logisch, dass man Visual Studio irgendwie mitteilen muss, für welche Sprachen es die Satellite Assemblies mit den lokalisierten Ressourcen in die XAP-Datei packen soll. Es wäre bei Silverlight ja ziemlich unklug, immer alle Satellite Assemblies für sämtliche vorhandenen Sprachen hinzuzufügen, selbst wenn die Anwendung beispielsweise nur für den deutschsprachigen Raum bestimmt ist. Die XAP-Datei würde unnötig vergrößert.

Dass man allerdings das XML der Projektdatei manuell bearbeiten muss, passt überhaupt nicht zu Visual Studio (und schon gar nicht zu Visual Studio 2010). Ein Eingabefeld unter den Silverlight Projektoptionen wäre sehr hilfreich, da vermutlich kaum jemand erwartet, dass eine so grundsätzliche Information direkt in die Projektdatei eingetragen werden muss.

Das Setzten der Property Language aus der Klasse FrameworkElement hat übrigens in Silverlight (im Gegensatz zu WPF) bei den meisten Controls keine weitere Auswirkung. Insbesondere führt der folgende XAML-Code nicht dazu, dass jetzt etwa französische Ressourcen verwendet werden.

<sdk:DataPager Language="fr" .../>

Möchte man die Sprache für eine Anwendung global umschalten, muss man der Property CurrentUICulture des Main-Threads bei Programmstart eine entsprechende neue CultureInfo zuweisen.

Hier geht's zum nächsten Tipp.

Aktuelle Workshop-Termine für SQL Server 2008 R2 und SharePoint Server 2010 sind exklusiv für Softwareentwickler verfügbar! Wir haben für Sie zwei separate Veranstaltungen zusammengestellt, um zielgerichtet Ihre Bedürfnisse in Ihrer Rolle als technischer Leiter oder als Entwickler abzudecken.

Office und SharePoint 2010 halten, was andere versprechen: Viele neue Funktionalitäten und vor allem eine einfachere Benutzung. Das trifft nicht nur für Anwender zu, sondern vor allem auch für Entwickler. Wir stellen Ihnen die Möglichkeiten von SharePoint 2010 dar und beleuchten Ihre Vorteile als Softwarehersteller bei der Integration von SharePoint 2010.

• Briefing zu neuen Geschäftspotentialen für Entscheider am 06.09.2010 in Bad Homburg (Anmelden)
• Entwickler-Camp für tief technischen Einstieg am 17.09.2010 in Berlin (Details zur Anmeldung)

SQL Server 2008 R2 ist die nächste Version des SQL Servers und stellt die Grundlage für eine Mission Critical Plattform dar. Es werden unter anderem umfangreiche Business Intelligence Erweiterungen vorgestellt. Sind Ihre Applikationen fit für den SQL Server 2008 R2 und bieten Mehrwerte für Sie und Ihre Kunden? Wenn Sie überlegen welche neuen Möglichkeiten interessant für Ihre Produkte sind, dann verschaffen Sie sich einen Überblick über Ihre Vorteile als Softwarehersteller bei der Integration von Microsoft SQL Server R2.

• Briefing zu neuen Geschäftspotentialen für Entscheider am 13.09.2010 in Köln (Anmelden)
• Entwickler-Camp für tief technischen Einstieg am 15.09.2010 in Bad Homburg (Details zur Anmeldung)

Alle Details inkl. der Inhalte der Veranstaltungen und zur Anmeldung finden Sie im Blog Softwarehersteller in Deutschland.

Der richtige Online Content ist für häufig noch immer schwer zu finden. Aus diesem Grund haben Dariusz Parys und Ich das Projekt Reticulum ins Leben gerufen, um Online Content explorativ besser auffindbar zu machen.  Warum eigentlich explorativ?  Suchmaschinen finden doch alles. Im Prinzip Ja, aber nur wenn man die richtigen Suchbegriffe kennt, was wiederum voraussetzt, dass man das Thema schon sehr gut kennt. Unser Ziel ist also klar definiert: Wir wollen zu bestimmten Themen zentrale Einstiegspunkte schaffen, die es ermöglichen, einen einfachen Einstieg zu finden.  Wobei wir den Content Managen, also nicht alles rein packen was es gibt, sondern nur ausgewählten Content. Für den Preview haben wir das Thema Visual Studio 2010 Application Lifecycle Management gewählt, da es Thematisch relativ umfangreich ist.

Für die technische Implementierung haben wir einiges ausprobiert, sind aber letztendlich beim Silverlight Pivot gelandet. Natürlich haben wir noch eine Menge Ideen, wie definierte Content Guides im Mindmap Still in unserem Backlog, wollten aber den aktuellen Stand der Community zeigen, um vor allem Euer Feedback zu bekommen. Lasst uns bitte wissen, was Ihr gut oder schlecht findet oder was Euch fehlt!  

Hier gibt’s ein kurzes Video wie es geht oder direkt weiter zum Visual Studio 2010 ALM Pivot.

Viel Spass

Viele kennen den Begriff Zoom It von dem netten kleinen Presenter-Tool.

Von dem ist hier nicht die Rede, sondern von der Webseite http://zoom.it . Dieses Tool kann ganze Webseiten in ein Deep Zoom umwandeln.

Das Ergebnis ist recht witzig.

Meine Homepage als Zoom.It

Die Kollegen von Bing Maps haben das Kartenmaterial für Bing angepasst. Dieses gibt es jetzt in zwei Darstellungsvarianten: AJAX und Silverlight. Nach dem Prinzip weniger ist mehr und Farben nur fürs wesentliche, wirkt die neue Darstellung sehr aufgeräumt und kühl.

Mehr Informationen dazu im Bing Blog.

Ich berichte noch heute von dem Ereignis der Verwandlung. Es war als Coding-Dojo geplant gewesen. Weiß jeder, was ein Coding-Dojo ist? Zu Beginn gibt es eine Kata, eine kleine Aufgabe, die es zu lösen gilt. Dazu gehören alle Schritte von der Planung und dem Durchdenken der gesamten Aufgabe bis hin zum entwickelten Code. Einige japanische Begriffe kannte ich noch von meinen früheren Judo-Kursen.

Es war nicht das erste mal, dass Ralf und Stefan ein solches Coding-Dojo durchführten. Es war aber das erste mal, dass wir eigentlich gar nicht kodierten, sondern uns viel mehr über die Architektur unterhielten. Abgesehen von einer Person, die total heiß drauf war mal wieder was zu kodieren, waren alle sehr zufrieden mit dem Ergebnis, auch ohne eine Zeile Code geschrieben zu haben. Selbst Ralf und Stefan waren begeistert. Die beiden lernen auch bei jedem Dojo immer wieder etwas Neues.

Bei der Aufgabe ging es darum, spezielle Textdateien einzulesen und zu konvertieren (sie nannten es BankOCR). Mehr verrat ich aber nicht, da ich Ralf und Stefan sowie auch den Teilnehmern den Spaß an der Aufgabe nicht verderben möchte.

Im Endeffekt dauerte unsere Architektur natürlich viel zu lange. 20 Leute brauchten für die Architektur ca. 3 Stunden. Das war aber auch gar nicht schlimm, weil es nicht um die Zeit ging, sondern um die Flut an Erkenntnissen und Sichtweisen der einzelnen Teilnehmer. Es wurde schnell klar, dass eines der Kernprobleme weder die .NET oder C#-Fähigkeiten waren, sondern eher viel mehr die unterschiedlichen Ansatzpunkte und Verständnissschwierigkeiten. Einer sagte, “das könnte man Zahl nennen”, dann sagte der nächste, “ja aber wie nennen wir dann das hier?” Allein die Begrifflichkeiten zu ermitteln dauerte seine Zeit. Es ging dabei aber nicht, wie auch später einstimmig erkannt wurde, um ein stupides Glossar. Es ging um einheitliche Begriffe, die jeder benutzen konnte sowie die Verbindungen zwischen den Begriffen untereinander. Dies bildete eine wunderbare Grundlage für spätere Objekte bzw. Objektbezeichnungen im Code (wenn man denn entwickelt hätte… :-)).

Ralf bemerkte gegen Ende, dass ja theoretisch anhand unserer Begriffsbildung ganz zu Beginn auch der Lösungsansatz sehr nah an diese Begriffe und den Zusammenhängen angelehnt war. Er stellte voller Erstaunen fest, dass, hätte man am Anfang andere Begriffe gewählt und somit auch andere Zusammenhänge, oder vllt. auch deteilliertere Begriffe, so wäre unter Umständen eine gänzlich andere Lösung am Ende entstanden.

Für mich bleibt als Fazit zu sagen. Mir hat es Spaß gemacht alle unterschiedlichen Denkansätze zu hören und nachzuvollziehen. Ich bin fast gar nicht hinterhergekommen mit mitschreiben, somit konnte ich mich selbst leider nicht so sehr beteiligen… Das hat aber auch niemanden gestört.

In ein paar Wochen geht es weiter, hier in Berlin… Man darf gespannt sein.

Aktuelle Workshop-Termine für SQL Server 2008 R2 und SharePoint Server 2010 sind exklusiv für Softwareentwickler verfügbar! Wir haben für Sie zwei separate Veranstaltungen zusammengestellt, um zielgerichtet Ihre Bedürfnisse in Ihrer Rolle als technischer Leiter oder als Entwickler abzudecken.

Office und SharePoint 2010 halten, was andere versprechen: Viele neue Funktionalitäten und vor allem eine einfachere Benutzung. Das trifft nicht nur für Anwender zu, sondern vor allem auch für Entwickler. Wir stellen Ihnen die Möglichkeiten von SharePoint 2010 dar und beleuchten Ihre Vorteile als Softwarehersteller bei der Integration von SharePoint 2010.

• Briefing zu neuen Geschäftspotentialen für Entscheider am 06.09.2010 in Bad Homburg (Anmelden)
• Entwickler-Camp für tief technischen Einstieg am 17.09.2010 in Berlin (* Hinweis zur Anmeldung siehe unten)

SQL Server 2008 R2 ist die nächste Version des SQL Servers und stellt die Grundlage für eine Mission Critical Plattform dar. Es werden unter anderem umfangreiche Business Intelligence Erweiterungen vorgestellt. Sind Ihre Applikationen fit für den SQL Server 2008 R2 und bieten Mehrwerte für Sie und Ihre Kunden? Wenn Sie überlegen welche neuen Möglichkeiten interessant für Ihre Produkte sind, dann verschaffen Sie sich einen Überblick über Ihre Vorteile als Softwarehersteller bei der Integration von Microsoft SQL Server R2.

• Briefing zu neuen Geschäftspotentialen für Entscheider am 13.09.2010 in Köln (Anmelden)
• Entwickler-Camp für tief technischen Einstieg am 15.09.2010 in Bad Homburg (* Hinweis zur Anmeldung siehe unten)

Inhalte der Veranstaltungen

Strategischer Überblick über SQL Server 2008 R2

• SQL Server 2008 R2 – ein Überblick
• Was habe ich als Partner von Microsoft SQL Server?
• Was habe ich als Partner von Microsoft SQL Server 2008 R2?
• Neues Business durch Migration auf den SQL Server 2008 R2
• Worauf sollte ich den Kunden hinweisen?
• Know-How-Bedarf und Deckung beim Partner

Leider mussten wir diese Veranstaltung abgesagen. Schauen Sie nach unseren neuen Terminen auf Microsoft Platform Ready.

Trainingscamp für Entwickler für den SQL Server 2008 R2

• Die Microsoft SQL Server 2008 und 2008 R2 Plattform
  • Von SQL Compact bis SQL Azure
• Spezielle Funktionen von SQL Server 2008 R2
  • Vorteile für Partner
• Ablöseszenarien von anderen Herstellern - Was, warum und wie?
  • Warum migrieren?

Leider mussten wir diese Veranstaltung abgesagen. Schauen Sie nach unseren neuen Terminen auf Microsoft Platform Ready.

Strategischer Überblick über SharePoint 2010

In dieser Veranstaltungen lernen Sie aus strategischer Sicht die Vorteile von SharePoint 2010 kennen. Folgende Themen haben wir für Sie vorbeitet.

• Potenziale für Partner durch SharePoint 2010 und Cloud/BPOS
• Integration von SharePoint in Partnerlösungen (Grundlagen, Vertrieb und Integration mit Visio)
• Integrationsszenarien SharePoint inhouse und BPOS – Vorteile für Kunden
• Technische Abgrenzung: wo macht SharePoint in Partnerlösungen Sinn?
• SharePoint 2010 – eine durchgehende Entwicklerstory für Partner
  • VS 2010, Sandboxed Solutions,  Developer Dashboard, Office Integration/Entwicklung

Datum und Ort: 6. September in Bad Homburg
Anmeldegebühr: keine
Für die Anmeldung zur Veranstaltung klicken Sie bitte hier.

Trainingscamp für Entwickler für SharePoint 2010

Diese Veranstaltung richtet sich an technische Leiter und Entwickler, die sich näher mit den Neuerungen und den Vorteilen von SharePoint 2010 vertraut machen möchten. Für Sie haben wir die folgenden Themen vorbereitet.

• SharePoint 2010 – ein technischer Überblick
• SharePoint 2010 für Entwickler – Neuerungen
• Cloud und BPOS – die neue Plattform für SharePoint Lösungen – ein technischer Blick
• SharePoint 2010 – eine durchgehende Entwicklerstory für Partner
  • VS 2010, Sandboxed Solutions,  Developer Dashboard, Office Integration/Entwicklung, Visio
• 1-2-3: SharePoint beim Partner - ein Fahrplan für den Wissensaufbau

Datum und Ort: 17. September in Berlin
Anmeldegebühr: 59,00 EUR
Für die Anmeldung zur Veranstaltung klicken Sie bitte hier.

[14.09.10] Aktualisiert: SQL Server Workshops

Die vierte an Entwickler gerichtete Vorschauversion zum Internet Explorer 9 (IE9) steht jetzt zum kostenlosen Download zur Verfügung. Mit dieser letzten Preview vor der öffentlichen Beta-Version des Browsers können Entwickler erstmals einen vollständigen Blick auf die neue Plattform werfen, um so ihre Webseiten auf einer verlässlichen Basis zu testen. Zu den Neuerungen gehören schnelleres JavaScript, optimierter Support vielfältiger Standards sowie die daraus resultierende Verbesserung des Acid-3-Ergebnisses, neue Tests für die Arbeitsgruppen des W3C (World Wide Web Consortium) und weitere Beispiele für Entwickler zu den Themen Performance, Grafik und HTML5. Mit den Previews, die bis zum Erscheinen der Beta-Version in einem 8-Wochen-Rhythmus erschienen sind, hat Microsoft der Webentwickler-Community frühzeitig Einblicke in die Evolution seiner interoperablen Webplattform gegeben. Mit schon heute über 2,4 Millionen Downloads war die Resonanz enorm. Nun sind die Weichen für die Beta-Version des IE9 gestellt.

Die ersten Informationen des seit langer Zeit geheim gehaltenen RAD Projektes (vielleicht hat der eine oder andere in diesem Zusammenhang von Kitty Hawk gehört?) sind nun bekannt gegeben worden. Jason Zander hat die Katze aus dem Sack gelassen. Mein Kollege Tom Wendel stellt LightSwitch hier vor.

Was ist LightSwitch? Kein “Access on Steroids”, es hat aber einiges von dessen Idee, nämlich in kurzer Zeit – und ohne Informatik studiert zu haben – eine funktionierende Anwendung auf die Beine zu stellen. Es ist ein Add-On zu Visual Studio. Und, auf Basis von Silverlight, erschlägt es auch die Szenarien “Desktop” (out-of-browser mode) und Internet (im Browser).

Am 23. August wird es die erste Beta geben.

Seit einiger Zeit nervt mich folgendes.

Ich arbeite an verschiedenen Projekten, die meisten nutzen auch Komponenten die nicht von mir stammen. Diese wären z.B. xUnit.net, Rhino.Mocks, Automapper, StructureMap usw. usf.

Des weiteren bin ich ein Freund davon alles was man für das Projekt braucht auch unter der Versionkontrolle zu haben um es nach dem ausschecken

• in Visual Studio öffnen,
• es kompilieren,
• auf dem Build-Server starten,
• Versionspezifische abhängigkeiten habe,
• usw

ohne dass es dabei zu Problemen kommt und man sofort damit arbeiten kann. Und man nicht schauen muss wo nun noch welche Assembly in welcher Version referenziert wird. Wenn mehrere an dem Projekt arbeiten potenzieren sich die Probleme weil jeder seine Assemblies woanders liegen hat. Somit, alles was geht mit in die Versionskontrolle. Dies sollte jeder so handhaben.

Wo liegt denn jetzt das Problem?

Ist doch alles schön und funktioniert. Nunja, fast, solange die externen komponenten nicht angefasst werden, nicht aktualisiert werden müssen sowie es nur ein Projekt ist. Nun sind auch noch eigenen Komponenten dabei, die zum Teil noch Rege in der Entwicklung sind und öfters aktualisiert werden.

Die Projekte aktuell zu halten, die Komponenten an den richtigen Platz kopieren ist eine nervige und auch für Fehler anfällige Arbeit.

Es wäre doch schön wenn man dies schnell, einfach und mehr oder minder automatisiert machen könnte.

Wir haben 2010, da muss es doch was geben?

Habe mich somit auf den Weg gemacht was zu suchen, was vielleicht eine Art Standard in der .NET Welt ist, Auch soll bei Open Source Projekten der Entwickler der mal kurz reinschnuppern will nicht in weitere Abhänigkeiten gedrängt werden, oder andere Teammitglieder müssen es nicht unbedingt verwenden um das Projekt zu bauen oder daran zu entwickeln.

Irgendwie nichts gefunden was meine Erwartungen und Bedürfnisse erfüllte. Als Software-Entwickler habe ich dies auf die lange MMMM-Liste gestellte (müsste man mal machen).

Ruby hat das Problem schon gelöst

Schaut man in die Ruby-Welt so gibt es da schon gar ewig RubyGems. Kleine Komponenten die man sich sehr einfach lokal auf den Rechner kopieren kann und immer aktuell halten kann.

Dies haben sich Dru Seller, Chris Patterson und ein paar andere auch gedacht und entwickelten NU. Ein kleines Tools welches auf RubyGems aufsetzt und somit auf bewährten. Dies um ein paar Features ergänzt die für “uns” wohl interssant sind.

NU betritt die Bühne

NU existierst nun schon eine ganze Weile aber seit 2-3 Wochen beginnt das ganze an Fahrt aufzunehmen, Nach der Installation von Ruby, Gems und Nu (ist total einfach) kann man schon loslegen.

nu install nhibernate

Und kurze später hat man in dem aktuellen Ordner einen LIB Ordner (einstellbar). Indem sich folgendes befindet.

• castle.core
• castle.dynamicproxy2
• log4net
• nhibernate
• nlog

Es wurde NHibernate und dessen Abhängigkeiten installiert. Zuerst in das lokale Gem-Repository und dann in das Projekt. Und von da aus natürlich in die Versionverwaltung.

Auf Tekpub befindet sich ein kostenloses Video dazu, dies zeigt in knapp 3 Minuten was NU ist und kann.

http://tekpub.com/view/dotnet-oss/nu

Eigene Gems zu erstellen ist auch sehr einfach

Dazu einfach ein gemspec erstellen und über gem bauen

version = File.read(File.expand_path("../VERSION",__FILE__)).strip  

Gem::Specification.new do |spec|
  spec.name        = 'fluentmetadata'
  spec.version     = version
  
  spec.has_rdoc = false
  spec.files = Dir["lib/FluentMetadata.*.dll", "lib/Readme.txt"]
  spec.files.reject! { |fn| fn.include? "Specs.dll"  }
  spec.description = 'FluentMetadata is describing Object-Metadata on one place, and using it from ASP.NET MVC 2 & 3, FluentNHibernate and EntityFramework 4 CodeFirst with EF Feature CTP 4'
  spec.summary     = 'FluentMetadata - Metadata on one place for .NET'
  
  spec.author			 = 'Albert Weinert'
  spec.email             = 'info@der-albert.com'
  spec.homepage          = 'http://wiki.github.com/DerAlbertCom/FluentMetadata/'
end

Das bauen eines Gems ist sehr einfach

gem build fluentmetada
gem install fluentmetada

Dies natürlich am besten direkt im Build-Skript machen und man braucht sich nicht mehr zu kümmern.

Und schon hat man das Gem im lokalen Repository und fertig. Mit “nu install” kann man dies nun in andere Projekte übernehmen und aktualisieren (am besten wieder über ein Skript oder Batch). Und braucht sich nicht mehr darum zu kümmen wo der kram nun herkommt.

Aktuell kann man die dann noch per “gem push” auf Rubygems.org pushen und dort sieht es dann so aus.

http://rubygems.org/gems/fluentmetadata

Ein Buildscript (mit psake) welches das Gem immer wieder erzeugt kann so aussehen

http://github.com/DerAlbertCom/FluentMetadata/blob/master/default.ps1

Zukunft

Natürlich bringt so ein System nur was wenn es viele, wenn nicht gar alle verwenden. Dann hat man ein schönes Eco-System und viel weniger Probleme und arbeit. Also nutzt es.

Natürlich ist Rubygems.org auf Dauer keine Lösung für uns, und ein eigener Platz für .net gems wäre fein, da wird schon dran gearbeitet und wird nicht mehr so lange auf sich warten lassen.

Aktuell findet man unter http://nu.wikispot.org/ alle wichtigen Informationen und Links.

NU selbst ist weiterhin in Entwicklung in der Mailingliste diskutiert man gerade um es um weitere .net Specifika zu erweitern, mir reicht erstmal die jetzige Funktionalität es fehlen nur weitere Gems für .NET. Also macht mit.

In der aktuellen Ausgabe vom dot.net magazin gibt es eine neue Folge von meiner Silverlight-Kolumne “Silverlight-Expertise”:  

Die Serie „Silverlight Expertise“ des dot.NET Magazins präsentiert monatlich zwei leckere Top-How-Tos zum Thema Silverlight von Gregor Biswanger (www.dotnet-blog.net), sodass Einsteiger und fortgeschrittene Silverlight-Experten durch geballtes Wissen gesättigt werden. Heute stehen auf der Menükarte „Text Trimming“ und „Bing Maps für Silverlight“. Viel Spaß und einen guten Appetit.

Zu lesen sind die How-To´s beim dot.net magazin, Ausgabe 09/2010.

Zu Kostüm- und Spaßzwecken habe ich mich letzte Woche daran gemacht, ein selbstleuchtendes Arc-Reactor-Prop (bekannt aus dem Film IronMan) zu basteln.

Hier die einzelnen Schritte:

1. Schnittmuster erstellen

Zuerst benötigte ich Schnittmuster für die drei Schichten á 3 mm Sperrholz. Das ging am besten in Corel-Draw und sieht dann so aus:

Wer sich ein eigenes Arc-Reactor Prop basteln möchte, kann hier die CDR-Datei auf eigene Gefahr und ohne jedwelche Gewährleistung herunterladen: ArcReactor.cdr (41,26 kb)

2. Schnittmuster ausschneiden

Das geht mit der Laubsäge, dem Teppichmesser oder - wie hier - mit einem Lasercutter:

 Die fertig ausgeschnittenden Scheiben inkl. der nicht benötigten Füllungen:

LEDs verlöten

Als Leuchtmittel verwende ich Hochleistungs SMD Leuchtdioden.

Um nicht zu viele Kabel im späteren Gehäuse zu haben und gleichzeitig etwas Wärme von den LEDs abführen zu können, ist es praktisch zwei Kuperringe anzulöten:

Das gleiche noch einmal für den inneren Ring - dort aber mit blauen statt weissen LEDs.

Ganz in der Mitte befindet sich dann schließlich noch eine weisse und zwei blaue LEDs.

Fertig zusammen bauen

Hier dann auch der gleich der erste Test:

Selbst unter einem T-Shirt ist die Leuchtkraft der SMD LEDs noch ernorm:

Ein erster "Selbstversuch" bei etwas dunklerem Licht in der Werkstatt...

...und einmal in vollem Tageslicht. Hat alles gut geklappt und scheint praxistauglich.

Mal sehen, ob die LEDs bei längerem Betrieb nicht doch zu warm werden. Dann müsste in einer zweiten Version wahrscheinlich doch mehr Kühlung als die vier Kupferringe eingebaut werden.

This post is powered by www.Giza-Blog.de |
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

dotnet-kicks.de erfreut sich in deutschen .NET Welt ja doch einiger Beliebtheit, also bietet es sich an dies auch im eigenen Blog zu unterstützen. Ich habe nun ein Control gebaut mit dem es ganz einfach geht.

Als erstes erstellt man in dem Controls-Ordner seines Skins die Datei KickIt.ascx, und füllt diese mit folgendem Inhalt.

<%@ Control Language="C#" ClassName="KickItDeControl"  
    Inherits="Subtext.Web.UI.Controls.CurrentEntryControl"%>
<% 
	string urlUrl = UrlEncode(Entry.FullyQualifiedUrl );
	string urlTitle = UrlEncode(HttpUtility.HtmlDecode(Entry.Title));
%>
<a href="http://dotnet-kicks.de/kick/?url=<%=urlUrl%>&amp;title=<%=urlTitle%>">
<img src="http://dotnet-kicks.de/Services/Images/KickItImageGenerator.ashx?url=<%=urlUrl%>" 
     border="0" alt="kick it on dotnet-kicks.de" /></a>

<%@ Register TagPrefix="awn" TagName="KickItDe" Src="KickItDe.ascx" %>

<!-- und nun an die Stelle wo es angezeigt werden soll -->

<awn:KickItDe runat="server"/>

Von nun wird auf jeder geänderten Seite der dotnet-Kicks.de Button angezeigt.

Nutzt man SubText für das eigenen Blog und möchte man Flattr damit verwenden, so kann man dies auf verschiedenen Weise machen. Hier nun wie ich es gemacht habe.

Als erstes erstellt man in dem Controls-Ordner seines Skins die Datei Flattr.ascx, und füllt diese mit folgendem Inhalt

<%@ Control Language="C#" ClassName="FlattrControl" 
    Inherits="Subtext.Web.UI.Controls.CurrentEntryControl"%>
<script runat="server">
	public string FlattrId {get;set;}	
</script>
<%
	string htmlTitle = HttpUtility.HtmlDecode(Entry.Title).Replace("'","\"");
%>
<script type="text/javascript">
var flattr_btn = 'compact';
var flattr_uid = '<%=FlattrId%>';
var flattr_tle = '<%=htmlTitle%>';
var flattr_dsc = '<%=htmlTitle%>';
var flattr_cat = 'text';
var flattr_lng = 'de_DE';
var flattr_url = '<%=Entry.FullyQualifiedUrl%>';
</script>
<script src="http://api.flattr.com/button/load.js" type="text/javascript"></script>

Dies ist ein einfaches Control welches den Flattr-Code erzeugt. Nun muss man das Control noch dort eintragen wo man es Anzeigen lassen (üblicherweise Day.ascx und ViewPost.ascx). Zuerst muss das UserControll wie in ASP.NET WebForms üblich registriert werden, dann kann es verwendet werden.

<%@ Register TagPrefix="awn" TagName="Flattr" Src="Flattr.ascx" %>

<!-- und dann dort wie man es anzeigen lassen will, als FlattrID muss man die 
 eigene Nummer eintragen -->

<awn:Flattr FlattrId="YourID" runat="server"/>

Von nun wird auf jeder geänderten Seite ein Flattr-Button erstellt.

When you’re using a WebBrowser control in your WPF application, you may have noticed that you can’t bind the control’s content. WebBrowser has no property to set its content but a method named NavigateToString. So when you’re following a strict MVVM approach you’re lost because you don’t want any code-behind for your views.

But then there are attached properties. As their name implies they allow you to attach new properties to existing dependency objects. In your XAML code you apply such a attached property to your element and can access it as any other property of the object.

Ok, first here’s the code of an attached property to set a WebBrowser’s content:

public class WebBrowserHelper {
    public static readonly DependencyProperty BodyProperty =
        DependencyProperty.RegisterAttached("Body", typeof (string), typeof(WebBrowserHelper), new PropertyMetadata(OnBodyChanged));

    public static string GetBody(DependencyObject dependencyObject) {
        return (string) dependencyObject.GetValue(BodyProperty);
    }

    public static void SetBody(DependencyObject dependencyObject, string body) {
        dependencyObject.SetValue(BodyProperty, body);
    }

    private static void OnBodyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
        var webBrowser = (WebBrowser) d;
        webBrowser.NavigateToString((string)e.NewValue);
    }
}

The static BodyProperty defines the type of the attached property: its name is Body, the type is string, and whenever it is changed the method OnBodyChanged should be called.

The accessors for a attached property must be conventionally named SetXxx and GetXxx. They are called whenever you set or get the property’s value.

Last but not least OnBodyChanged is called when the value of the property has changed. The first parameter is the object the property is attached to, so we can cast it to WebBrowser and call its NavigateToString method.

The actual usage of the new Body property is pretty simple:

<WebBrowser
    src:WebBrowserHelper.Body="{Binding MyHtml}"
    />

given that the ViewModel has a property named MyHtml providing the desired content for the control.

A complete sample application is available on GitHub.