.
Anmeldung | Registrieren | Hilfe

.NET-Blogs Archiv Juni 2010

Deutsche Texte in Infragistics NetAdvantage 10.2

30.06.2010 23:53:59 | Andre Kraemer

Wie Craig Shoemaker bereits in seinem Blog geschrieben hat, werden die Infragistics NetAdvantage Controls für Silverlight und WPF ab der Version 10.2 auch mit Deutschen Oberflächentexten ausgeliefert. In diesem Beitrag möchte ich die Notwendigen Schritte noch einmal im Schnelldurchlauf in deutscher Sprache am Beispiel von Silverlight erläutern.

Initiales Setup

Mein Silverlightprojekt besteht aus einer einzigen Seite, in der ein XamGrid definiert wurde:

<UserControl x:Class="NAGermanLocalization1.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400" xmlns:ig="http://schemas.infragistics.com/xaml">

    <Grid x:Name="LayoutRoot" Background="White">
        <ig:XamGrid HorizontalAlignment="Left" Name="xamGrid1" VerticalAlignment="Top"  AutoGenerateColumns="false"  >
            <ig:XamGrid.FilteringSettings>
                <ig:FilteringSettings AllowFiltering="FilterMenu" />
            </ig:XamGrid.FilteringSettings>
            <ig:XamGrid.GroupBySettings>
                <ig:GroupBySettings AllowGroupByArea="Top" />
            </ig:XamGrid.GroupBySettings>
            <ig:XamGrid.Columns>
                <ig:TextColumn Key="Id" />
                <ig:TextColumn Key="Name"/>
                <ig:TextColumn Key="Vorname"/>
                <ig:TextColumn Key="Land" />
            </ig:XamGrid.Columns>
        </ig:XamGrid>
    </Grid>
</UserControl>

Für das Grid habe ich wie der vorherige Codeausschnitt zeigt Filtern und Gruppieren aktiviert.

Meine Codebehind Datei sieht ähnlich schmal aus:

using System.Collections.Generic;
using System.Windows.Controls;

namespace NAGermanLocalization1
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
            InitGrid();
        }

        private void InitGrid()
        {
 	        List<Kunde> kunden = new List<Kunde>();
            for (int i = 0; i<10; i++)
            {
                Kunde kunde = new Kunde{Id = i, Name = string.Format("Name {0}", i), Vorname = string.Format("Vorname {0}", i), Land = "DE"};
                kunden.Add(kunde);
            }
            xamGrid1.ItemsSource = kunden;
        }
    }

    public class Kunde
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Vorname { get; set; }
        public string Land { get; set; }
    }
}

An der Oberfläche schaut das ganze nun wie folgt aus:

GridVorher

DialogVorher

Und einmal auf Deutsch bitte ...

Um das ganze nun zu lokalisieren, sind lediglich zwei Schritte erforderlich.

Zunächst muss das Silverlight Projekt entladen und anschließend im Textmodus editiert werden:

unloadproject editproject

Der vorhandene leere Tag SupportedCultures muss mit dem Wert de versehen werden.

supportedcultures

Anschließend muss die Projektdatei gespeichert und erneut geladen werden. Als letzter Schritt muss dann innerhalb der Webseite, die das Silverlight Control hostet noch die Zeile <param name="uiculture" value="de" /> innerhalb des Object Tags eingefügt werden:

uiculture

Wenn nun nichts schief gegangen ist, sollten die Oberflächentexte nun auf Deutsch erscheinen:

GridNachher

DialogNachher

Fazit

Lokalisierte Oberflächen werden mit Infragistics NetAdvantage 10.2 zum Kinderspiel, da das umständliche Setzen der Oberflächentexte über die runtime resource-string customization in Zukunft entfällt.



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

Interactive STERN.DE Image Gallery

30.06.2010 20:27:22 | Damir Tomicic

Eine neue interaktive Gallerie mit wirklich aussergewöhnlichen Bildern [1] ging gerade online bei STERN.DE.

Die Gallerie basiert auf der neusten Microsoft Silverlight 4 Technologie und wurde mit Hilfe des SilverHD-Frameworks [2] von Axinom erstellt. Nun auch im Metro-Design mit Deep Zoom Framework verfügbar :-)

[1] http://www.stern.de/gallery/
[2] http://silverhd.net

Die Neuigkeiten von VSTO 2010 vorgestellt

30.06.2010 16:01:38 | Jens Häupel

Gerade ist ein Online-Artikel von mir erschienen, indem die Möglichkeiten von Visual Studio 2010 angerissen werden, Office-Lösungen zu erstellen. Der Artikel soll einen Überblick über die Neuigkeiten von VS2010 in Bezug auf Office 2010 bieten und beschäftigt sich nicht mit solch “alten” Technologien wie Task Panes oder Custom Forms Regions (die es natürlich immer noch gibt). Er ist als Ergänzung zu den bekannten Technologien zu sehen.

Weitere Informationen gibt es dann in der Ausgabe 09 des dotNet Magazins (ab 4. August am Kiosk), u.a. auch ein Artikel zum Security und Deployment Modell von VSTO 2010.

Open XML Package Editor für VS2010

30.06.2010 15:50:06 | Jens Häupel

Für Visual Studio 2008 gab es die ein Plug-In, welches das Öffnen und Bearbeiten von Open XML Dateien erlaubte. Enthalten war es in der VSTO Power Tools. Leider arbeitete das nicht mit VS2010 zusammen. Jetzt gibt es dafür Abhilfe. Der Open XML Package Editor Power Tool for Visual Studio 2010 bringt die Funktionalität zurück in Visual Studio 2010 und kann aus der Visual Studio Gallery geladen werden.

Damit können Open XML- und XPS-Dateien geöffnet und die einzelnen Parts eingesehen, entfernt und geändert sowie neue Parts hinzugefügt werden.

Besonders hilfreich ist, dass das Tool erkennt, wenn die geöffnete Datei extern verändert wurde und das Laden der Änderungen anbietet, ohne die datei vorher schließen zu müssen.

OXPE1

Ein Doppelklick auf einen Part führt zum Öffnen desselben in Visual Studio’s XML Editor:

OXPE2

Outlook Ribbon XML – 150 Zeilen Code eingespart

30.06.2010 13:54:00 | Jens Häupel

Ich hatte mir vor einigen Jahren ein AddIn für Outlook 2003 gebastelt, welches mir ausgewählte Kontakte verarbeitet und Adressaufkleber druckt. Über die Jahre hinweg habe ich es nach Office 2007, von VB.NET nach C# und von VSTO 2005 SE nach VSTO 3.0 portiert. Nun bringt Outlook 2010 das Ribbon UI für den Explorer. Mein Add-In lief immer noch, jetzt im Add-Ins Tab integriert, sah aber natürlich unschön aus.

Also habe ich mich heute an die Arbeit gemacht, eine korrekte Integration in das Ribbon-Modell von Office 2010 zu bauen.

Das RibbonX für die Gruppe war schnell gebaut:

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

<ribbon>
  <tabs>
    <tab idMso="TabContacts">
      <group id="groupCM" label="Contact Manager"
             insertAfterMso="GroupViewGallery">
        <button id="btnCreateLabels" label="Create Labels"…
                onAction="onCreateLabels"/>
        <button id="btnSendMails" label="Send Email" …
                onAction="onSendMail"/>
        <button id="btnCheckAddresses" label="Validate Address" …
                onAction="onCheckAddress"/>
      </group>
    </tab>
  </tabs>
</ribbon>

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

Dank Integration in den TabContacts fiel gleich die Prüfung weg, ob sich der Benutzer in den Kontakten aufhält und natürlich auch der (reichlich unlesbarer) Code zum Erzeugen der Menüeinträge:

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

Office.CommandBar menuBar = olEx.CommandBars["Menu Bar"];
ContactManager =
   (Office.CommandBarPopup)menuBar.Controls.Add
      (Office.MsoControlType.msoControlPopup, 1,
       null, menuBar.Controls.Count, true);
ContactManager.Caption = "Contact Manager";
ContactManager.Visible = false;

mnuLabelMaker =
   (Office.CommandBarButton)ContactManager.Controls.Add
      (Office.MsoControlType.msoControlButton, 1,
       null, 1, true);
mnuLabelMaker.Caption = "Create Labels";
mnuLabelMaker.Tag = "_Labels";
mnuLabelMaker.Click +=
   new Microsoft.Office.Core.
     _CommandBarButtonEvents_ClickEventHandler(LabelClickHandler);
mnuLabelMaker.Visible = true;

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

Adé, lieber Code, wir brauchen Dich nicht mehr.

Allerdings versuchte Outlook nun auch, denselben Ribbon-Eintrag beim Öffnen eines einzelnen Kontakts anzuzeigen, was natürlich fehl schlug:

image

Ja, da war doch noch etwas: An der Stelle, wo das Ribbon XML geladen wird, kann man einschränken (IRibbonExtensibility Members):

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

public string GetCustomUI(string ribbonID)
{
  if (ribbonID == "Microsoft.Outlook.Explorer")
    return GetResourceText("ContactManager.MainRibbon.xml");
  else
    return string.Empty;

}

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

Wo bekommt man nun die ribbonID her?

Der Ribbon Designer hat eine Property RibbonType, wo man alle Typen aufgelistet bekommt:

RibbonTypes

Die Ribbon Callbacks sind wieder einfach:

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

public void onCreateLabels(Office.IRibbonControl control)
{
     Globals.ThisAddIn.CreateLabelsFromRibbon();
}

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

Jetzt noch schnell die Kontextmenüeinträge bauen und fertig ist der Laden. … Ganz so schnell ging es dann doch nicht. Welches Kontextmenü ist das richtige und wie heißt es?

Die Namen und IDs der Menüs und Befehle sind hier zu finden (mehrere einzelne Excel-Files). Die Datei für den Outlook Explorer öffnen und die Spalte Tab nach “None (Context Menu)” fiiltern. Danach kann man in der Spalte daneben die Namen der Kontextmenüs finden (Duplikate entfernen):

ContextMenuAttachments ContextMenuNoteSystemMenu
ContextMenuCalendarItem ContextMenuQuickFlags
ContextMenuCalendarView ContextMenuRemoteDocument
ContextMenuCalendarViewFreeBusyBar ContextMenuSearchRoot
ContextMenuCalendarViewTimeBar ContextMenuShortcut
ContextMenuCardView ContextMenuStore
ContextMenuCategories ContextMenuTableArrangeBy
ContextMenuContactItem ContextMenuTableView
ContextMenuContactsMoreActions ContextMenuTableViewColumn
ContextMenuFlaggedContactItem ContextMenuTaskItem
ContextMenuFlaggedMailItem ContextMenuTimelineView
ContextMenuFolder Group/Context Menu Name
ContextMenuGroupHeader MenuCalendarNewItem
ContextMenuIconView MenuContactsNewItem
ContextMenuJournalItem MenuJournalNewItem
ContextMenuMailItem MenuMailNewItem
ContextMenuMailMoreActions MenuNotesNewItem
ContextMenuMultipleItems MenuTasksNewItem
ContextMenuNoteItem

 

Das Kontextmenü für einen einzelnen Kontakt war schnell gefunden: ContextMenuContactItem. Allerdings stellte sich heraus, dass bei mehreren ausgewählten Kontakten wieder ein anderes angezeigt wurde. Mit ein bisschen Suchen kam ich auf ContextMenuMultipleItems. (Die Doku dazu könnte ein wenig hilfreicher sein) Das RibbonX dafür sieht dann so aus:

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

<contextMenus>
  <contextMenu idMso="ContextMenuContactItem"> 
    <button id="ctxCreateLabels" label="Create Labels" …
            onAction="onCreateLabels" insertAfterMso="Copy"/>
  </contextMenu>
  <contextMenu idMso="ContextMenuMultipleItems">
    <button id="ctxCreateLabelsMI" label="Create Labels" … 
            onAction="onCreateLabels" insertAfterMso="Copy"/>
  </contextMenu>
</contextMenus>

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

Die Vorgängerversion bediente sich noch des Outlook-Objektmodells und sah (auszugsweise) so aus:

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

olEx.Application.ItemContextMenuDisplay +=
   new Microsoft.Office.Interop.Outlook
       .ApplicationEvents_11_ItemContextMenuDisplayEventHandler
       (Application_ItemContextMenuDisplay);

void Application_ItemContextMenuDisplay(
           Microsoft.Office.Core.CommandBar CommandBar,
           Microsoft.Office.Interop.Outlook.Selection Selection)

{
   if (ContactView)
  {
    mnuCtxLabelMaker =
       CommandBar.Controls.Add(
          Office.MsoControlType.msoControlButton, 
          missing,
          missing,
          missing,
          true) as Office.CommandBarButton;
    mnuCtxLabelMaker.BeginGroup = true;
    mnuCtxLabelMaker.Caption = "Create Labels";
   
mnuCtxLabelMaker.Tag = "Create_Labels";
    mnuCtxLabelMaker.FaceId = 65;

    mnuCtxLabelMaker.Click += new Microsoft.Office.Core.
      _CommandBarButtonEvents_ClickEventHandler(LabelClickHandler);
    mnuCtxLabelMaker.Visible = true; 
    …
  }
  …
}

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

Nicht sonderlich schön. Besonders, wenn man das schon etwas kryptische Event-Prinzip von Outlook betrachtet. Da faßt sich doch Ribbon XML viel besser an.

 

Das Endergebnis ist nun folgendes:

 

1. Ribbon-Integration im Outlook Explorer:

image

2. Ribbon-Integration in das Kontextmenü für einen einzelnen Kontakt:

Snip2

2. Ribbon-Integration in das Kontextmenü für mehrere ausgewählte Kontakte:

Snip1

Alles in allem habe ich etwa 150 Zeilen alten Code eingespart, wofür ich vielleicht ein Fünftel davon in neuen Code (RibbonX und Callbacks) investiert habe.

 

siehe auch: Show and Hide Context Menu Items in Outlook 2010

3. Internet Explorer 9 Platform Preview (IE9 PP) verfuegbar

30.06.2010 13:18:55 | Kay Giza

Gerichtet an Web-Entwickler, stellt Microsoft auf den IE Test Drive-Seiten die nunmehr 3. Vorschauversion zum kommenden Internet Explorer 9 (IE9) vor – die Sie parallel zu einer bestehenden Internet Explorer Version installieren können. Mit den Preview-Versionen, die bis zum Erscheinen einer öffentlichen Beta-Version etwa im 8-Wochen-Rhythmus erscheinen, verschafft Microsoft Entwicklern den Einblick in den Fortschritt der Browsertechnologie, von Verbesserungen an Markup über Leistungsverbesserungen und Nutzung von Hardwarebeschleunigung bis zu neuen Beispielen für Entwickler. Die Neuerungen der aktuellen Preview umfassen neben der Abarbeitung Ihres Feedbacks über die Connect-Seiten konkret die Verfügbarkeit der HTML5-Tags audio, video und canvas, schnelleres JavaScript, Standardverbesserungen (inkl. ES5 und WOFF) und verbessertes Acid 3-Ergebnis, neue W3C-Tests sowie 15 neue Beispiele für Entwickler zu den Themen Performance, Grafik und HTML5. Weitere Informationen finden Sie auch im MSDN Internet Explorer Developer Center oder im Internet Explorer 9 Testing Center. Internet Explorer 9 (IE9) Platform Preview 3 vermittelt einen weiteren Ausblick auf die kommende Browser-Generation von Microsoft. Internet Explorer 9 (IE9) bietet der Webentwickler-Community eine Plattform und die passenden Werkzeuge und Features zur Entwicklung von interoperablen und den Standards entsprechenden, modernen Webanwendungen. Microsoft stellt die Internet Explorer 9 (IE9) Platform Previews bereit, um wie versprochen mehr Transparenz zu schaffen und einen frühzeitigen und regelmäßigen Einblick in Internet Explorer 9 (IE9) zu gewährleisten. Durch die aktuelle und die kommenden Platform Preview-Veröffentlichungen möchte Microsoft das Engagement für Standards und das Verständnis für die jeweiligen Einsatzszenarien sowie... [... mehr]

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

Git mit farbiger Darstellung in der PowerShell und beim Command Prompt

30.06.2010 11:00:10 | Albert Weinert

Git unterstützt die farbige Ausgabe seiner Meldungen, dies macht es um einiges einfacher über die Shell zu bedienen. In der Standard-Konfiguration macht Git dies automatisch bei allen Ausgabegeräten die sich als Terminal ausgeben. So steht’s in der Dokumentation.

Leider machen dies wohl weder die PowerShell noch der Command Prompt von Windows. Möchte man trotzdem Farben in der Ausgabe haben, so muss man Git überreden dies zu machen. Am einfachsten geht in dem man die Shell seines Vertrauens öffnet und folgendes eingibt.

 git config --global color.ui always

Damit wird in der globalen .gitconfig die Farbausgabe in allen Bereichen bei denen Git dies unterstützt aktiviert.

Möchte man dies ein wenig granularer haben, so kann man dies auch für einzelne Teile aktivieren oder deaktivieren.

Details dazu stehen in der Dokumentation.

http://www.kernel.org/pub/software/scm/git/docs/v1.7.1/git-config.html

Sucht dort einfach nach color.branch, ab da findet Ihr die möglichen Variationen.

 

Technorati Tags: ,,,,

Introducing IIS Express

29.06.2010 17:36:00 | Damir Tomicic

In vielen Firmen, bspw. bei den Entwicklungsteams in einer Bank ist aus diversen Gründen die Installation eines lokalen Web Servers auf der Entwicklungsmaschine nicht möglich, auch wenn die Web-Entwickler dies für die eigene tägliche Entwicklung benötigen. Die Applikationen werden zum Test in eine abgeschlossene Test-Umgebung deployed und ausgeführt, getestet und freigegeben.

Die Kluft zwischen dem großen Internet Information Server (IIS) auf einer und dem kleinen Visual Studio Web Serverchen auf der anderen Seite war bisher recht groß, allein aufgrund der Funktionalität des späteren produktiven Web Servers... es fehlte etwas dazwischen, eine Mischung, eine Brücke, die die beiden Welten besser verbindet.

Scott Guthrie hat in seinem Blog [1] gerade die Verfügbarkeit des neuen Produkts "IIS Express" bekannt gegeben, eines Produkts der die oben erwähnte Lücke besser füllen sollte. Wie bei Scott üblich ist die gesamte Applikation im Detail in einem langen Post beschrieben.

Prädikat: Lesenswert!

[1] http://weblogs.asp.net/scottgu/archive/2010/06/28/introducing-iis-express.aspx

Visual Studio 2010 und Team Foundation Server 2010 RTM Virtual Machine Image verfügbar

29.06.2010 15:39:17 | Thomas Schissler

Endlich ist es soweit und Microsoft stellt ein VM Image für Visual Studio 2010 und TFS 2010 in der RTM Version bereit. Auf diesem Image sind nicht nur die Produkte sowie einige weitere benötigten Tools installiert, sondern es befinden sich darauf auch Demo-Daten (Tailspin Toys) und 9 Hands-On-Labs. Die VM ist für Hyper-V, Virtual PC 2007 SP1 verfügbar. Die Trial-Versionen auf der VM laufen bis zum 15. Dezember 2010.

Weitere Infos und Hinweise zum Download finden sich hier: http://blogs.msdn.com/b/briankel/archive/2010/06/25/now-available-visual-studio-2010-rtm-virtual-machine-with-sample-data-and-hands-on-labs.aspx

Notepad–Wetten, dass das noch keiner wusste :)

29.06.2010 10:54:11 | Oliver Scheer

Bin gerade auf einen sehr witzigen Trick in NOTEPAD gestossen.

Ich bin mir sicher, das wußte fast niemand Winking smile

1. Man lege eine neue Notepad-Datei an und nennt diese beliebig.

2. Man tippe ".LOG” in die erste Zeile und schließt die Datei wieder

3. Man öffnet die Datei wieder und hat direkt Datum und Uhrzeit in einer Zeile, und kann quasi damit sein “Logbuch” führen.

Das Verhalten ist immer das Gleiche, wenn man die Datei öffnet wird eine neue Zeile eingetragen mit Uhrzeit/Datum eingetragen.

Witzig Smile

image

Visual Studio 2010–Versteckte Perlen, der Extension Manager

29.06.2010 10:26:07 | Oliver Scheer

Bin gerade mal wieder über den Extension Manager von Visual Studio 2010 gestolpert. Dieser erlaubt es Visual Studio 2010 auf sehr umfangreiche Weise zu erweitern. Mich interessieren natürlich die Silverlight-Features. Und siehe da … in der Online Gallerie sind sehr viele Controls und Add-ons verfügbar.

image

Einfach ausprobieren. Zu finden ist der Extension Manager unter Tools –> Extension Manager.

Die spinn bei Philips…

28.06.2010 08:27:24 | Nico Franze

Heute mal etwas technischer und fern von .NET. Ich habe mir vor ca. einem Jahr kabellose Kopfhörer von Philips gekauft. In den Kopfhörern selbst sind Philips-Akkus, und wenn man die Kopfhörer in so eine Ladestation stellt, dann laden sie sich wieder auf. Ok, soviel zur Vorgeschichte.

Vor einer Woche stellte ich fest, dass die Kopfhörer außerhalb der Ladestation nur noch ca. 10 Minuten funktionierten. Die Akkus sind also im Eimer. Nun gut. Nach einem Jahr nich so doll, aber meinetwegen.

image

So sehen die Originalen Akkus aus. In bzw. auf dem Gerät steht, man soll natürlich nur Philips-Akkus kaufen.Ich bin losgerannt zum nächsten Rewe und habe mir irgendwelche NoName-Akkus gekauft.  Hab sie eingesteckt und dann ging der Kopfhörer zwar kurzzeitig an, aber die Statuslampe blinkte und der Kopfhörer war nach ca. 5 Sekunden wieder aus. Ok, ich hab die Daten der Akkus verglichen und gemerkt, dass die Akkus von Rewe 100 mA/h weniger haben. Ja, also eigentlich ist das ja kein Problem, aber nun gut dachte ich, wer weiss was die da wieder verbaut haben in China und habe also nun Originale Akkus bestellt bei Amazon.

So sehen dann die neuen Akkus aus:

image

So, nun dachte ich, ich kann endlich mal wieder loslegen und Musik hören. Aber nein. Auch mit diesen Akkus blinkte die Statuslampe kurz und nach 5 Sekunden waren die Kopfhörer wieder aus. So, spätestens jetzt hatte ich die … voll und wollte der Sache auf den Grund gehen. Ich wurde auch sehr schnell fündig. Wenn man sich oben nochmal die originalen Akkus ansieht, so sieht man am Minus-Pol, dass die Folie, die normaler Weise den gesamten Batteriekörper überzieht, relativ weit oben aufhört und der untere Teil also die blanke metallische Aussenhülle des Akkus ist. Nun werfen wir mal kurz einen Blick in die Kopfhörer selbst.

image

Man sieht an den Einsteckbuchsen für die Akkus, dass nicht nur ein Kontakt für den Minuspol vorhanden ist, wie man es kennt, sondern gleich zwei (siehe rote Ellipsen). Diese Affen von Philips haben also mit Absicht diesen Quatsch da eingebaut, damit man immer nur ihre dummen Akkus nimmt, die natürlich nach spätestens einem Jahr im Eimer sind. Und selbst, nachdem ich laut Bezeichnung die originalen Akkus bestellt habe, funktioniert es nicht, weil diese Deppen bei Philips wohl ihre Super-Kontakte da vergessen haben und dass normale Akkus nicht gehen. Man bedenke, seit dem Tag wo ich keine Musik mehr länger als ne viertel Stunde hören konnte bis jetzt sind schon fast eine ganze Woche vergangen… Super.

So. Ich habe mir nun einen der Akkus genommen und einfach unten die Folie etwas abgepopelt. Generell besteht bei Batterien und Akkus die gesamte Außenseite aus dem Minus-Pol. Die Folie umhüllt den Metallkörper und kann relativ leicht abgezogen werden. Das sieht dann so aus:

image

Wenn man dieses Akku nun wieder einsteckt, mit der freigelegten metallischen Seite, so dass die beiden Kontakte das Metall berühren, oh wunder, geht es wieder. Diese Aktion kostete mich einmal umsonst dumme Akkus von Philips und n Haufen Wartezeit. Es hätte alles soo einfach sein können, aber nein.. Warum auch?

Solltet ihr auch zufällig diese Kopfhörer Philips SHD9100 gekauft haben, dann kauft keine Akkus von Philips. Das nützt eh nichts. Popelt schnell das bisschen Folie ab von irgendwelchen anderen Akkus und schon hat Philips kein Geld mit den Akkus verdient… Jeah!

Man kann hier sicherlich auch irgendwas mit .NET machen, aber ich wollte einfach nur Musik hören…

Nochmal ein Bild aller Komponenten als Zusammenfassung

image

XSD.exe /c - Klassengenerierung richtig gemacht

26.06.2010 15:07:00 | Timo Rehl

Einleitung:
XSD.exe hat so seine Tücken, ich glaube das zeigt auch der große Unmut, der im Internet zu finden ist. Dabei muss das doch nicht sein Big Smile

Ich habe festgestellt, dass wenn man XSD verwenden möchte, dass es sinnvoll ist den Berg zum Propheten zu tragen. Im Folgenden erkläre ich, was das Problem eigentlich so dabei ist, und wie man das geschickt umschiffen kann.

Problembeschreibung:
XSD generiert lediglich aus den Teilen Klassen und Felder, von denen es denkt, dass diese zu gebrauchen sind. Dabei beachtet es nur die Elemente in den Schemas, Complex- und SimpleTypes für sich betrachtet lässt es außen vor.

Beispiel:
<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein SimpleElement, das ebenfalls in der Klassengeneration beachtet werden soll -->
  <xs:simpleType name="SimpleRootElement">
    <xs:restriction base="xs:string">
      <xs:enumeration value="TestVal1" />
      <xs:enumeration value="TestVal2" />
    </xs:restriction>
  </xs:simpleType>

</xs:schema>

Hier meldet XSD die Fehlermeldung
Warning: cannot generate classes because no top-level elements with complex type were found.

Genauso sieht es aus, wenn das Schema so aussehen würde:
<?xml version="1.0" encoding="utf-8"?>
<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />

</xs:schema>


Und wiederum folgendes Schema, das ebenfalls die o.g. Fehlermeldung provoziert:
<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />
  
  <!-- Ein ComplexType, aus dem eine Klasse generiert werden soll -->
  <xs:complexType name="ComplexTypeWhichIsReferenced">
    <xs:sequence>
      <xs:element name="CommonInnerElement1" type="xs:string" />
    </xs:sequence>
  </xs:complexType>

</xs:schema>


Was will das "doofe" XSD denn überhaupt, warum erzeugt es mir aus dem Schema keine Klassen?

Problemerklärung:
XSD will zwingend ein ElementType, das im Root des Xml-Baumes des Schemas liegt. Weiterhin will es zwingend mindestens einen ComplexType definiert wissen, welches von solch einem Root-Element referenziert wird. Also folgendes Schema ist als Basis für XSD ausreichend, so dass es mit einer Klassengenerierung beginnt:

<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es allerdings ein Top level element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced2' veweist-->
  <xs:element name="TestElement2" type="ComplexTypeWhichIsReferenced2" />
  <xs:complexType name="ComplexTypeWhichIsReferenced2">
    <xs:sequence>
      <xs:element name="CommonInnerElement2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>

</xs:schema>


Ergebnis (Kommentare und Attribute entfernt):
public partial class ComplexTypeWhichIsReferenced2 {
    
    private string commonInnerElement2Field;
    
    /// <remarks/>
    public string CommonInnerElement2 {
        get {
            return this.commonInnerElement2Field;
        }
        set {
            this.commonInnerElement2Field = value;
        }
    }
}


Na das ist doch soweit super, oder? Jetzt hat XSD endlich ein Ergebnis produziert, das auch einem prüfenden Blick Stand hält.
Aber...

Erweiterte Problembeschreibung:
Wenn jetzt Kombinationen aus den oben genannten Schemas und deren Fehlermeldungen mit dem funktionierenden Beispiel zusammenspielen, dann wird es gefährlich. Denn dann wird XSD keine Fehlermeldung ausspucken und aber nur einen Teil für die Klassengenerierung heranziehen. Das ist denke ich das größte Manko, das diesem Tool angelastet wird. So denkt der Benutzer, dass das Tool eine gewisse undurchschaubare Eigenintelligenz verwendet.

Ich habe hier einmal ein kleines Schema entwickelt, das sehr viele Probleme auf einmal betrachtet:
<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  
  <!-- Ein SimpleElement, das ebenfalls in der Klassengeneration beachtet werden soll -->
  <xs:simpleType name="SimpleRootElement">
    <xs:restriction base="xs:string">
      <xs:enumeration value="TestVal1" />
      <xs:enumeration value="TestVal2" />
    </xs:restriction>
  </xs:simpleType>
  
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />
  
  <!-- Ein ComplexType, aus dem eine Klasse generiert werden soll -->
  <xs:complexType name="ComplexTypeWhichIsReferenced">
    <xs:sequence>
      <xs:element name="CommonInnerElement1" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es allerdings ein Top level element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced2' veweist-->
  <xs:element name="TestElement2" type="ComplexTypeWhichIsReferenced2" />
  <xs:complexType name="ComplexTypeWhichIsReferenced2">
    <xs:sequence>
      <xs:element name="CommonInnerElement2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es ein inneres Element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced' veweist-->
  <xs:complexType name="TestInnerLink">
    <xs:sequence>
      <xs:element name="ComplexInnerElement" type="ComplexTypeWhichIsReferenced" />
    </xs:sequence>
  </xs:complexType>
</xs:schema>


Wenn man das so mittels XSD durch den Klassengenerator jagt, dann entsteht folgender C# Code:
public partial class ComplexTypeWhichIsReferenced2 {
    
    private string commonInnerElement2Field;
    
    /// <remarks/>
    public string CommonInnerElement2 {
        get {
            return this.commonInnerElement2Field;
        }
        set {
            this.commonInnerElement2Field = value;
        }
    }
}


Was unschwer zu erkennen ist: Das ist genau das Gleiche, wie in dem oben genannten funktionierenden Minischema. Also hier hat XSD alles andere als das TestElement2 ignoriert!

Lösung:
Die Lösung ist aus der oben erwähnten Fehlermeldung heraus begründet. XSD betrachtet nur den Inhalt zur Klassengenerierung, welcher als Root-Element auf andere Complex-Typen verweist.
Das könnte man nun manuell machen, oder es automatisiert anwenden. Ich habe hier ein kleines Tool geschrieben, das die notwendigen Elemente einfach dem Schema hinzufügt. Die Logik im Schema ändert sich quasi nicht, aber XSD ist glücklich und das Ergebnis sieht sehr viel besser aus.
Das Tool macht von der Logik her folgendes (Codeausschnitt):
        /// <summary>
        /// Methode, die ein XML Schema erweitert, so dass keine ClassType ohne Element existieren,
        /// das darauf verweist.
        /// </summary>
        /// <remarks>Verhindert die Warnung:
        /// cannot generate classes because no top-level elements with complex type were found.</remarks>
        /// <param name="xsdFullFilename">Der voll qualifizierte Dateiname zur XSD Schemadatei.</param>
        /// <param name="throwError">Definiert, ob im Fehlerfall eine Exception geworfen werden soll.</param>
        /// <returns>True, wenn die Erweiterung der Schemadatei erfolgreich war, andernfalls False.</returns>
        public static bool GenerateDummyElementsForClassTypes(string xsdFullFilename, bool throwError)
        {
            XmlDocument schemaDoc = null;
            bool retVal = false;
            List<string> rootElements = new List<string>();
            Dictionary<string, string> rootElementsToAddToSchema = new Dictionary<string, string>();

            try
            {
                // Überprüfung, ob Schemadatei vorhanden
                if (!System.IO.File.Exists(xsdFullFilename))
                {
                    throw new System.IO.FileNotFoundException(String.Format("Konnte die Datei '{0}' nicht finden!", xsdFullFilename));
                }

                // Versuch das Schema in ein XmlDokument zu laden
                schemaDoc = new XmlDocument();
                schemaDoc.Load(xsdFullFilename);

                // Alle Root-Elements herausfinden
                ExtractAllElements(schemaDoc, rootElements);

                // Alle Root-ComplexTypes herausfinden
                ExtractAllClassTypes(schemaDoc, rootElements, rootElementsToAddToSchema);

                // Alle vorgemerkten Root-Elements dem Schema hinzufügen
                AddNecessaryRootElementsToSchemafile(xsdFullFilename, schemaDoc, rootElementsToAddToSchema);

                retVal = true;
            }
            catch
            {
                // wenn gewünscht, dann Fehler schmeißen, ansonsten nur den
                // Rückgabewert auf "False" setzen.
                if (throwError)
                {
                    throw;
                }
                retVal = false;
            }

            return retVal;
        }

Es gibt einen vollständigen Download des VisualStudio 2010 Projektes hier: XsdPrepare.zip

Durch Anwendung der Methode GenerateDummyElementsForClassTypes entsteht aus dem kompletten Schema oben folgendes:
<xs:schema targetNamespace="http://MyTestSchemas/XMLSchema.xsd" elementFormDefault="qualified" xmlns="http://MyTestSchemas/XMLSchema.xsd" xmlns:mstns="http://tempuri.org/XMLSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <!-- Ein SimpleElement, das ebenfalls in der Klassengeneration beachtet werden soll -->
  <xs:simpleType name="SimpleRootElement">
    <xs:restriction base="xs:string">
      <xs:enumeration value="TestVal1" />
      <xs:enumeration value="TestVal2" />
    </xs:restriction>
  </xs:simpleType>
  <!-- Ein normales Element, das kein ComplexType verwendet -->
  <xs:element name="CommonRootElement" type="xs:string" />
  <!-- Ein ComplexType, aus dem eine Klasse generiert werden soll -->
  <xs:complexType name="ComplexTypeWhichIsReferenced">
    <xs:sequence>
      <xs:element name="CommonInnerElement1" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es allerdings ein Top level element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced2' veweist-->
  <xs:element name="TestElement2" type="ComplexTypeWhichIsReferenced2" />
  <xs:complexType name="ComplexTypeWhichIsReferenced2">
    <xs:sequence>
      <xs:element name="CommonInnerElement2" type="xs:string" />
    </xs:sequence>
  </xs:complexType>
  <!-- Ein weiterer ComplexType, aus dem eine Klasse generiert werden soll 
       Hier gibt es ein inneres Element, das auf den komplexen Typ 'ComplexTypeWhichIsReferenced' veweist-->
  <xs:complexType name="TestInnerLink">
    <xs:sequence>
      <xs:element name="ComplexInnerElement" type="ComplexTypeWhichIsReferenced" />
    </xs:sequence>
  </xs:complexType>
  <xs:element name="RootElement0" type="SimpleRootElement" />
  <xs:element name="RootElement1" type="TestInnerLink" />
</xs:schema>


Und wenn man dann XSD nochmal drüberlaufen lässt, dann entsteht folgender Code:
public partial class ComplexTypeWhichIsReferenced2 {
    
    private string commonInnerElement2Field;
    
    /// <remarks/>
    public string CommonInnerElement2 {
        get {
            return this.commonInnerElement2Field;
        }
        set {
            this.commonInnerElement2Field = value;
        }
    }
}

public partial class ComplexTypeWhichIsReferenced {
    
    private string commonInnerElement1Field;
    
    /// <remarks/>
    public string CommonInnerElement1 {
        get {
            return this.commonInnerElement1Field;
        }
        set {
            this.commonInnerElement1Field = value;
        }
    }
}

public enum SimpleRootElement {
    
    /// <remarks/>
    TestVal1,
    
    /// <remarks/>
    TestVal2,
}

public partial class TestInnerLink {
    
    private ComplexTypeWhichIsReferenced complexInnerElementField;
    
    /// <remarks/>
    public ComplexTypeWhichIsReferenced ComplexInnerElement {
        get {
            return this.complexInnerElementField;
        }
        set {
            this.complexInnerElementField = value;
        }
    }
}


Wenn man jetzt ein letztes Mal genau drauf schaut, dann hat XSD den Fall CommonRootElement nicht betrachtet, aber hier muss man zu dessen Schutz sagen, hier wüsste ich auch nicht, wie man hieraus eine Klasse basteln soll.

Aber mit meinem kleinen Helfertool gehen nun (hoffentlich) keine Inhalte mehr durch die Klassengenerierung verloren, und so kann man das auch in automatisierten Prozessen dann einsetzen.

Ich hoffe, dass die nähere Betrachtung hilfreich war, und dass ihr etwas mit dem Tool anfangen könnt. Über Kommentare und Verbesserungsvorschläge würde ich mich freuen.

Es gibt einen vollständigen Download des VisualStudio 2010 Projektes hier: XsdPrepare.zip

Work Item Type aus bestehendem Projekt löschen

26.06.2010 13:11:34 | Thomas Schissler

Im Team Foundation Server lassen sich die Work Items sehr einfach anpassen, neue Work Item Types lassen sich erzeugen und damit ein individuelles Process Template erzeugen. Das ganze geht sehr einfach und intuitive wenn mann den Process Template Editor aus den Team Foundation Server Power Tools verwendet (http://visualstudiogallery.msdn.microsoft.com/en-us/3e8c9b68-6e39-4577-b9b7-78489b5cb1da)

Wer mal auf den Geschmack gekommen ist, das Process Template im TFS anzupassen, wird durch ausprobieren und rumspielen schnell vor der Frage stehen, wie kann ich nun in einem bestehenden Projekt einen Work Item Type wieder löschen den ich nicht mehr brauche?

Hier hilft das Kommandozeilentool witadmin weiter das sich dirckt über die Visual Studio Eingabeaufforderung ausführen lässt.

witadmin destroywitd /collection:http://<Servername>:8080/tfs/<Team Project Collection> /p:<Team Projekt Name> /n:<Name des Work Item Types>

löscht den angegebenen Work Item Type.

Vorsicht,
mit diesem Kommando werden aber auch alle Work Items gelöscht, die diesen Typ verwenden, diese können ja vom System nach löschen der WITD nicht mehr verwaltet werden.

Wenn man also den WIT bestehender Work Items verändern möchte, dann sollte man diesen umbenennen und anschließend so anpassen dass er den neuen Anforderungen entspricht. Zum Umbenennen eines WIT hilft ebenfalls witadmin

witadmin renamewitd /collection:http://<Servername>:8080/tfs/<Team Project Collection> /p:<Team Projekt Name> /n:<Alter Name des Work Item Types> /new:<Neuer Name des Work Item Types>

New Book on .NET CF 3.5 Development (Reviewed)

25.06.2010 11:30:12 | Peter Nowak

.NET_CF_3.5

Recently I’ve been asked to do a review of a new published book on Data-Driven .NET Compact Framework 3.5 development.

It is called “.NET Compact Fraework 3.5 Data Driven Applications” by Edmund Tan, which has been released in April 2010.

The book is a pretty good book for developers, who want to start developing .NET Compact Framework Applications with the most recent version. It doesn't refer to Windows Phone 7 development, which is good, as for business applications the .NET Compact Framework 3.5 technology will be still valid for a longer period of time.

The book itself is structured in 13 chapters, and contains a complete lifecycle of 3 applications from design down to deployment.
Therefore it uses a pretty good story around the applications, which are developed here by sample. It gives an insight in thick, thin and smart clients, as well as in architecture with the MVC Pattern.
Working with databases (Oracle and SQL CE) is as well described as the creation and usage of WebServices. Even the topics 'Auto Update' and working with Bluetooth (among other interfaces) are described as well. Not to forget the usage of Sync Services, the book describes the topics Authentication and Encryption as well.
Chapter 7 is all about Best Practices for mobile applications. These topics for beginners are very useful. Unfortunatelly the book has some drawbacks.

Visual Studio 2008 for example is described as a requirement. Unfortunatelly the author doesn't describe, why Visual Studio 2010 can't be used in this scenario. (Visual Studio 2010 doesn’t support any Windows Mobile development. It is meant to be used for Windows Phone 7 development and later)
As well it isn't obvious to the reader, why 2 different database engines get used (Oracle and SQL CE). On the other hand these databse engines are valuable information to the reader, as he get's described how to work with those different platforms.
The described Dashboard application uses a pull mechanism, where it is requesting new data every minute. This isn't a good practice, as in this sample it isn't necessary as well as it is draining the battery. In general battery usage isn't mentioned at all.
The Bluetooth sample just uses a Bluetooth SerialPort. This means, that the user has to manage Bluetooth connectivity by himself. This isn't a real life scenario. By the usage of the 32feet Library, this would have had additional value to the reader and the user.
The described Pluginsystem lacks of security. Showing the basic steps is absolutly legal, but unfortunatelly not a real world scenario.
Datasets as the BusinessObject intermediate isn't a good choice in this book, as the memory usage is increased.
A side not of using Reflection that it is affecting the applications performance an memory isn't mentioned as well.
Creating a full search scenario is good. Unfortunatelly the coding here creates a security hole for SQLInjection, which isn't mentioned anywhere.
Using regular expressions for the search scenario is great, but the author doesn't tell the reader anything about Regular Expressions at all.
While the complete book uses C# code, it isn't obvious, while Chapter 4 suddenly introduces a VB.NET sample.
The salesforce sample describes the usage of Bluetooth and IrDA as interfaces for exchanging data. This would make it necessary, to have both sales persons to be at the same spot. This isn't a real life scenario as well.

All in all the book is a good entry point for .NET Compact Framework development, but lacks in the depth of the provided information and background. Nevertheless, as it lacks in a few mentioned details, this book shall be worth a read for beginners, as the story around the applications gives a good template on how to start with the overall application lifecycle.

If you are interested, you can check out the details (including a free chapter download) here.



This posting is provided "AS IS" with no warranties, and confers no rights.

MCTS passed

24.06.2010 20:52:00 | Lars Schmitt




Ja ich weiß, ich habe lange nichts geschrieben, jedoch war und bin ich aktuell Beruflich stark eingespannt.

aber ich möchte trotzdem kurz über etwas Berichten.

Am 30.04.2010 habe ich mich, an dem beta Zertifikat 71-511 versucht, und heute erhielt ich dann endlich die ersehnte Mail.

Congratulations on earning your .NET Framework 4, Windows Applications certification! 
We hope you enjoy the benefits of your certification and of membership in the
Microsoft Certified Professional community.

Ich wünsche allen die sich an diesem Zertifikat versuchen möchten viel Glück.





bonn-to-code.net – Blend für Nichtdesigner

24.06.2010 15:12:00 | Stefan Lange

Zu meinem Vortrag „Blend für Nichtdesigner“ am 22.06.2010 bei der .NET User Group für Bonn und Umgebung finden sich hier die Materialien.

In diesem Vortrag ging es um den Nutzen von Blend 4 speziell für den Software-Entwickler. Anhand vieler Beispiele wurde gezeigt, dass Blend keineswegs nur ein Werkzeug für Grafiker ist, sondern auch für Entwickler praktisch gleichberechtigt neben Visual Studio 2010 stehen sollte.

Da der überwiegende Teil des Vortrags mit Blend durchgeführt wurde, sind die Slides eigentlich wenig hilfreich, aber auf mehrfachen Wunsch stehen sie hier dennoch zum Download bereit.

Die am Ende gezeigte Anwendung von der Mix 2010 kann mir hier downloaden: Dynamic Layout and Transitions in Blend 4

Materialien zu diesem Vortrag:

Dritte Internet Explorer 9 Platform Preview verfügbar

24.06.2010 14:42:27 | Peter Kirchner

Gerichtet an Web-Entwickler, stellt Microsoft auf den IE Test Drive-Seiten die nunmehr 3. Vorschauversion zum kommenden Internet Explorer 9 (IE9) vor – die sie parallel zu einer bestehenden Internet Explorer Version installieren können. Mit den Preview-Versionen, die bis zum Erscheinen einer öffentlichen Beta-Version etwa im 8-Wochen-Rhythmus erscheinen, verschafft Microsoft Entwicklern den Einblick in den Fortschritt der Browsertechnologie, von Verbesserungen an Markup über Leistungsverbesserungen und Nutzung von Hardwarebeschleunigung bis zu neuen Beispielen für Entwickler.
Die Neuerungen der aktuellen Preview umfassen neben der Abarbeitung Ihres Feedbacks über die Connect-Seiten konkret die Verfügbarkeit der HTML5-Tags audio, video und canvas, schnelleres JavaScript, Standardverbesserungen (inkl. ES5 und WOFF) und verbessertes Acid 3-Ergebnis, neue W3C-Tests sowie 15 neue Beispiele für Entwickler zu den Themen Performance, Grafik und HTML5. Weitere Informationen finden Sie auch im MSDN Internet Explorer Developer Center oder im Internet Explorer 9 Testing Center.

Anonymen Zugriff für VisualSVN Server konfigurieren

24.06.2010 11:50:00 | Peter Bucher

Schon seit längerem betreibe ich einen SVN-Server mithilfe der kostenlosen Software VisualSVN Server.
Leider kann standardmässig kein anonymer Zugriff (Ohne Logindaten) genutzt werden, es braucht mindestens einen Namen bspw. "guest" oder "anonymous".

Mit folgender Anleitung von Rick Strahl ist es einfach möglich, nach einer kleiner Änderung in der Konfiguration dem Spezialbenutzer "Everyone" Rechte zu geben. Das gilt dann für Clients, die keine Logindaten angeben.

Internet Explorer 9 Platform Preview 3 erschienen

24.06.2010 11:02:20 | Oliver Scheer

Gestern hat Microsoft die dritte Platform Preview für den Internet Explorer 9 veröffentlicht. Damit wird das Versprechen eingehalten, alle acht Wochen eine aktualisierte Version der nächsten Internet Explorer 9 Version bereitzustellen.

Unter www.ietestdrive.com kann sie heruntergeladen werden. Aber auch andere Browser können diese Seite verwenden um die Tests, durch die der Internet Explorer 9 gehen muss, ebenfalls auszuführen.

Diese Version beinhaltet jetzt Unterstützung der HTML5-Elemente <audio>, <video> und <canvas>, das Web Open Font Format (WOFF) und viele weitere verbesserten Features

<canvas>

Um das <canvas>-Element hat sich in den vergangen Wochen hartnäckig das Gerücht gehalten, Microsoft würde dies nicht unterstützen. Microsoft hat dies immer dementiert und zeigt jetzt im aktuellen Preview die Integration in die Preview. Dazu werden einige sehr beeindruckende Beispiele bereitgestellt.

Amazon Shelf

Ein Klassiker des Webs ist das sogenannte Pageflip-Control, das im Internet Explorer 9 Platform Preview basierend auf HTML5 und dem Canvas-Element implementiert wurde. Dabei werden Daten von Amazon herangezogen und im Buchstil präsentiert.

clip_image002

FishIE Tank

Die FishIE Tank-Demonstration zeigt, dass durch die Zuhilfenahme der GPU auch bei sehr komplexen Grafiken eine sehr gute Bildwiederholungsrate (Frames per second) erzielt werden kann. Ein normaler Computerbildschirm verwendet eine Rate von 60 FPS. Dadurch wird ein flimmerfreies Bild gewährleistet.

clip_image004

Mr. Potato Guy

Bei Mr. Potato Guy handelt es sich um ein kleines Shooter-Spiel, das zeigt wie leicht es ist mittels HTMl5 und dem Canvas-Element erstellt werden kann.

clip_image006

Asteroid Belt

Bei Asteroid Belt werden sehr komplexe Grafikanimationen dargestellt. Dabei fliegen kleine Asteroiden um größer. Sehr beeindruckend ist dabei, dass die FPS-Rate sich zu keinem Zeitpunkt verändert und konstant bei 60 FPS bleibt.

clip_image008

windows.msPerformance

Weitere sehr detaillierte Performancetests werden mit „windows.msPerformance“ demonstriert.

Microsoft arbeitet sehr intensiv mit dem W3C zusammen um interoperable browserübergreifende Performancemetriken zu erstellen die einen Vergleich über die echte Ladezeit von Webseiten zu ermöglichen. Diese Informationen sind über die Document Object Model (DOM) API abrufbar und können nach dem Laden der Seite analysiert werden.

clip_image010

DOM Traversal

Abfragen von Elementen innerhalb des DOM ist ein technisch aufwendiger Prozess und auch ein Performanz Indikator. Dieses Beispiel zeigt sehr interessante Bild-, Video- und Audio-Daten der NASA und beschreibt daran die Methoden zum Filtern von Inhalten auf einer Webseite.

clip_image012

Video Performance

Durch die konsequente Verwendung der GPU innerhalb des Browsers lassen sich Videos (auch HD) ohne starken Einfluss auf die Gesamtleistung des Computers darstellen. Demonstriert wird dies mit Kino-Trailern von IMDB.com und dem <video>-Tag.

clip_image014

clip_image016

JavaScript/ECMAScript5-Performance

Die JavaScript-Unterstützung im IE9 ist so ausgelegt, dass sie die aktuellste Version von JavaScript ECMAScript 5 verwendet. ECMAScript 5 bringt neun neue Methoden für das Suchen und manipulieren von Array-Inhalten mit. Diese Methoden mussten bisher durch komplizierte, selbstzuschreibende Schleifen erstellt.

Insgesamt hat sich die Geschwindigkeit der JavaScript-Engine weiter verbessert und liegt bereits vor den aktuellen Firefox-Varianten.

clip_image018

WebFonts

Typografie von Webseiten ist gerade für Webdesigner ein wichtiger Faktor. Die Einbindung weiterer Schriftarten in eigene Webseiten wird in CSS3 durch die @fon-face Regel ermöglicht. IE9 unterstützt jetzt sogenannte WOFF- Fonts (Web Open Font Format).

Mehr Informationen zu WOFF (http://www.w3.org/Submission/2010/03/)

clip_image020

Acid3

Bei Acid3 handelt es sich um eine Testseite des Web Standards Project, das überprüft wie gut Browser sich an bestimmte Elemente des Webstandards halten. Fokus hierbei liegt auf dem Document Object Model und JavaScript.

clip_image021

CSS3 – Selectors Test

Ein weiteres Testverfahren sind die CSS3 Selectors Tests. Diese besteht der IE9 inzwischen zu 100% nach aktuellem Stand.

clip_image023

Deep Zoom

Eine sehr populäre Technik im Internet ist die Deep Zoom Technologie. Deep Zoom ermöglicht es sehr große hochauflösende Bilder in einer sehr schnellen Performance darzustellen. Dabei wird ein üblicher Trick verwendet, der aus einem großen Bild verschiedene Qualitäts- und Größen-Kacheln erzeugt. Diese Technik sorgt dafür, dass nur wirklich das geladen und angezeigt wird, was auch gerade auf dem Bildschirm angezeigt werden kann und soll. Unnötige Daten werden nicht übertragen.

Der Deep Zoom Test zeigt eine Implementierung mittels AJAX.

clip_image025

Kein vollständiger Browser

Die Internet Explorer 9 Platform Preview 3 ist kein vollständiger Webbrowser. Diese Version ist lediglich dazu gedacht, Webentwicklern einen frühen Blick auf die Web Platform Technologien zu geben die im nächsten Release enthalten sein werden. Es ist noch keine offizielle Beta-Version, die allen Kundenqualitätsansprüchen gerecht wird. Eine Beta-Version wird es erst geben, wenn ein sehr hoher Qualitätslevel erreicht wurde.

Für die Verwendung der Platform wird Windows Vista oder Windows 7 benötigt.

Weitere Informationen gibt es unter den FAQs (http://ie.microsoft.com/testdrive/info/FrequentlyAskedQuestions/Default.html)

Umfangreiche Informationen für Entwickler zum Thema bietet Microsoft im MSDN Internet Explorer Developer Center unter http://msdn-online.de/ie.
Die Release Notes zum Internet Explorer 9 (IE9) Platform Preview 3 befinden sich unter http://ie.microsoft.com/testdrive/info/releasenotes/
Weitere Informationen gibt es im Internet Explorer Blog unter: http://blogs.msdn.com/b/ie/

Drinking Game “Mexican” with Windows Mobile

22.06.2010 13:32:11 | Peter Nowak

You know these fridays: Bored on friday nights and you come on the great idea to play a drrinking game with some friends, like probably “Mexican” (find a description for the game here).

You have all the beverage in place, but it tends to happen, that you don’t have any dices around. Good when you have your Windows Mobile with you:

LieberLieber released virtual dices for this game for free over here.

image_thumb19[1]

Go and grab it.

P.S.: No warranties are given about headaches next morning. ;-)



This posting is provided "AS IS" with no warranties, and confers no rights.

TT.DOM in der aktuellen dotnetpro, Teil 4

22.06.2010 12:55:00 | Jörg Neumann

In der aktuellen Ausgabe der dotnetpro (7/2010) ist der vierte und letzte Teil meiner Artikelserie über die Entwicklung von Datenklassen erschienen. Hierin geht es um den Einsatz von TT.DOM in verteilten Anwendungen.
Aus dem Abstract:
In verteilten Anwendungen überschreiten Objekte die Prozessgrenze. Dies stellt den Entwickler vor einige Herausforderungen. Dabei spielen nicht nur Themen wie Serialisierung, sondern auch Änderungsverfolgung, Synchronisation und Konkurrenzbehandlung eine Rolle. Darüber hinaus sind Zugriffsrechte sowie kommunikationsspezifische Eigenheiten nicht zu unterschätzen.
dnp_072010

Mehrsprachige Websites in SharePoint 2010

22.06.2010 10:44:00 | Martin Hey

Mehrsprachige Benutzeroberflächen (sog. MUIs) werden in SharePoint 2010 out-of-the-box unterstützt. Voraussetzung dafür ist, dass das passende Language Pack installiert ist. Ist die Einstellung in einer Site aktiviert, können Anwender über eine Sprachauswahl die Sprache umschalten. Im Gegensatz zu vorherigen SharePoint-Versionen können nun zusätzlich zu den systemeigenen Beschriftungen beispielsweise auch Spaltenüberschriften in Listen in anderen Sprachen dargestellt werden.

Aktivierung über die Benutzeroberfläche
Unter Site Administration -> Language Settings finden sich die Spracheinstellungen der Site.

Die Standardsprache ist nicht änderbar. Dabei handelt es sich um die Sprache, mit der die Site angelegt wurde. Es kann jedoch festgelegt werden, welche Sprachen die Site zusätzlich unterstützen soll.

Auswirkungen
Standard-Templates von SharePoint (wie z.B. die Teamsite) unterstützen dank der Language Packs direkt die gewählten Sprachen. Kehrt man nach der Änderung der Einstellung in die Site Administration zurück und hat wie ich zwar eine englische Site, aber einen Browser mit deutscher Sprachauswahl, so wird die Site Administration direkt in deutsch angezeigt und auch die Listen, Dokument-Bibliotheken und Spaltenüberschriften erscheinen auf deutsch.


Bei näherer Betrachtung fällt auf, dass es nun im Menü einen neuen Menüpunkt gibt, über den die Anzeigesprache geändert werden kann. Wer sich bereits mit Variations beschäftigt hat, dem sollte dieses Verhalten bekannt vorkommen. Bereits in Microsoft Office SharePoint Server 2007 gab es den Variation Label Picker, der ähnlich funktioniert hat.

Als kleines Beispiel soll eine Liste dienen, die kleinere Projekte verwalten soll – so zum Beispiel den Hausbau von Familie Smith und den Bau einer Hundehütte bei Familie Doe. Da als Standard "English" definiert ist, lege ich auch die neuen Spalten in englisch an. Etwas unschön für die nicht-englischsprachige Anwender ist nun, dass selbst definierte Listenspalten und auch der Listentitel im Menü auch in englisch erscheint. Das lässt sich aber ganz einfach ändern. Dazu navigiert man in die Listeneinstellungen bzw. Spalteneinstellungen, wenn die entsprechende Sprache ausgewählt ist und überschreibt die Werte. Der Effekt ist, dass deutsche Benutzer nun eine fast perfekt übersetzte Seite sehen.


Die Listeninhalte sind natürlich weiterhin in der Sprache, in der sie angelegt wurden und sie sind auch nur in einer Instanz vorhanden – Änderungen wirken sich daher direkt auf andere Sprachen aus.

Aktivierung über die PowerShell
Die Einstellung gilt nur für die entsprechende Site. Besonders bei vielen Subsites ist es daher sinnvoll, eine skriptgesteuerte Variante für die Aktivierung von Mehrsprachigkeit zu haben. Die Einstellungen finden sich im Objekt vom Typ SPWeb. Das folgende Skript ermittelt das Rootweb der angegebenen Site-Collection und fügt die Sprache Deutsch zu den unterstützten Sprachen hinzu – also genau das was auch in der Beschreibung oben über die Benutzeroberfläche gemacht wurde.
Start-SPAssignment -Global

# add german language to alternate languages
$site = Get-SPSite "http://myServer/sites/mhytest"
$web = $site.RootWeb
$web.IsMultilingual = $True
$web.AddSupportedUICulture([System.Globalization.CultureInfo]::GetCultureInfo(1031))
$web.Update()

Stop-SPAssignment -Global;

Fotos fürs Leben mit AxCMS.net

22.06.2010 09:41:55 | Damir Tomicic

Eine neue und richtig ansprechende Umsetzung eines internationalen Online-Portals: Ifolor AG [1] hat sich für den internationalen Relaunch in 6 Ländern für AxCMS.net [2] entschieden und erfolgreich durchgeführt.. Was man im Vordergrund nicht sieht ist natürlich die monatelange Arbeit im Hintergrund - eine umfassende Integration mit internen ERP- und Produktionssteuerungssystemen in verschiedenen Ländern für die Abbildung und Optimierung der Geschäftsprozesse. Denn das Layout ist es nicht mehr dieser Tage, die Funktionalität muss stimmen und auch Vorteile bringen.

Ein tolles Projekt. Glückwunsch an das Team!

[1] http://www.Ifolor.de
[2] http://de.AxCMS.net

Aufzeichnungen von den TechDays BI und SQL Server 2008 R2 stehen zur Verfügung

21.06.2010 16:25:04 | Steffen Krause

Die Aufzeichnungen für die Mai-Techdays, bei denen wir uns mit Business Intelligence und SQL Server 2008 R2 beschäftigt haben stehen jetzt zur Verfügung. Sie sind etwas falsch als TechDay Juni betitelt. Teil 1 von 5: SQL Server 2008 R2 und die Microsoft BI Plattform Teil 2 von 5: PowerPivot und Analysis Services in SQL Server 2008 R2 Teil 3 von 5: Reporting Services in SQL Server 2008 R2 Teil 4 von 5: Business Intelligence in SharePoint Server 2010 und Office 2010 Teil 5 von 5: SQL Server 2008 R2 – was gibt es Neues im nicht-BI-Bereich Gruß, Steffen...(read more)

Eine neue Folge von msdn tv ist online 09/2010

21.06.2010 10:25:52 | Oliver Scheer

clip_image002Die zehnte Ausgabe von msdn tv in diesem Jahr widmet sich dem Thema Open Source und der spannenden Frage, wie es denn Microsoft damit hält. Kompetenter Gesprächspartner von Moderator Jan Schenk ist diesmal James Utzschneider, General Manager Open Source bei Microsoft.
Vorab geht‘s in den Kurznachrichten u.a. um die englischsprachige Version 4 von Expression Studio, die ab sofort als Download erhältlich ist und gleich mehrfach um nützlichen Lesestoff für Programmierer: einmal um einen Leitfaden, der bei Auswahl der passenden Visual Studio 2010 Edition weiterhilft und um das neue Evaluierungshandbuch für SharePoint 2010-Entwickler von Microsoft, das im Downloadcenter kostenlos abgerufen werden kann. Dort, im Microsoft Downloadcenter, steht auch die jüngste Fassung der „Windows Azure Tools for Visual Studio 1.2” zum herunterladen bereit.
P.S.: Wer bis zu den Outtakes durchhält, wird noch mit einem bizarren Themenreigen belohnt: Schluckauf, Katzen und sonderbares deutsches Liedgut. Damit tritt unser begnadeter Frontman Jan Schenk wohl endgültig in die Fußstapfen seines berühmten Namensvetters und TV-Urgesteins Heinz.

Facebook-Gruppe: http://www.facebook.com/msdntv

Office 2010 installiert und Visual Studio 2008 friert ein?

20.06.2010 21:38:00 | Peter Bucher

Nebenbei habe ich letztens Office 2010 installiert.
Als ich dann wieder einmal Visual Studio 2008 benutzte, blieb die Anwendung im ASPX-Editor komplett hängen.

Es musste der Prozess abgeschossen werden, um VS überhaupt beenden zu können.
Mein Verdacht lag zuerst bei Resharper, was sich dann aber als falsch herausgestellt hat.

Bei mir hat die Lösung mit dem Reparieren von den "Web Authoring Components" geholfen:

Silverlight: Managing presentation model state

20.06.2010 11:15:00 | Patric Schouler

In our current project Privatbilanz we had the problem that we have to manage the state of the IsExpanded property in a treeview.

Our architecture:
  • Data Access Layer: Entity Framework
  • WCF RIA Services
  • Silverlight client

After each manipulation of our nodes of the treeview, we have to call the WCF service to give us back the fresh list of nodes. After this action the tree will have has initial look – all nodes are collapsed :-(

So what we did now was to extend our data model at the client side with a partial class to define for our entity a IsExpanded property.

Step 1 – Extend entity
   1: public partial class AnzeigeKategorie
   2:     {
   3:         private bool _isExpanded;
   4:         
   5:         public bool IsExpanded
   6:         {
   7:             get { return _isExpanded; }
   8:             set
   9:             {
  10:                 if (value == _isExpanded) return;
  11:                 _isExpanded = value;
  12:                 RaisePropertyChanged("IsExpanded");
  13:             }
  14:         }
  15:     }

Note: You have to use the same namepace as your model at the service side (WCF RIA Services)

Step 2 – Bind the property to UI
   1: <!--TreeViewItem Style-->
   2:     <Style TargetType="controls:TreeViewItem">
   3:         <Setter Property="Padding" Value="3"/>
   4:         <Setter Property="HorizontalContentAlignment" Value="Stretch"/>
   5:         <Setter Property="VerticalContentAlignment" Value="Top"/>
   6:         <Setter Property="Background" Value="Transparent"/>
   7:         <Setter Property="Foreground" Value="{StaticResource TextBrush}"/>
   8:         <Setter Property="FontFamily" Value="{StaticResource ContentFontFamily}"/>
   9:         <Setter Property="FontSize" Value="{StaticResource ContentFontSize}"/>
  10:         <Setter Property="TextOptions.TextHintingMode" Value="Animated"/>
  11:         <Setter Property="BorderThickness" Value="1"/>
  12:         <Setter Property="Cursor" Value="Arrow"/>
  13:         <Setter Property="IsTabStop" Value="True"/>
  14:         <Setter Property="TabNavigation" Value="Once"/>
  15:         <Setter Property="Margin" Value="0 1 0 0"/>
  16:         <Setter Property="Helpers:SetterValueBindingHelper.PropertyBinding">
  17:             <Setter.Value>
  18:                 <Helpers:SetterValueBindingHelper Property="IsExpanded" Binding="{Binding IsExpanded, Mode=TwoWay}" />
  19:             </Setter.Value>
  20:         </Setter>

Because in our case the control is a TreeviewItem we have to do this in our style definition. Unfortunately Silverlight does not support this kind of binding at the normal way – WPF is at this point much better.

So what we have to do additional is to define a helper class SetterValueBindingHelper. We found this really useful class at Delay’ Blog:

As the platform evolves, so do the workarounds [Better SetterValueBindingHelper makes Silverlight Setters better-er!] - Delay's Blog - Site Home - MSDN Blogs

 
Step 3 – Helper class for Setter binding
   1: /// <summary>
   2:     /// Class that implements a workaround for a Silverlight XAML parser
   3:     /// limitation that prevents the following syntax from working:
   4:     ///    &lt;Setter Property="IsSelected" Value="{Binding IsSelected}"/&gt;
   5:     /// </summary>
   6:     public class SetterValueBindingHelper
   7:     {
   8:         /// <summary>
   9:         /// Optional type parameter used to specify the type of an attached
  10:         /// DependencyProperty as an assembly-qualified name, full name, or
  11:         /// short name.
  12:         /// </summary>
  13:         [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods",
  14:             Justification = "Unambiguous in XAML.")]
  15:         public string Type { get; set; }
  16:  
  17:         /// <summary>
  18:         /// Property name for the normal/attached DependencyProperty on which
  19:         /// to set the Binding.
  20:         /// </summary>
  21:         public string Property { get; set; }
  22:  
  23:         /// <summary>
  24:         /// Binding to set on the specified property.
  25:         /// </summary>
  26:         public Binding Binding { get; set; }
  27:  
  28:         /// <summary>
  29:         /// Gets the value of the PropertyBinding attached DependencyProperty.
  30:         /// </summary>
  31:         /// <param name="element">Element for which to get the property.</param>
  32:         /// <returns>Value of PropertyBinding attached DependencyProperty.</returns>
  33:         [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters",
  34:             Justification = "SetBinding is only available on FrameworkElement.")]
  35:         public static SetterValueBindingHelper GetPropertyBinding(FrameworkElement element)
  36:         {
  37:             if (null == element)
  38:             {
  39:                 throw new ArgumentNullException("element");
  40:             }
  41:             return (SetterValueBindingHelper)element.GetValue(PropertyBindingProperty);
  42:         }
  43:  
  44:         /// <summary>
  45:         /// Sets the value of the PropertyBinding attached DependencyProperty.
  46:         /// </summary>
  47:         /// <param name="element">Element on which to set the property.</param>
  48:         /// <param name="value">Value forPropertyBinding attached DependencyProperty.</param>
  49:         [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters",
  50:             Justification = "SetBinding is only available on FrameworkElement.")]
  51:         public static void SetPropertyBinding(FrameworkElement element, SetterValueBindingHelper value)
  52:         {
  53:             if (null == element)
  54:             {
  55:                 throw new ArgumentNullException("element");
  56:             }
  57:             element.SetValue(PropertyBindingProperty, value);
  58:         }
  59:  
  60:         /// <summary>
  61:         /// PropertyBinding attached DependencyProperty.
  62:         /// </summary>
  63:         public static readonly DependencyProperty PropertyBindingProperty =
  64:             DependencyProperty.RegisterAttached(
  65:                 "PropertyBinding",
  66:                 typeof(SetterValueBindingHelper),
  67:                 typeof(SetterValueBindingHelper),
  68:                 new PropertyMetadata(null, OnPropertyBindingPropertyChanged));
  69:  
  70:         /// <summary>
  71:         /// Change handler for the PropertyBinding attached DependencyProperty.
  72:         /// </summary>
  73:         /// <param name="d">Object on which the property was changed.</param>
  74:         /// <param name="e">Property change arguments.</param>
  75:         private static void OnPropertyBindingPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
  76:         {
  77:             // Get/validate parameters
  78:             var element = (FrameworkElement)d;
  79:             var item = (SetterValueBindingHelper)(e.NewValue);
  80:             if ((null == item.Property) || (null == item.Binding))
  81:             {
  82:                 throw new ArgumentException(
  83:                     "SetterValueBindingHelper's Property and Binding must both be set to non-null values.");
  84:             }
  85:  
  86:             // Get the type on which to set the Binding
  87:             Type type = null;
  88:             if (null == item.Type)
  89:             {
  90:                 // No type specified; setting for the specified element
  91:                 type = element.GetType();
  92:             }
  93:             else
  94:             {
  95:                 // Try to get the type from the type system
  96:                 type = System.Type.GetType(item.Type);
  97:                 if (null == type)
  98:                 {
  99:                     // Search for the type in the list of assemblies
 100:                     foreach (var assembly in AssembliesToSearch)
 101:                     {
 102:                         // Match on short or full name
 103:                         type = assembly.GetTypes()
 104:                             .Where(t => (t.FullName == item.Type) || (t.Name == item.Type))
 105:                             .FirstOrDefault();
 106:                         if (null != type)
 107:                         {
 108:                             // Found; done searching
 109:                             break;
 110:                         }
 111:                     }
 112:                     if (null == type)
 113:                     {
 114:                         // Unable to find the requested type anywhere
 115:                         throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
 116:                             "Unable to access type \"{0}\". Try using an assembly qualified type name.",
 117:                             item.Type));
 118:                     }
 119:                 }
 120:             }
 121:  
 122:             // Get the DependencyProperty for which to set the Binding
 123:             DependencyProperty property = null;
 124:             var field = type.GetField(item.Property + "Property",
 125:                 BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static);
 126:             if (null != field)
 127:             {
 128:                 property = field.GetValue(null) as DependencyProperty;
 129:             }
 130:             if (null == property)
 131:             {
 132:                 // Unable to find the requested property
 133:                 throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
 134:                     "Unable to access DependencyProperty \"{0}\" on type \"{1}\".",
 135:                     item.Property, type.Name));
 136:             }
 137:  
 138:             // Set the specified Binding on the specified property
 139:             element.SetBinding(property, item.Binding);
 140:         }
 141:  
 142:         /// <summary>
 143:         /// Returns a stream of assemblies to search for the provided type name.
 144:         /// </summary>
 145:         private static IEnumerable<Assembly> AssembliesToSearch
 146:         {
 147:             get
 148:             {
 149:                 // Start with the System.Windows assembly (home of all core controls)
 150:                 yield return typeof(Control).Assembly;
 151:  
 152:                 // Fall back by trying each of the assemblies in the Deployment's Parts list
 153:                 foreach (var part in Deployment.Current.Parts)
 154:                 {
 155:                     var streamResourceInfo = Application.GetResourceStream(
 156:                         new Uri(part.Source, UriKind.Relative));
 157:                     using (var stream = streamResourceInfo.Stream)
 158:                     {
 159:                         yield return part.Load(stream);
 160:                     }
 161:                 }
 162:             }
 163:         }
 164:     }

Silverlight: Binding Events to ICommand interface (MVVM)

19.06.2010 12:06:00 | Patric Schouler

If you want to bind Silverlight controls which does not implement the ICommand interface to an ICommand method of your viewmodel, you can use System.Windows.Interactivity with the following pattern. In this sample I have implemented a SaveCommand at the LostFocus-Event of a TextBox.

XAML
   1: <TextBox 
   2:                                    Text="{Binding Name, Converter={StaticResource UpperCaseConverter}, Mode=TwoWay}" 
   3:                                    Grid.Column="0"                           
   4:                                    HorizontalAlignment="Stretch" 
   5:                                    VerticalAlignment="Center" 
   6:                                    Width="Auto" 
   7:                                    FontSize="18" 
   8:                                    Template="{StaticResource TextBoxFadeOut}">
   9:                                    <Interactivity:Interaction.Triggers>
  10:                                        <Interactivity:EventTrigger EventName="LostFocus" >
  11:                                            <Helpers:InvokeDelegateCommandAction 
  12:                                                Command="{Binding DataContext.SaveKategorieCommand, ElementName=LayoutRoot}" CommandParameter="{Binding}"/>
  13:                                        </Interactivity:EventTrigger>
  14:                                    </Interactivity:Interaction.Triggers>
  15:                                </TextBox>
Viewmodel-Command Definition
   1: public ICommand SaveKategorieCommand { get; set; }
   2:  
   3: SaveKategorieCommand = new DelegateCommand(SaveKategorie);
Viewmodel-Command Implementation

   1: private void SaveKategorie(object param)
   2:        {
   3:            if (param != null && param is AnzeigeKategorie)
   4:            {
   5:                var anz = param as AnzeigeKategorie;
   6:                if (anz.HasChanges)
   7:                {
   8:                    _domainContextSynchronizer.AddSubmitChangesToQueue();
   9:                }
  10:            }
  11:        }
Helper-Method InvokeDelegateCommandAction
   1: public sealed class InvokeDelegateCommandAction : TriggerAction<DependencyObject>
   2:     {
   3:         /// <summary>
   4:         ///
   5:         /// </summary>
   6:         public static readonly DependencyProperty CommandParameterProperty =
   7:             DependencyProperty.Register("CommandParameter", typeof(object), typeof(InvokeDelegateCommandAction), null);
   8:         
   9:         /// <summary>
  10:         ///
  11:         /// </summary>
  12:         public static readonly DependencyProperty CommandProperty = DependencyProperty.Register(
  13:             "Command", typeof(ICommand), typeof(InvokeDelegateCommandAction), null);
  14:  
  15:         /// <summary>
  16:         ///
  17:         /// </summary>
  18:         public static readonly DependencyProperty InvokeParameterProperty = DependencyProperty.Register(
  19:             "InvokeParameter", typeof(object), typeof(InvokeDelegateCommandAction), null);
  20:  
  21:         private string commandName;
  22:  
  23:         /// <summary>
  24:         ///
  25:         /// </summary>
  26:         public object InvokeParameter
  27:         {
  28:             get
  29:             {
  30:                 return this.GetValue(InvokeParameterProperty);
  31:             }
  32:             set
  33:             {
  34:                 this.SetValue(InvokeParameterProperty, value);
  35:             }
  36:         }
  37:  
  38:         /// <summary>
  39:         ///
  40:         /// </summary>
  41:         public ICommand Command
  42:         {
  43:             get
  44:             {
  45:                 return (ICommand)this.GetValue(CommandProperty);
  46:             }
  47:             set
  48:             {
  49:                 this.SetValue(CommandProperty, value);
  50:             }
  51:         }
  52:  
  53:         /// <summary>
  54:         ///
  55:         /// </summary>
  56:         public string CommandName
  57:         {
  58:             get
  59:             {
  60:                 return this.commandName;
  61:             }
  62:             set
  63:             {
  64:                 if (this.CommandName != value)
  65:                 {
  66:                     this.commandName = value;
  67:                 }
  68:             }
  69:         }
  70:  
  71:         /// <summary>
  72:         ///
  73:         /// </summary>
  74:         public object CommandParameter
  75:         {
  76:             get
  77:             {
  78:                 return this.GetValue(CommandParameterProperty);
  79:             }
  80:             set
  81:             {
  82:                 this.SetValue(CommandParameterProperty, value);
  83:             }
  84:         }
  85:  
  86:         /// <summary>
  87:         ///
  88:         /// </summary>
  89:         /// <param name="parameter"></param>
  90:         protected override void Invoke(object parameter)
  91:         {
  92:             this.InvokeParameter = parameter;
  93:  
  94:             if (this.AssociatedObject != null)
  95:             {
  96:                 ICommand command = this.ResolveCommand();
  97:                 if ((command != null) && command.CanExecute(this.CommandParameter))
  98:                 {
  99:                     command.Execute(this.CommandParameter);
 100:                 }
 101:             }
 102:         }
 103:  
 104:         private ICommand ResolveCommand()
 105:         {
 106:             ICommand command = null;
 107:             if (this.Command != null)
 108:             {
 109:                 return this.Command;
 110:             }
 111:             var frameworkElement = this.AssociatedObject as FrameworkElement;
 112:             if (frameworkElement != null)
 113:             {
 114:                 object dataContext = frameworkElement.DataContext;
 115:                 if (dataContext != null)
 116:                 {
 117:                     PropertyInfo commandPropertyInfo = dataContext
 118:                         .GetType()
 119:                         .GetProperties(BindingFlags.Public | BindingFlags.Instance)
 120:                         .FirstOrDefault(
 121:                             p =>
 122:                             typeof(ICommand).IsAssignableFrom(p.PropertyType) &&
 123:                             string.Equals(p.Name, this.CommandName, StringComparison.Ordinal)
 124:                         );
 125:  
 126:                     if (commandPropertyInfo != null)
 127:                     {
 128:                         command = (ICommand)commandPropertyInfo.GetValue(dataContext, null);
 129:                     }
 130:                 }
 131:             }
 132:             return command;
 133:         }
 134:     }

At this way you can bind each event of any Silverlight control to a ICommand.

VSTO 2010: Multi Target Deployment

18.06.2010 12:00:00 | Jens Häupel

Bisher wurde je ein Projekt in ein ClickOnce Package gepackt. Bei mehreren Add-Ins, vielleicht auch noch für verschiedene Anwendungen, wird es schnell unübersichtlich. Jedes Paket muss einzeln getestet werden. Das ändert sich mit VSTO 2010. Nun können mehrere Add-Ins zu einem Paket zusammengefasst werden. Ich will hier einmal beschreiben, welche Schritte dazu nötig sind.

Nehmen wir an, wir haben 2 Lösungen (Excel und Word), die gemeinsam verteilt werden sollen. Zunächst wird ein weiteres Projekt der Solution hinzugefügt (ContosoInstaller), welches die Basis für das gemeinsame Verteilungsprojekt bildet. Das dient nur als Dummy und sollte ein Add-In-Projekt für einen Office Client sein, für den sowieso schon ein Add-In verteilt werden soll (hier Word oder Excel). Benötigt werden nur das Application Manifest (*.manifest) und das Deployment Manifest (*.vsto). Für dieses Projekt wird nun ClickOnce Deployment konfiguriert, also Pre-Requisites, Updateverhalten, Versionierung und die Starteinträge eingestellt.

clip_image002

Für die Einzelprojekte muss noch das Ladeverhalten des Add-Ins festgelegt werden (Publish Options: Beim Start, OnDemand, etc.).

clip_image004

Zu Guter Letzt wird das Publishing aller 3 Projekte durchgeführt.

Nun ist Handarbeit angesagt, denn aus den Application Manifests der beiden Add-In-Projekte müssen Einträge in das Dummy-Manifest kopiert werden, welches damit zum Multi-Add-In-Manifest wird. Wir legen dazu einen neuen Ordner (ContosoInstaller) an, in den folgende Dateien kopiert werden:

  • ContosoInstaller\ContosoInstaller.vsto
  • ContosoInstaller\Application Files\ContosoInstaller_1_0_0_0: Alle Dateien mit dem Suffix .deploy sowie ContosoInstaller.dll.manifest.

Die Ordnerstruktur lassen wir so, wie vom Dummy-Projekt (Publish-Ordner) vorgegeben, sonst müssen noch die Pfade innerhalb der Manifeste geändert werden. Angepasst werden muss u.U. auch die Versionsnummer, welche aber auch über das Dummy-Projekts innerhalb von Visual Studio vor dem Publishing angepasst werden kann.

Alle 3 Application Manifeste werden in nun Visual Studio geöffnet. Aus dem Multi-Add-In-Manifest werden folgende Einträge entfernt:

  • Alle Dependency Einträge, bei denen dependencyType=“install“ ist
  • Alle vstav3:entryPoints (sollte nur einer sein)
  • Alle vstov4:customizations (sollte nur einer sein)

Jetzt geht’s ans Kopieren. Aus beiden Application Manifests werden diejenigen Abhängigkeiten kopiert, deren Typ „Install“ ist.

image

Sie werden am Ende der Dependency Liste Eingefügt, wobei auf Duplikate geachtet werden muss.

Nun werden die Entry Points kopiert (einer pro Projekt). Zu finden sind sie unter vstav3:entryPointsCollection. Sie werden an der gleichen Stelle im Zielmanifest eingefügt. Da es nun aber mehr als einen gibt, muss eine eindeutige ID vergeben werden.

image

Am Ende der Kopiererei müssen die Assemblies noch dem VSTO.V4 Namensraum zugeordnet werden. Das geschieht im Abschnitt vstov4:customizations. Auch hier besteht wieder die Notwendigkeit, eine ID zu vergeben.

image

An Ende müssen die Manifeste noch signiert werden. Dazu wird Mage.exe, das Manifest Generation Tool, benötigt, welches im Windows 7 SDK enthalten ist.

image

Und das Deployment Manifest wird so signiert:

image

(Die drei Punkte im Pfad müssen natürlich durch den korrekten Pfad ersetzt werden.)

Damit ist das ClickOnce Package komplett fertig modifiziert und kann getestet werden.

.NET User Group in Bielefeld am 21.06.2010

18.06.2010 11:07:25 | Mathias Raacke

Bereits vor einigen Jahren gab es schon einmal die .NET User Group Bielefeld. Nachdem Henner – der die Gruppe damals organisierte – aber seinen Arbeitgeber gewechselt hatte, fand sich kein Nachfolger für die Organisation der User Group.

Inzwischen hat Henner eine eigene Firma und ich bin von Paderborn nach Werther (bei Bielefeld) gezogen. Deshalb werden wir zusammen erneut die Treffen der .NET User Group in Bielefeld organisieren.

Da unsere alte Domain dotnet-bielefeld.de noch immer bei Henners ehemaligem Arbeitgeber liegt und die Übergabe sich nun schon seit Wochen verzögert gibt es die Infos zur User Group vorläufig hier im Blog.

Das 1. Treffen ist am 21.06.2010 um 18 Uhr. Wir treffen uns bei Xavannah in der Karl-Oldewurtel Straße 40 in Bielefeld. Der Treffpunkt ist sowohl über die A2/A33 als auch mit der Bahn gut erreichbar.

Unter anderem werde ich ein wenig über Visual Studio 2010 Extensibility erzählen.

Scrum Prozessvorlage für TFS

18.06.2010 10:25:00 | Jan Christian Selke

Zwar nicht mehr brandaktuell, aber Microsoft bietet seit Anfang des Monats die Beta Version einer Scrum Prozessvorlage für den TFS zum kostenlosen Download an. Mehr dazu findet sich hier.

Folgende Punkte werden mit der Vorlage abgedeckt:

  • Work Item Types
    • Product Backlog Item
    • Bug
    • Task
    • Impediment
    • Test Case
    • Sprint
  • Reports
    • Release Burndown
    • Velocity
    • Sprint Burndown
  • SharePoint Project Portal

24.06.2010 Treffen der .NET Developer Group Braunschweig - WCF RIA Services

18.06.2010 07:06:00 | Lars Keller

Die DNUG Braunschweig trifft sich am 24.06.10 um 19:00 Uhr im Restaurant Zucker (Tagungsraum). Uns kommt der Microsoft MVP Constantin Klein mit dem Thema “WCF RIA Services” besuchen.

Abstract:
Mit den Windows Communication Foundation (WCF) RIA Services verspricht Microsoft die Entwicklung von traditionellen n-tier Applikationen zu vereinfachen und die ASP.NET und die Silverlight Plattform zusammen zu bringen. Diese Session gibt einen Überblick darüber, was es damit auf sich hat und wie man mit den WCF RIA Services schnell und effizient Lösungen entwickeln kann.

Bio:
Constantin arbeitet als Anwendungsarchitekt und Entwickler bei der Freudenberg Forschungsdienste KG. Dort beschäftigt er sich hauptsächlich mit dem Design und der Entwicklung von Web-Informationssystemen und Datenbanken. Seit seinem Studium der Wirtschaftsinformatik gilt sein besonderes Interesse darüber hinaus allen aktuellen Themen im Microsoft .NET Umfeld, insbesondere aber dem Thema Softwarearchitektur. Er ist MCSD, MCITP Database Developer und MCPD Web + Enterprise Application Developer. 2010 wurde er von Microsoft zum Most Valuable Professional (MVP) für SQL Server ernannt. Er engagiert sich zusätzlich im Vorstand des Just Community e.V. (http://www.justcommunity.de) und als Leiter der .NET User Group Frankfurt (http://www.dotnet-ug-frankfurt.de). Sein Blog finden Sie unter http://kostjaklein.wordpress.com

Wie immer ist dieses Event kostenlos und jeder .NET Interessierte ist herzlich willkommen!

Weitere Informationen zur DNUG Braunschweig findest du hier.

Bericht vom Office Community Day 2010

18.06.2010 05:15:00 | Lars Keller

Der zweite Office Community Day ist nun vorüber und auch dieses Mal war es ein voller Erfolg. Waren wir Teilnehmer des Office Community Day 2010noch letztes Jahr bei Microsoft Österreich in Wien zu Gast, wurde dieses Jahr der Office Community Day 2010 bei Microsoft Deutschland in Unterschleißheim von Mario Meir-Huber und mir ausgerichtet. Natürlich mit viel Hilfe von Tom Wendel (noch mal herzlichen Dank dafür !!!). Insgesamt waren knapp 20 Teilnehmer vor Ort (darunter wieder 1 Schweizer und 2 Österreicher), was mich besonders gefreut hat. Somit scheint der Office Community Day im deutschsprachigem Raum eine sehr interessante Veranstaltung zu sein. Wir hatten auch ein breites Spektrum von Teilnehmern. Vom Hobby-Entwickler bis zum Profi war alles vertreten, aber es waren auch Teilnehmer dabei, welche Endanwender waren und sich einfach von den umfangreichen Möglichkeiten der Office Anpassungen inspirieren lassen wollten! Mario Meir-Huber und Lars Keller

Es wurde viel besprochen! VSTO 4, COM Interop und .NET waren natürlich Hauptthema. .-) Dieses Jahr haben wir uns nicht nur rein auf die MS Office Entwicklung mit VSTO beschränkt, sondern die Veranstaltung um das Thema SharePoint erweitert. Beide Welten wachsen immer mehr zusammen, was wir auch in den Sessions demonstriert haben. Natürlich hatten wir auch viel Zeit für das Networken bei Brötchen, Kuchen und Kaffee einkalkuliert. Besonders gefreut haben wir uns, dass der eine oder andere Microsoft Mitarbeiter vorbeigeschaut hat.

Die Abendveranstaltung haben fast alle im Restaurant Culininari USH mit uns verbracht, wo viele der Session Themen noch mal vertieft, besprochen worden.

Besonderen Dank möchte ich noch mal Albert Weinert und Jörg Egretzberger aussprechen, welche spontan für den erkrankten Andi einsprangen und seine SharePoint/TDD Session übernahmen. Auch meinen VSTO MVP Kollegen Helmut Obertanner möchte ich für seine Unterstützung recht herzlich Danken! Danke Jungs! So etwas nenn ich Community!  Office Community Day 2010 Abendveranstaltung im Culinari USH

Mein weiterer Dank geht an die Sponsoren: Typemock, dotnetpro, Codeforce, AX Solutions GmbH, Microsoft Deutschland, Dorothea (für die CLIP-Goodies) und natürlich den Spenden der Teilnehmern! Danke! :)

Wie versprochen findet ihr unten aufgelistet die Materialien zu den Sessions (Alles liegt mir noch nicht vor, ich werde es nach und nach ergänzen).

 

 

Downloads:

 Tom Wendel bei der Sharepoint SessionJörg Erztberger und Albert Weinert in Action

Konstruktorinjektion unterschiedlicher Instanzen eines Typs mit StructureMap

17.06.2010 08:26:00 | Jan Christian Selke

In einem Projekt, in dem wir StructureMap als DI Container nutzen, standen wir vor einem kleinen Rätsel. Wir hatten einen Typ, der im Konstruktor als Parameter zwei unterschiedliche Objekte des gleichen Typs erwartete.

public interface IMojo
{

}


public class Mojo
{
public Mojo(IFooBar fooBar1, IFooBar fooBar2)
{

}
...
}

Zuerst haben wir hier die StructureMap Standardregistrierung genutzt.
For<IMojo>().Use<Mojo>();
For<IFooBar>().Use<FooBar>();

Das hatte aber zur Folge, dass nicht zwei Instanzen des Typs als Parameter injiziert wurden (was ich eigentlich aufgrund des transienten LifeCycles erwartet hatte), sondern zweimal die selbe Instanz. Ein andere Lösung musste also her.
Kurz gesagt: wir haben letztlich benannte Instanzen genutzt. Ich weiß, dass es unterschiedliche Ansichten über Sinn und Unsinn von benannten Instanzen gibt – in diesem Fall funktioniert es damit aber für uns. Falls jemand eine andere Idee hat, bin ich für Anregungen offen ;-).
Die Registrierung sieht zum Schluss nun wie folgt aus:
For<IFooBar>().Use<FooBar>().Named("foo1");
For<IFoorBar>().Use<FooBar>().Named("foo2");

For<IMojo>().Use<Mojo>()
.Ctor<IFooBar>("fooBar1").Is(x => x.TheInstanceNamed("foo1"))
.Ctor<IFooBar>("fooBar2").Is(x => x.TheInstanceNamed("foo2"));

…weil man nicht nur in Amerika gerne mal ein Bierchen trinkt

17.06.2010 00:17:00 | Gordon Breuer

Von der peinlichen (oder vielleicht doch absichtlichen?) Panne des Apple-Mitarbeiters, der sein (Prototyp)-Handy in einem Biergarten vergessen hat, haben sicher schon alle gehört. Ob es für die elektronischen Geräte auf der Basis von Kernobst ebenfalls eine Lösung – wie die im Folgenden vorgestellte – gibt, weiß ich leider nicht. Zumindestens aber für Geräte auf Basis von Symbian, Windows Mobile und Android gibt es eventuell Abhilfe.

(c) photocase.com Wie uns der bereits erwähnte Fall des im Biergarten vergessenen Handys / Smartphones verdeutlicht kann es auch gewissenhaften Menschen immer mal passieren, dass man seinen elektronischen Begleiter verliert. Aber es muss gar nicht die eigene Schusseligkeit sein: Es gibt auch Menschen mit sagen wir mal weniger tugendhaften Absichten, welche ohne das Einverständnis des Eigentümers den Gegenstand in Besitz nehmen wollen (für alle, deren Gehirn bereits vuvuzelageschädigt ist: gemeint sind Diebe). Im ersten Fall genügt manchmal ein einfacher Anruf an sich selbst und das Hoffen auf einen ehrlichen Finder, der das Gerät gerne wieder zurückgibt. Im zweiten Fall wird das schon schwieriger: Der “Finder” wird nicht nur nicht das Gespräch annehmen sondern vermutlich durch Wechsel der SIM-Karte das Handy unerreichbar machen.

Die beste Methode ist hier sicherlich, die IMEI (eine weltweit eindeutige, 15-stellige Seriennummer) an den eigenen Provider und an die Polizei im Rahmen einer Diebstahlanzeige weiterzugeben (zu ermitteln über den GSM-Code *#06#). Sobald jemand versucht das Handy in Betrieb zu nehmen kann dieses so (zumindest ungefähr) geortet und – theoretisch – für alle SIM-Karten im EIR gesperrt werden. Der Nachteil: Eventuell private Daten sind weiterhin auf dem Handy zugänglich und dem Datenmissbrauch ist Tür und Tor geöffnet. Auch für den Fall, dass man das Handy nur verloren oder verlegt hat ist eine solche Meldung eher ungeeignet.


 

Testbericht: “Anti Theft for Mobile” von “F-Secure”

In diese Lücke springt die Software “Anti Theft for Mobile”. F-Secure hat sich – zumindestens im Augenblick – dafür entschieden, das Programm kostenlos verfügbar zu machen. Die Funktionsweise ist denkbar einfach: Nach der Installation auf dem Smartphone mit Symbian, Android oder Windows Mobile (was zumindest unter WinMo einen Neustart des Gerätes zur Folge hat) und der Vergabe eines persönlichen Sicherheitscodes (in den folgenden Beispielen “12345678”), arbeitet die Software im Hintergrund. Von nun an hat man drei SMS-Kommandos zur Verfügung:

Sperren des Telefons

Wer das Telefon zunächst lediglich sperren möchte, damit es von niemandem mehr benutzt werden kann, sendet einfach den Code #lock#12345678 als SMS an sein Handy. Hierfür muss allerdings auch die Gerätesperre aktiviert werden. Das Handy sperrt sich im übrigen auch, wenn bsp. ein Dieb eine andere SIM-Karte einlegt. In diesem Fall kann man auch aktivieren, dass dessen Handy-Nummer automatisch an eine festzulegende Nummer als SMS geschickt wird.

Lokalisieren

Sofern in der Software aktiviert lässt sich der Standort des eigenen Handys auf Google-Maps anzeigen durch Senden einer SMS mit #locate#12345678.

Reinitialisieren

Um auf Nummer sicher zu gehen kann man – ebenfalls sofern in den Einstellungen aktiviert – das Telefon komplett löschen bzw. Reinitialisieren. Dazu genügt wieder eine SMS, dieses mal mit dem Code #wipe#12345678. Anschließend sollen alle Daten bereinigt werden und man hat nur noch ein Telefon mit den Werksteinstellungen.

Der Praxistest

(c) photocase.com Das erste Problem tat sich bei mir auf, als ich die Software installieren wollte: Das Programm ist mit beinahe 7MB ein ziemlich unhandlicher Brocken und auf meinem HTC Touch Diamond habe ich sowieso ständig Probleme mit zu wenig Datenspeicher. Schließlich habe ich es doch noch installiert bekommen und nach einem Neustart des Telefons werde ich sofort von einem kleinen Assistenten begrüßt. Der will einen automatischen Update-Service einrichten, ohne den die Software nicht funktionieren soll. Ein Datentarif ist also vermutlich empfehlenswert. Weiteres Problem: Da der Assistent sofort nach dem Neustart sich in den Vordergrund drängte, konnte ich meinen PIN noch gar nicht eingeben und ohne den gibts auch keine Datenverbindung. Als auch diese Hürde genommen ist werden noch ein paar kleine Updates heruntergeladen, diverse Systemicons tauchen neben der Uhrzeit auf und schließlich müssen in den Einstellungen noch diverse Funktionen wie die Lokalisierung und der Wipe aktiviert werden um die SMS-Kommandos auch nutzen zu können.

Doch was ist das: Ich habe neben meinem Diebstahlschutz auch noch Icons für Virenschutz, Firewall und den Browser-Schutz – alles kostenpflichte Programmteile von F-Secure die ich aber weder installieren noch haben wollte! Kurz darauf startet auch schon ein automatischer Virenscan und später steht in der Sicherheitsübersicht, dass ich noch 90 Tage in meinem Abonnement verbleibend habe. Kein Wunder also, dass das ganze Paket so viel Platz in meinem Datenspeicher verschlingt wenn ohne Nachfrage noch soviel Testsoftware mit installiert wird.

Ich vergebe für den Praxistest also einen Sicherheitscode in den Einstellungen und aktiviere unter anderem den “Locator”. Anschließend sende ich eine SMS mit dem entsprechenden Befehl an mein Handy und … warte. Beinahe 5 Minuten später kommt dann endlich eine Antwort-SMS: “Location information is not available” – aha. Sofern die Software hier ausschließlich auf ein GPS-Signal verlässt ist die Antwort erklärbar, immerhin sitze ich am Computer innerhalb eines Gebäudes und das Handy hat sicherlich keinen GPS-Empfang zur Zeit. Hier erwarte ich aber eigentlich zumindestens eine ungefähre Positionsbestimmung anhand der Mobilfunkzellen, bei denen das Handy angemeldet ist. Selbst kostenlose Tools nutzen diese Funktion immer häufiger da sie schneller und auch ohne GPS-Signal funktioniert. Und bevor ich gar keine Info erhalte ist mir eine ungefähre Position allemal lieber. F-Secure scheint hier jedoch anderer Meinung zu sein.

Fazit

(c) photocase.com Das ungefragte Installieren von Testsoftware ist eine Praxis die schon auf dem Desktop-PC nervt, bei einem Handy mit begrenzten Ressourcen aber ist es schon fast eine Frechheit. Es ist verständlich, dass F-Secure mit diesem Programm natürlich auch Werbung für seine anderen produkte machen möchte, aber so muss es ja wirklich nicht sein. Auch die eigentliche Funktion mag nicht wirklich überzeugen: Die Lokalisierung hat auf Anhieb nicht funktioniert, alle gewünschten Befehle müssen zunächst in einem schwer auffindbaren Einstellungsdialog aktiviert werden und schlußendlich gibt es auch keine Web-Oberfläche um die bereitgestellten Funktionen zu verwenden. Hat man also keinen Zugriff auf ein weiteres Handy auf das dann auch die Antworten geschickt werden können, hat man ein ernsthaftes Problem. Das selbe Problem ergibt sich bei der Diebstahlsicherung wenn eine fremde SIM-Karte eingelegt wird: Die Benachrichtigung mit der fremden Handynummer wird ausschließlich an eine zuvor festhinterlegte Handynummer versendet. Hier wäre entweder auch eine Web-Oberfläche hilfreich oder zumindestens die Möglichkeit statt einer SMS eine E-Mail zu versenden. Sollten die Antwort- und Benachrichtigungs-SMS von der Software direkt verschickt werden – wovon ich ausgehe, aber nicht nachsehen konnte – besteht hier weiterhin die Möglichkeit den Versand zu verhindern wenn man einen Prepaid-Tarif und kein weiteres Guthaben hat. Auch dieser Fall kann schließlich immer mal wieder vorkommen, im Zweifel würde ich als Dieb jedenfalls eine (anonyme) SIM-Karte mit Prepaid-Tarif ohne Guthaben für die erste Inbetriebnahme verwenden um genau solche Sicherheitsmaßnahmen auszuhebeln.

Alles in allem ist das Tool nicht nur kostenlos sondern sogar umsonst – und bereits wieder von meinem Smartphone runtergeflogen.

Alternative: Microsoft My Phone

Microsoft My Phone Seit geraumer Zeit verwende ich bereits “Microsoft My Phone”, welche ebenfalls kostenlos verfügbar ist. Der primäre Einsatzzweck des Tools ist die regelmäßige, automatisierte Sicherung der wichtigsten Daten “in the cloud”. Hierfür stehen derzeit 200 MB auf den Servern von Microsoft zur Verfügung. Neben der übersichtlichen Archivierung und Sicherung von Daten wie Kalendereinträge, Kontaktdaten, Aufgaben, SMS, Favoriten, Fotos, Videos, Musik und Dokumente bietet die Software jedoch noch weitere Funktionen. Eine davon ist “Verloren gegangenes Telefon suchen”. Auch hier kann der letzte bekannte Ort des Telefons abgerufen werden (zur Zeit leider aber nur im US-amerikanischen Markt verfügbar). Weitere Funktionen sind das Anrufen des Telefons, bei dem es für eine Minute laut klingelt, selbst wenn es lautlos oder auf Vibrationsalarm gestellt wurde, Sperren des Telefons, bei dem man zusätzlich auch eine Nachricht eingeben kann die auf dem Bildschirm – bsp. für den ehrlichen Finder – angezeigt wird, und das Löschen des Telefons, bei dem sowohl Telefon als auch Speicherkarte gelöscht und somit auf die Werkseinstellungen zurückgesetzt werden.

Wird beispielsweise das Telefon angerufen, wird unabhängig sonstiger Einstellungen der aktuelle Klingelton in maximaler Lautstärke abgespielt und auf dem Display sieht man die Meldung “Sie haben mich gefunden. Mein Besitzer <hier steht die Live-ID / E-Mail> sucht nach mir.

Die zuletzt genannten Sonderfunktionen bezeichnet Microsoft als “Premiumfeatures”. Diese sind bei der erstmaligen Verwendung kostenlos, anschließend betragen die Kosten 4,89 EUR. Dabei wird als “Verwendung” das Ausführen von 3x Klingeln, 3x Auffinden, 1x Sperren und 1x Löschen angesehen und ein Premiumpaket ist nach der Bestellung 1 Woche lang gültig. Das klingt auf den ersten Blick nicht wirklich preisgünstig, andererseits können diese Funktionen auch die letzte Möglichkeit sein das verlorene Handy zurückzubekommen oder zumindest die persönlichen Daten zu löschen. Da alle Daten zusätzlich ja auch in My Phone online gesichert sind (und das bis auf die Datenverbindung des Handys kostenlos), ist nicht einmal ein größerer Datenverlust zu befürchten. Für mich also eine sehr gute Alternative zum getesteten Produkt von F-Secure und eine klare Empfehlung! Leider ist “My Phone” nur für Windows Mobile Geräte verfügbar und nicht, wie Anti Theft for Mobile, auch für Symbian und Android.

Artikel empfehlen auf .NET-Kicks Deutschland

Caching für Alle in .Net 4

17.06.2010 00:04:14 | Manfred Steyer

Das .NET-Framework enthält seit seinen ersten Tagen eine Cache-Implementierung – allerdings lediglich für Web-Applikationen. Um auch andere Applikationen von Caching-Mechanismen profitieren zu lassen, werden entsprechende Konstrukte ab Version 4 für sämtliche Applikationen über den Namespace System.Runtime.Caching in der gleichnamigen Assembly angeboten. Die damit bereitgestellte Implementierung ähnelt jener von ASP.NET und sieht zurzeit lediglich einen In-Memory-Cache (MemoryCache) vor. Weitere Cache-Implementierungen können jedoch durch Ableiten von der Basisklasse ObjectCache entwickelt werden.



Dieser Blogeintrag ist ein Auszug aus meinem aktuellen Buch .Net 4 Update.

Ein Beispiel für die Verwendung von MemoryCache findet sich im nachfolgenden Listing. Zunächst wird hier über die statische Eigenschaft MemoryCache.Default eine Referenz auf die global bereitgestellte Standard-Instanz von MemoryCache bezogen und versucht, über den Schlüssel someText einen gecachten String abzurufen. Konnte dieser nicht ermittelt werden, wird der Eintrag aus einer Datei gelesen sowie unter dem mit ihm assoziierten Schlüssel someText im Cache abgelegt. Im Zuge dessen wird auch eine CacheItemPolicy übergeben. Diese legt fest, wann der Cache-Eintrag wieder aus dem Cache entfernt werden soll. Dazu wird mit der Eigenschaft SlidingExpiration festgelegt, nach welchem Zeitraum, in welchem nicht auf das Element zugegriffen wird, dieses zu entfernen ist. Alternativ dazu kann mit der Eigenschaft AbsoluteExpiration eine absolute Zeitspanne, nach welcher der Eintrag entfernt werden soll, angeführt werden. Daneben bietet Priority vom Enum-Typ CacheItemPriority die Möglichkeit zu definieren, dass ein Eintrag gar nicht aus dem Cache entfernt werden soll. Dies wird mit dem Wert NotRemovable angezeigt. Zusätzlich zur SlidingExpiration wird auch ein ChangeMonitor vom Typ HostFileChangeMonitor registriert. Dieser überwacht die an den Konstruktor übergebenen Dateien und/oder Ordner auf Änderungen. Im Fall einer Änderung werden die mit der Policy assoziierten Einträge aus dem Cache entfernt. Neben dem HostFileChangeMonitor existiert auch ein SqlChangeMonitor, welcher eine Instanz der seit .NET 2.0 verfügbaren Klasse SqlDependency kapselt und diese zur Überwachung von Änderungen in einer SQL Server-Datenbank (ab Version 2005) verwendet. Weitere derartige Mechanismen können durch Ableiten von der Basisklasse ChangeMonitor oder einer deren Subklassen bereitgestellt werden.

const string source = @”c:\temp\someTextFile.txt”;
ObjectCache cache = MemoryCache.Default;
string fileContents = cache[”someText”] as string;

if (fileContents == null)
{
Console.WriteLine(„Element war nicht (mehr) im Cache!“);
CacheItemPolicy policy = new CacheItemPolicy();
policy.SlidingExpiration = TimeSpan.FromSeconds(50);

List<string> filePaths = new List<string>();
filePaths.Add(source);
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));

fileContents = File.ReadAllText(source);
cache.Set(“someText”, fileContents, policy);
}
Console.WriteLine(fileContents);

Um die verwendeten Caches über die Applikationskonfigurationsdatei anpassen zu können, kann jeder Instanz von MemoryCache ein Name spendiert werden. Der Name der im letzten Listing verwendeten Standard-Instanz lautet auf Default. Weiteren Instanzen kann, nachfolgend gezeigt, über den Konstruktor ein Name zugewiesen werden. Dabei gilt zu beachten, dass es verschiedene Instanzen mit demselben Namen geben kann.

In der Applikationskonfigurationsdatei können diesen Namen Konfigurationseigenschaften zugewiesen werden. Im nachfolgenden Listing wird beispielsweise für den Cache mit dem Namen MyCache festgelegt, dass dieser max. 10 MB einnehmen soll (cacheMemoryLimitMegabytes) bzw. max. 15 % des physikalischen Speichers (physicalMemoryLimitPercentage) sowie dass in Intervallen von einer Minute (pollingInterval) geprüft werden soll, ob diese Grenzen überschritten wurden. Als Alternative zur Definition dieser Parameter über die Applikationskonfiguration besteht auch die Möglichkeit diese in Form einer NameValueCollection an den Konstruktor von MemoryCache zu Übergeben.


private static MemoryCache cache;
private static void CacheDemo2()
{
const string source = @”c:\temp\someTextFile.txt”;
if (cache == null) cache = new MemoryCache(“MyCache”);
string fileContents = cache[”someText”] as string;
if (fileContents == null)
{
Console.WriteLine(„Element war nicht (mehr) im Cache!“);
CacheItemPolicy policy = new CacheItemPolicy();
List<string> filePaths = new List<string>();
filePaths.Add(source);
policy.ChangeMonitors.Add(new HostFileChangeMonitor(filePaths));
policy.SlidingExpiration = TimeSpan.FromSeconds(50);

fileContents = File.ReadAllText(source);
cache.Set(“someText”, fileContents, policy);
}

Console.WriteLine(fileContents);
}


<system.runtime.caching>
<memoryCache>
<namedCaches>
<add name=”MyCache”
cacheMemoryLimitMegabytes=”10”
physicalMemoryLimitPercentage=”15”
pollingInterval=”00:01:00” />
</namedCaches>
</memoryCache>
</system.runtime.caching>

Buildautomation mit Hudson in der dotnetpro

16.06.2010 21:11:00 | Jan Christian Selke

Mit etwas stolz habe ich gesehen, dass der Artikel Bitte ein Build! Software automatisiert mit Hudson bauen, den ich gemeinsam mit meinem Kollegen André Krämer geschrieben habe, in der aktuellen Ausgabe 07/2010 der dotnetpro erschienen ist.

dnp_072010

Wir stellen einen im .Net Umfeld eher unbekannten Vertreter der Buildserver vor: Hudson. Weit verbreitet in der Java Welt stellt er als OSS auch eine mächtige und kostengünstige Alternative zu Buildservern wie dem TFS oder CruiseControl.Net dar.

Also, lesen… ;-)

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

16.06.2010 21:05:38 | Jan Schenk

Get Microsoft Silverlight

 

Die zehnte Ausgabe von msdn tv in diesem Jahr widmet sich dem Thema Open Source und der spannenden Frage, wie es denn Microsoft damit hält. Kompetenter Gesprächspartner von Moderator Jan Schenk ist diesmal James Utzschneider, General Manager Open Source bei Microsoft.
Vorab geht‘s in den Kurznachrichten u.a. um die englischsprachige Version 4 von Expression Studio, die ab sofort als Download erhältlich ist und gleich mehrfach um nützlichen Lesestoff für Programmierer: einmal um einen Leitfaden, der bei Auswahl der passenden Visual Studio 2010 Edition weiterhilft und um das neue Evaluierungshandbuch für SharePoint 2010-Entwickler von Microsoft, das im Downloadcenter kostenlos abgerufen werden kann. Dort, im Microsoft Downloadcenter, steht auch die jüngste Fassung der „Windows Azure Tools for Visual Studio 1.2” zum herunterladen bereit.
P.S.: Wer bis zu den Outtakes durchhält, wird noch mit einem bizarren Themenreigen belohnt: Schluckauf, Katzen und sonderbares deutsches Liedgut. Damit tritt unser begnadeter Frontman Jan Schenk wohl endgültig in die Fußstapfen seines berühmten Namensvetters und TV-Urgesteins Heinz.


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.

Einladung zum Treffen der .NET Usergroup Dresden am 21.07.2010

16.06.2010 20:54:00 | Martin Hey

Nach einer durch die Fußball-Weltmeisterschaft bedingten Pause, findet das nächste Treffen der .NET Usergroup am 21. Juli 2010 um 18:00 Uhr im Erdgeschoss der T-Systems MMS statt.

Auch an diesem Abend gibt es wieder zwei interessante Präsentationen:

Dynamic Linq von Martin Hey
Anhand eines Beispieles zeige ich, wie man zur Laufzeit Expression-Trees für Linq-Abfragen erstellt, die man dann zur dynamischen Filterung und Sortierung von Objekten verwenden kann. Diese Präsentation musste ja leider aufgrund von Krankheit Anfang des Jahres verschoben werden und wird jetzt nachgeholt.

Buildmanagement & Branching/Merging Strategien mit dem TFS von Robert Mühsig
Anhand eines Real Life Projektes, welches aus Windows Diensten, Webservices & ASP.NET Applikationen besteht, zeigt Robert die Verwendung der Team Builds vom Team Foundation Server. Nightly Deployments, Continous Integration und der Einsatz von MSBuild zum Bauen von Paketen werden zusammen mit der Branching & Merging Strategie, die sich in diesem Projekt bewährt haben, vorgestellt.

Wer teilnehmen möchte, trägt sich bitte in die Teilnehmerliste in Doodle oder im Xing ein, damit wir die Raumplanung entsprechend vornehmen können.

See# Party - .NET-Community Konferenz am Bodensee

16.06.2010 03:41:00 | Jürgen Gutsch

Kurz vor dem 20. Treffen veranstaltet der .NET-Stammtisch Konstanz-Kreuzlingen eine .NET-Community Konferenz in Kreuzlingen am Bodensee mit dem Ziel auch hier in der Region eine günstige und nahe alternative zu den großen, herkömmlichen Konferenzen zu bieten.

Bei der Planung ist eine Konferenz am Bodensee mit dem passenden Namen “See# Party” entstanden.

Die See# Party findet am 28. August 2010 im DREISPITZ Sport- und Kulturzentrum in Kreuzlingen (CH) statt.

Die Anmeldung für bis zu 250 Teilnehmer startet am 01. Juli 2010

Wer einen eigenen Vortrag einreichen möchte, kann gerne mit uns Kontakt aufnehmen und uns die Vorschläge per E-Mail zusenden. Mehr Informationen zu den einzureichenden Vorträgen sind hier zu finden: Call for Papers

Um die Teilnahme für alle so günstig wie möglich zu machen, sind wir auf die Unterstützung durch Sponsoren angewiesen. Wer die See# Party in irgendeiner Art unterstützen möchte findet auf der Seite “Sponsor werden” die nötigen Hinweise.

Bis jetzt bin ich sehr zufrieden mit dem gestrigen Start:

  • Golo Roden hat sich bereit erklärt die Keynote zum Thema ALT.NET zu halten
  • Die ersten Sprecher haben Ihre Vorschläge eingereicht
  • Die ersten möglichen Sponsoren und Medienpartner haben bereits zusagen gemacht
  • Die Resonanz per Facebook, Twitter und auch XING übersteigt meine Erwartungen
  • Das CMS add.min arbeitet hervorragend (und ist schneller als ich es in Erinnerung hatte)

Natürlich haben wir uns ein sehr, sehr engen Zeitplan gesetzt. Allerdings läuft es bis jetzt hervorragend mit der Planung. Dabei halfen die nötigen Verbindungen und natürlich auch ein kleines bisschen Glück.

Dank großes Dankeschön geht vorab schon mal an die vielen motivierten Helfer und auch an die Firma K&K Internet GmbH die uns als Hosting-Sponsor zur Seite steht und uns das CMS add.min zur Verfügung gestellt hat.

DotNetKicks-DE Image

Anonymen Zugriff in SharePoint mit PowerShell aktivieren

15.06.2010 16:42:00 | Martin Hey

Um auf einer Site Collection anonymen Zugriff zu aktivieren, sind mehrere Schritte notwendig: Zunächst muss in der Central Administration grundsätzlich der anonyme Zugriff auf der Webanwendung aktiviert werden.
Im Anschluss daran kann man auf den gewünschten Site Collections dieser Webanwendung definieren, ob hier die komplette Site Collection oder Listen anonym erreichbar sein sollen, oder ob dieses Feature ganz unterbunden wird.

Eine gute Beschreibung, wie man der Reihe nach vorgehen muss, um diese Einstellungen über die Weboberfläche vorzunehmen, findet man im Post von Randy Drisgill.

Was über die Benutzeroberfläche geht, geht auch über die PowerShell - dem Tool der Wahl für die Administration des SharePoint über die Kommandozeile, allerdings sind die Einstellungen gut versteckt.

Um die Einstellungen in der Central Administration per Kommandozeile durchzuführen, sind ist das Cmdlet GET-SPWebApplication von zentraler Bedeutung. Ist das passende Objekt vom Typ SPWebApplication dann ermittelt, kann man darüber die SPIisSettings ermitteln, in denen der anonyme Zugriff gesetzt werden kann. Laut MSDN ist im Anschluss noch ein Re-Provisioning notwendig, damit sämtliche Frontendserver aktualisiert werden.

Nach diesem Schritt kann in den gewünschten SPSiteCollections die Eigenschaft AnonymousState des RootWebs auf On gesetzt werden. Hier schlägt die in diesem Punkt gewöhnungsbedüftige Syntax der PowerShell zu, nach der sogenannte Nested Types (wie es SPWeb.WebAnonymousState ist) nicht mit dem ".", sondern mit einem "+" dargestellt werden.
Start-SPAssignment -Global;

# set anonymous access in webapp
$webapp = Get-SPWebApplication "http://myserver";
$webAppZone = [Microsoft.SharePoint.Administration.SPUrlZone]::Default;
$webappsettings = $webapp.GetIisSettingsWithFallback($webAppZone);
$webappsettings.AllowAnonymous = $true;
$webapp.Update()
$webapp.Provision()

# set anonymous access in website
$site = Get-SPSite "http://myserver/sites/mytest";
$web = $site.RootWeb;
$web.AnonymousState = [Microsoft.SharePoint.SPWeb+WebAnonymousState]::On;
$web.Update();

Stop-SPAssignment -Global;

Weiß man all diese Hürden zu umschiffen, hat man im Anschluss ein anonym zugreifbares Portal.

Hattrick!

15.06.2010 02:32:46 | Andre Kraemer

Passend zur Fußball WM konnte ich einen virtuellen Hattrick landen. Kürzlich ist nämlich mein dritter Artikel in Folge auf der deutschen ASP.NET Site http://www.asp.net/de veröffentlicht worden. Cool :-)

aspnet_de

Nachdem ich die Artikel des Tages nun also "gestürmt" habe, frage ich mich nur noch, wie ich mein Blog in den Feed links bekomme ...

Visual Studio ALM User Group: 2010: Scrum, TFS and Microsoft

15.06.2010 00:10:26 | Thomas Schissler

Aaron-Headshot-Sml.jpg

In diesem Monat möchte ich die Leser meines Blogs auch auf das US-Meeting der Visual Studio User Group aufmerksam machen, da dieses Treffen dieses mal zu einer auch für Europa günstiger Zeit stattfindet (Donnerstag 17. Juni 18:00 Uhr).

Das Thema ist Scrum, TFS und Microsoft. Aaron Bjork wird das neue Scrum Template von Microsoft vorstellen das er maßgeblich verantwortlich ist. Also Informationen aus erster Hand die man nicht verpassen sollte. Für Mitglieder gibt es ein Recording des Meetings im Nachgang auch zum Download.

Das neue “Team Foundation Server Scrum v1.0 Beta” Template kann man sich hier herunterladen: http://visualstudiogallery.msdn.microsoft.com/en-us/59ac03e3-df99-4776-be39-1917cbfc5d8e
Nähere Informationen zum Meeting gibt es hier: http://www.vsalmug.com/Meetings/Announcements/June-2010/June-17,-2010--Scrum,-TFS-and-Microsoft.aspx

Hattrick!

14.06.2010 23:32:46 | Andre Kraemer

Passend zur Fußball WM konnte ich einen virtuellen Hattrick landen. Kürzlich ist nämlich mein dritter Artikel in Folge auf der deutschen ASP.NET Site http://www.asp.net/de veröffentlicht worden. Cool :-)

aspnet_de

Nachdem ich die Artikel des Tages nun also "gestürmt" habe, frage ich mich nur noch, wie ich mein Blog in den Feed links bekomme ...



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

dotnet Cologne 2010: Silverlight für Windows Phone 7

14.06.2010 21:27:15 | Peter Nowak

Am 28.05.2010 findet die dotnet Cologne 2010 in Köln statt.

Die Veranstaltung selbst war einfach nur super. Es hat richtig Spaß gemacht dort den Vortrag zu “Silverlight für Windows Phone 7” halten zu dürfen. Nicht nur, dass der Raum fast überfüllt war, waren die Diskussionen zwischen den Teilnehmern sehr erfrischend.

Leider führte dies jedoch unter anderem auch dazu, dass ich den Stoff leider nicht komplett zeigen konnte. Aus diesem Grund gibt es an dieser Stelle die Slides und Samples zum Download.

Bitte beachtet, dass in den Samples eine Textdatei enthalten ist, welche weitere Informationen bietet.

Weitere Informationen zur dotnet Cologne findet Ihr hier.

PeNo_SL für WP7.zip (557,18 KB)

This posting is provided "AS IS" with no warranties, and confers no rights.

Auf geht es zum Office Community Day 2010

14.06.2010 13:27:00 | Lars Keller

Morgen startet der zweite Office Community Day! Einen Tag lang sprechen wir über Office & Sharepoint Entwicklung. Nachdem wir im letzten Jahr in Wien waren, findet dieses Mal der Office Community Day in München bei Microsoft Deutschland statt.

Ich freue mich sehr auf das Event und die vielen Gespräche rund um die Office Entwicklung. Mal schauen, ob wir den Teilnehmerrekord vom letzten Jahr in Wien brechen können.

Alle Kurzentschlossende können gern vorbei schauen, alle weiteren Informationen findet ihr hier.

 

btw: Passend zu dem Tag wird auch das neue MS Office 2010 an Endanwender verkauft werden!

Project Natal is now Kinect for Xbox 360

14.06.2010 11:25:31 | Damir Tomicic

Die gierig erwartete Xbox-Neuerung code name "Project Natal" bekam gestern Abend offiziell auf einer Pressekonferenz im Vorfeld der Electronic Entertainment Expo in Los Angelos den Namen "Kinect for Xbox 360". Die Erweiterung ermöglicht full-motion tracking des menschlichen Körpers bei 30 frames pro Sekunde und damit eine kontrollerfreie Steuerung der Xbox 360 Konsole. Kinect soll für 150 USD (gebundelt mit Xbox Arcade für 300 USD) im Oktober zu kaufen sein. Auch eine neue Xbox 360 mit 250 GB HD und WLAN wird erwartet ..

Eine ganze Reihe neuer Spiele wurde angekündig - die Standardverdächtigen, die man von der Wii bereits kennt (Kinect Sports, Kinect Adventures etc.) aber auch einige neue Spiele wie bspw. Star Wars (Zusammenarbeit mit Steven Spielberg) und Dance Central (Zusammenarbeit mit MTV Games). Die Analysten erwarten bis zu 10 Milliarden Umsatz pro Jahr in USA für die neue Konsolenerweiterung. Es bleibt spannend.

[1] http://www.microsoft.com/Presspass/Features/2010/jun10/06-13KinectIntroduced.mspx

NEW Version 3.6 TeamSpeak Sidebar Gadget für Windows Vista und Windows 7

12.06.2010 09:18:00 | Andreas Mehl

Version 3.6 released

  • NEW Added Direct Query Support for 32 bit Windows Systems
  • NEW Optimizied Direct Querys with the help of json.
  • NEW Direct Querys supports multicores.
  • NEW Direct Query Viewer shows Custom Icons with Title + Name.
  • NEW Direct Query Viewer new 16 x 16 Icons
  • NEW .NET 4.0 Framework is requiered for Direct Query Mode

 

Teamspeak 3 Sidebar Gadget

 

Screenshots can be found here: Screenshots

New Video can be found here: Video

Documentation can be found here: Documentation

Have fun Laughing

Download Sidebar Gadget Teamspeak 3.6

Team Foundation Server Scrum v1.0 Template Beta

11.06.2010 18:46:34 | Christian Binder

 

Zum RTM Download

Für Agile Teams hat Team Foundation Server das Prozess Template MSF for Agile Development, welches grundsätzlich die Anwendung von Scrum Mechanismen erlaubt.  Zusätzlich gibt es Jetzt gibt es auch die erste Beta eines neuen Scrum Templates, welches dann auch die Scrum Terminologien verwendet. Zum Download in der Visual Studio Gallery,

Team Foundation Server Scrum v1.0 Beta

 

Chris

Missing Developer Tab

11.06.2010 12:35:39 | Jens Häupel

Umsteiger von Office 2007 auf 2010 werden u.U. die Möglichkeit suchen, den developer Tab einzuschalten. Bei 2007 noch unter dem Stichwort “Show Developer Tab in Ribbon” zu finden, findet sich das Ganze in 2010 unter “Customize Ribbon” wieder.

Show Dev Tab

Neue WebCasts zu VSTO / Office 2010 Integration mit VS2010 verfügbar

11.06.2010 11:32:51 | Jens Häupel

Wenn man mit einem Achillessehnenriss zuhause sitzt, kann man nicht wirklich viel machen. Jedenfalls nichts, was mit viel Bewegung zu tun hat. Also habe ich mir Visual Studio und Office (Jeweils 2010) hergenommen und die neuen Möglichkeiten herausgearbeitet. Herausgekommen sind 3 WebCasts:

  1. Ribbon- und Backstage-Programmierung mit Visual Studio 2010 und Office 2010
    User Interface Integration in Office 2010 mit C# 4.0
  2. Deployment von Office 2010 Erweiterungen
    Part I: Grundlagen der Anwendungsverteilung
  3. Deployment von Office 2010 Erweiterungen
    Part II: Erweiterte Möglichkeiten der Anwendungsverteilung

Inzwischen ist die Sehne wieder halbwegs ganz und vielleicht sieht man sich ja auf dem Office Community Day nächste Woche.

Blog-Parade: Noch 11 Tage! Jetzt noch mitmachen!

11.06.2010 11:14:54 | Peter Kirchner

Freunde der Blog-Paraden,

dies ist eine Erinnerung, dass die 2. Blog-Parade nur noch elf Tage läuft! Momentan sind die Quoten für die Teilnehmer noch exzellent, eine der drei Xboxen zu gewinnen! ;-)

Hier noch einmal das Thema

Dieses Mal ist Ihre Kreativität gefragt! Wie Sie alle mitbekommen haben, ist das Thema Cloud Computing ein wesentlicher Bestandteil der zukünftigen Plattform von Microsoft. Aus diesem Grund wird das Thema dieser Blog-Parade sein, coole Ideen zu sammeln, was man alles mit Windows Azure machen kann. Ihrer Phantasie sind hier keine Grenzen gesetzt, ob es nun spezielle Web-Anwendungen sind oder Anwendungen, die sowohl lokal auf dem PC oder einem Windows Handy laufen, aber auch für innovative Funktionen, die die Cloud benötigen.

Alle Infos zur Blog-Parade und dem Gewinnspiel finden Sie im Start-Blogbeitrag. Hier finden Sie im Kommentarabschnitt auch schon die Links zu den Beiträgen der bisherigen Teilnehmer.

Keynote von James Utzschneider auf dem LinuxTag

10.06.2010 20:44:20 | Jan Welker

Der dritte und letzte Blogpost vom LinuxTag gibt einen kurzen Überblick über die Open Source Strategie vom Microsoft. James Utzschneider hat die Keynote gehalten, er ist Microsofts General Manager of Open Source. Er hat in gut 50 Minuten über das Umdenken in Sachen Open Source bei Microsoft referiert. Vor geschätzten 200 – 300 Linux-Freaks war das sicher keine leichte Aufgabe. Der Vortrag und die anschließende Fragerunde verliefen aber sehr sachlich und fair.

Linuxtag_4

Zum Einstieg der Keynote machte James folgendes Statement: „We have changed“ und untermauerte es mit drei Aussagen:

  • “We play well with others”. Zu dieser Aussage lieferte er ein knackiges Beispiel: Er hielt ein iPad in den Händen und erklärte, dass auf dem Gerät (höchstwahrscheinlich) keine Zeile Code von Microsoft läuft, jedoch kann das iPad Dokumente im Open XML Format lesen, welches von Microsoft ausführlich dokumentiert wurde und frei zugänglich ist.
  • “We listen to customers”. Beim Thema Interoperabilität hört Microsoft verstärkt auf die Stimmen der Kunden und verbessert die Zusammenarbeit von Microsoftprodukten und anderen Technologien. Dabei war ihm wichtig, dass die Zuhörer verstehen, dass Microsoft keine fremden Technologien kopiert sondern eine bessere Zusammenarbeit anstrebt.
  • Natürlich darf auch die Cloud nicht fehlen. Der dritte Punkt war “Open in the Cloud”. Microsofts Azure Plattform unterstützte von Anfang an, neben dem bekannten Microsoft Stack, Technologien wie zum Beispiel Ruby, PHP und Python.

Linuxtag_3

Folgend führte er einige Beispiele an, in denen die neue Strategie erfolgreich umgesetzt wurde. Als erstes sprach er über Windows 7. Es gibt derzeit geschätzte 4 Millionen Anwendungen, die auf Windows 7 laufen. Das diese reibungslos funktionieren, liegt unter anderem daran, dass unzählige offene Standards von Windows unterstützt werden. Microsoft hat aber nicht nur bestehende Standards implementiert sondern dokumentiert auch eigene Technologien, so das andere diese einsetzen können. Ein Beispiel hierfür ist HyperV, die Virtualisierungsplattform von Microsoft. HyperV ist im aktuellen Linux Kernel implementiert.
Als weiteres Beispiel für die neue Offenheit stellte James den Web Plattform Installer vor. Mit ihm können zahlreiche Webanwendungen einfach installiert werden. Zu den Webanwendungen gehören nicht nur Projekte, die auf dem Microsoft Stack aufbauen, sondern auch PHP Anwendungen wie zum Beispiel Wordpress oder Drupal. Als letztes von seinen Beispielen möchte ich Codeplex nennen, die Open Source Plattform von Microsoft. Auf dieser Plattform sind im Moment 3000 Windows-Projekte, 1500 Sharepoint-Projekte sowie 800 Projekte für den SQL Sever gehostet.

Microsoft ist und bleibt ein kommerzielles Unternehmen, das Geld verdienen will und so konnten folgende Fragen nicht positiv beantwortet werden:

  • Wird der nächste Internet Explorer Open Source?
  • Wird der nächste Internet Explorer auf dem Webkit basieren?

Was mir an der Keynote fehlte, war ein Blick in die Zukunft, z.B. welche neuen Projekte von Microsoft im Open Source Bereich geplant sind.

Der LinuxTag und der Ausflug in die Open Source Welt war für mich eine interessante Abwechslung zu den üblichen .NET Konferenzen. Dank einer sehr engagierten Usergroup konnte ich zum Beispiel auch neues über die Scriptsprache Perl lernen ;-)

Neue Folge von Silverlight-Expertise: “Statische Resourcen aus Assemblies” und “Popup-Hinweis zur unterstützen Bildschirmauflösung”

10.06.2010 18:51:26 | Gregor Biswanger

dotnet-magazin-logo

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

Silverlight-Expertise - Die Crème de la Crème des Monats

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 „Statische Resourcen aus Assemblies“ und „Popup-Hinweis zur unterstützen Bildschirmauflösung“. Viel Spaß und einen guten Appetit.

dotnet-magazin-07-2010

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

Beispielanwendungen für Windows Azure

10.06.2010 14:47:00 | Oliver Scheer

Wer sich näher für die Möglichkeiten der Windows Azure-Plattform von Microsoft interessiert, dem sind die beiden Beispielanwendungen PhluffyFotos com und Full Monte zu empfehlen. Erstere ist eine Galerie, bei der User die Möglichkeit haben, Fotos hochzuladen, diese zu tagen und für andere freizugeben. PhluffyFotos nutz dazu unter anderem .NET 4, ASP.NET MVC, SIlverlight, Windows Azure Tables, Blobs and Queues. Full Monte hingegen ist eine Monte Carlo Simulation für Windows Azure. Ziel der Anwendungen ist, Map/Reducing-Operationen in einer Anwendung im HPC-Stil zu demonstrieren. Verwendet werden unter anderem .NET 4, Windows Azure Worker Roles und Queues sowie der AppFabric Service Bus.

Link

Preise für Windows Azure Content Delivery Network (CDN)

10.06.2010 13:42:00 | Oliver Scheer

Das Windows Azure Content Delivery Network ermöglicht es Entwicklern, ihre Windows Azure Blob Storage-Daten in verschiedenen Datencentern auf der Welt zu sichern, um die Daten näher an die Nutzer zu bringen. Zurzeit sind 19 Center weltweit verfügbar, die auch von Angeboten wie Windows Update und Bing Maps genutzt werden. Ab 30. Juni 2010 kann man die finale Version des Service über drei verschiedene Preiskategorien nutzen: 0.15 US-Dollar pro Gigabyte für Datentranfers von Europa nach Nordamerika, 0,20 US-Dollar pro Gigabyte für Datentranfers von anderen Orten oder 0,01 US-Dollar pro 10.000 Transaktionen.

Ankunft auf dem LinuxTag

10.06.2010 13:36:10 | Jan Welker

pinguin_1 Wie gestern angekündigt, berichte ich heute vom LinuxTag. Am Empfang machte der LinuxTag einen sehr überschaubaren Eindruck. Neben einem kleinen Infostand und einem Shop, wo man Pinguin-T-Shirts kaufen konnte, wirkte das Foyer verlassen. Nach dem ich mich registriert hatte, ging es in die Halle 7 der Berliner Messe. Zu meiner Überraschung gibt es beim LinuxTag nicht nur Vorträge. In der Halle 7 ist eine recht große Ausstellung. Neben ein paar großen Firmen, wie Siemens, Oreilly und Microsoft gibt es Stände von Linux-Usergroups und von vielen kleinen IT Firmen. Auf fast allen PC’s der Aussteller läuft übrigens Windows XP. . .

In der Ausstellung sind zwei Bereiche, auf denen von verschiedenen Firmen Vorträge gehalten werden. Auf einer Vortragsfläche gibt es Vorträge zum Thema Open Source, auf der anderen Fläche gibt es Online Marketing Vorträge. Die Besucher fühlten sich ehr zu Vorträgen aus dem Bereich SEO und Landingpages hingezogen :-)

Linuxtag_2

Neue Version der Windows Azure Tools for Visual Studio

10.06.2010 10:34:00 | Oliver Scheer

Im Download Center von Microsoft stehen ab sofort due Windows Azure Tools for Visual Studio 1.2 kostenlos zur Verfügung. Die Erweiterung für Visual Studio 2010 und Visual Studio 2008 unterstützt Entwickler bei der Erstellung von Anwendungen für Windows Azure. Neuerungen in Version 1.2 sind unter anderem die Unterstützung für die finalen Versionen von Visual Studio 2010 und .NET Framework 4, ein Cloud Storage Explorer sowie IntelliTrace-Support für Services, die in der Cloud laufen.

Link

Tech∙Ed Europe 2010: Register and Save €500

10.06.2010 10:20:00 | Oliver Scheer

Tech∙Ed Europe is Microsoft’s premier technical education event providing the most comprehensive technical training on Microsoft’s suite of products, technologies, solutions and services. Attendees get deep technical content, hands-on learning experiences, and opportunities to connect with industry and Microsoft experts one-on-one. If you are a technology professional involved in building, deploying or maintaining IT solutions using Microsoft technologies, Tech∙Ed Europe is the conference that will help you solve today's real-world challenges and prepare you for tomorrow's innovations.
WHAT YOU'LL GET AT TECHED EUROPE 2010

  • Hear about the future of Microsoft’s products, technologies, solutions and services directly from Microsoft’s leaders
  • Choose from over 370 technical sessions delivered by Microsoft and industry experts
  • Participate in more than 150 Hands-on-Labs and Technical Learning Centres designed to give you practical experience with the latest tools and technologies
  • Network with Microsoft and industry experts, and fellow attendees that share your technology interests and business challenges
  • Plan the features and architecture to support your product and business goals to prepare your skills for the future

GET A JUMPSTART ON TECHNICAL LEARNING WITH PRE-CONFERENCE SEMINARS
Arrive early and get a jumpstart on your technical learning. Choose from eight pre-conference seminars delivered by Microsoft and industry experts, and selected to give you an edge on the latest technologies and topics.
Here’s just a sampling:

  • Architecting Cloud Scale Applications on the Windows Azure Platform
  • Microsoft Exchange Server 2010 High Availability and Disaster Recovery – Be Prepared
  • Successfully Deploying and Migrating to OCS 14
  • Windows Phone 7 Application Platform Technical Deep Dive
Seminars will start in the morning on 8 November, and end prior to the keynote presentation. Additional fees apply; conference attendees will receive a €100 discount on the pre-conference seminars. To view the full list of seminar titles, descriptions and speakers visit us online.

HTTP Compression nutzen

10.06.2010 09:47:34 | Rene Drescher-Hackel

Wer den Fiddler2 in Benutzung hat und sich diverse Auswertungen ansieht, stolpert sicher so wie ich über die Anzeige der Kompression der Webseite.
Kompression_1

Also stellte sich die Frage, wie ich nun diese Kompression aktiviert bekomme. Auf den Internetseiten von Microsoft findet man diverse Hinweise, wie das ganze sich am IIS einstellen lässt.

Visual Studio 2010 Pro Power Tools

10.06.2010 09:05:00 | Alexander Zeitler

Microsoft hat vor zwei Tagen die Visual Studio 2010 Pro Power Tools veröffentlicht.

Dieser erweitern Visual Studio 2010 unter anderem um folgende Features:

 

  • Colored Tabs
    Die Tabs in Visual Studio werden in unterschiedlichen Farben in Abhängigkeit des zugehörigen Projekts oder in Abhängigkeit von Regular Expressions mit frei definierbaren Farben dargestellt:
    Colored Tabs

  • Pinned Tabs
    Tabs können, wie von Windows 7 Jump Lists oder dem Docking Window von Visual Studio bereits gewohnt, fixiert werden:
    Pinned Tabs

  • Vertical Tabs
    Tabs können nun auch vertikal angeordnet werden:
    verticaltabs

  • Close Button sitzt rechts
    Einer der großen Diskussionspunkte in Visual Studio 2010: Der “Schließen”-Button für Tabs kann jetzt auch wieder ganz rechts platziert werden:
    Close Button

  • Neuer Dialog für “Add Reference” inkl. Suchfunktion
    Auch der Dialog, um Referenzen zu Projekten in Visual Studio 2010 hinzuzufügen, stand bereits mehrfach in der Kritik. Dieser wird durch einen neuen Dialog mit Suchmöglichkeit ersetzt:
    Add Reference

  • Strg+Klick zur vereinfachten Navigation im Code
    Mittels Strg+Mausklick gelangt man zur Definition des geklickten Objekts
    Strg + Click


Dies war nur eine kleine Auswahl der Verbesserungen, die die Visual Studio 2010 Pro Power Tools liefern. Auf der Projektseite in der Visual Studio Gallery sind alle neuen Funktionen aufgeführt.

Update: Im Blog von Jason Zander gibts noch mehr Details zu den Erweiterungen.

DotNetKicks-DE Image

VSTO 4: SparkLines per Code erstellen

10.06.2010 06:45:00 | Lars Keller

Mit dem neuen Excel 2010 wurden die SparkLines eingeführt, welche sich mit der neuen VSTO 4 Version programmieren lassen.

Was ist ein SparkLine und wie sieht dieses aus?

 SparkLines sind kleine Diagramme, die in einer einzelnen Excelzelle abgebildet werden.

SparkLines SparkColumnStacked100

 

 

 

 

 

Das Diagramm ist in der Spalte D zu erkennen und ist als SparkColumnStacked100 dargestellt.

sparkline_menu

SparkLines können ganz einfach über das entsprechende SparkLine-Tab optisch angepasst werden.


Doch wie erstelle ich diese per Code?

Das ist relativ einfach. Alles was dafür benötigt wird, ist ein Range-Objekt. Ein Range-Objekt ist ein definierter Bereich, welcher aus Zellen besteht. Es ist dabei egal, ob es aus mehreren Zellen oder nur aus einer Zelle besteht.

 Range sparklineRange = sheet.get_Range("D1");
SparklineGroup sparkline = sparklineRange.SparklineGroups.Add(XlSparkType.xlSparkColumnStacked100, "A1:C1");

Nachdem das Range-Objekt definiert wurde, wird diesem eine SparkLineGroups hinzugefügt. Eine SparkLine benötigt die Darstellungsart und die Datenquelle, aus welcher das Diagramm generiert werden soll. Die Darstellungsart kann aus drei verschiedenen Diagrammarten (Linien-, Säulen- oder Gewinn/Verlust-Diagramm) gewählt werden.

 sparkline.SeriesColor.ThemeColor = XlThemeColor.xlThemeColorAccent3;
sparkline.Points.Highpoint.Visible = true;
sparkline.Points.Firstpoint.Visible = true;
sparkline.Points.Negative.Visible = true;

 

Das SparkLine kann auch bspw. in der Graphenfarbe verändert werden. Alles was dafür getan werden muss, ist eine der entsprechenden XlThemeColor-Werte auszuwählen. Als ein weiteres optisches Detail kann festgelegt werden, dass die negativsten, ersten, letzten, etc. Werte eines SparkLines farblich gekennzeichnet werden.

So einfach lassen sich die SparkLines mit VSTO 4 programmieren. Zum Schluss ist hier ein komplettes lauffähiges Beispiel:

using System;
using Microsoft.Office.Interop.Excel;
using Office = Microsoft.Office.Core;
namespace ExcelWorkbook1
{
    public partial class Tabelle1    
    {
        private void Tabelle1_Startup(object sender, EventArgs e)
        {
            Worksheet sheet = Globals.ThisWorkbook.ActiveSheet as Worksheet;
            SetRow(sheet, 1, 1, 4, 6);
            SetRow(sheet, 2, 4, 1, 9);
            SetRow(sheet, 3, 1, -5, 3);
            Range sparklineRange = sheet.get_Range("D1");
            SparklineGroup sparkline = sparklineRange.SparklineGroups.Add(XlSparkType.xlSparkColumnStacked100, "A1:C1");
            sparkline.SeriesColor.ThemeColor = XlThemeColor.xlThemeColorAccent3;
            sparkline.Points.Highpoint.Visible = true;
            sparkline.Points.Firstpoint.Visible = true;
            sparkline.Points.Negative.Visible = true;
            sparklineRange.Copy(sheet.get_Range("D2:D3"));
        }

        private void Tabelle1_Shutdown(object sender, EventArgs e)
        {
        }

        private void SetRow(Worksheet sheet, int row, params int[] values)
        {
            for (int x = 0; x < values.Length; x++)
            {
                sheet.Cells[row, x + 1] = values[x];
            }
        }   
        #region VSTO Designer generated code
        ///  
        ///  Required method for Designer support - do not modify
        ///  the contents of this method with the code editor.  
        ///  
        private void InternalStartup()
        {
            Startup += Tabelle1_Startup;  
            Shutdown += Tabelle1_Shutdown;
        }       
        #endregion   
    }
 }

Microsoft auf dem LinuxTag

09.06.2010 22:00:30 | Jan Welker

Linuxtag_1 In Berlin findet vom 9.-12. Juni 2010 der LinuxTag statt, diese Veranstaltung wird vom LinuxTag e. V durchgeführt und hat den Themenschwerpunkt Linux und freie Software.
Entstanden ist die Veranstaltung aus sogenannten Installationspartys, bei denen sich Linux-Anwender treffen, um gemeinsam das alternative Betriebssystem zu installieren.
In Berlin gibt es den LinuxTag schon seit 1996 und ist Europas führender Treff für Linux und Open Source.

Was macht Microsoft auf dem LinuxTag?

Microsoft tritt auf diesem Event in zwei Rollen auf, zum einen als Partner bzw. Sponsor und zum anderen ist James Utzschneider Sprecher der Keynote am 10. Juni.
James Utzschneider ist der General Manager für Open Source bei Microsoft und leitet ein Team, welches verantwortlich ist für die weltweite Vermarktung von Microsofts Bemühungen im Open Source Bereich.

Das Microsoft sich in den letzten Jahren immer mehr in den Open Source Bereich eingebracht hat, war nicht zu übersehen. Bestes und aktuellstes Beispiel ist die Aussage von Microsoft, wonach sämtliche Entwickleraktivitäten aus dem ASP.NET Ajax Framework in das jQuery-Projekt verlagert werden.

Ich höre mir morgen in Berlin die Keynote von James Utzschneider an und werde hinterher die Gelegenheit haben, ihn persönlich zu sprechen. Alle Fakten über Microsofts zukünftige Open Source Strategie wird es dann morgen, hier im Blog zu lesen geben.

Stay tuned..

Reports mit Parameter aufrufen

09.06.2010 12:08:42 | Thomas Schissler

Kurzbeschreibung: Dieser Artikel beschreibt, wie Parameter an Reports über die URL übergeben werden können um so über Links oder im SharePoint Dashboard Reports bereits mit voreingestellten Parametern aufzurufen und so z.B. den Burndown eines spezifischen Sprints zu erhalten ohne die Parameter jedesmal von Hand einstellen zu müssen.

Im Team Foundation Server werden sie SQl Server Reporting Services (SSRS) genutzt um Reports zu generieren. Diese Reports geben schnell Auskunft über den aktuellen Status eines Projektes. Ein gutes Beispiel für einen solchen Report ist ein Burndown-Chart:

image

Solche Reports können sehr einfach aus dem SharePoint Portal oder aus dem TeamExplorer aufgerufen werden.

image

Nachteil an dieser Methode ist, dass bei jedem Aufruf die entsprechenden Parameter eingestellt werden müssen oder das Report Template immer an den aktuellen Sprint angepasst werden muss. Glücklicherweise unterstützen die SSRS die Übergabe von Parametern in der URL, so dass man sich sehr einfach Links generieren kann die den Report bereits vorkonfigurieren. Hierzu ruft man folgende URL auf:

http://<Reportserver URL oder IP>/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2f<Project Collection Name>%2f<Tem Project Name>%2f<Ordner>%2f<Report Name>&rs%3aCommand=Render

In meinem Fall sieht das so aus:

http://myReportServer/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2fartisoProjects%2fReportingDemo%2fProject+Management%2fBurndown+and+Burn+Rate&rs%3aCommand=Render

Damit können wir zunächst mal den Report direkt aufrufen. Nun können wir noch ein paar Parameter übergeben. Dazu müssen wir wissen wie die Parameter heißen. Dies kann man am einfachsten rausfinden indem man den Report über das SSRS Frontend aufruft und zwar über

http://<Reportserver URL oder IP>/Reports

und dann zu dem entsprechenden Report navigiert.  Die Seite die man nun erhält sieht ungefähr so aus:

image

Unter Eigenschaften / Parameter werden nun alle Parameter mit ihrem Namen angezeigt:

image

Wir wollen nun z.B. das Start- und Enddatum in unserer URL setzen. Dazu ergänzen wir die URL von oben einfach:

http://myReportServer/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2fartisoProjects%2fReportingDemo%2fProject+Management%2fBurndown+and+Burn+Rate&rs%3aCommand=Render&StartDateParam=28.05.2010&EndDateParam=10.06.2010 >

Damit wird bereits das Start- und Endedatum korrekt gesetzt. Nun wollen wir noch die Iteration setzen. Hier ist die Geschichte nicht ganz so trivial, da der TFS recht kryptische Angaben zum Iteration-Pfad erwartet. Das liegt daran, dass das Warehouse Daten aus mehreren Project Collections enthält und vor allem bei einem Rebuild die IDs unverändert bleiben sollen. Diesen Parameter kann man auf verschiedene Arten ermitteln, der mit dem geringsten Vorbereitungsaufwand soll hier kurz beschrieben werden.

Dazu ruft man zunächst das SQL Server Management Studio auf und verbindet sich zu den Analysis Services. Hier erstellt man nun eine neue MDX-Query.

image

Dann wählt man im Feld “Cube” den Eintrag “Work Item” aus und geht im Baum unter Work Item \ Work Item.Iteration Hierarchy \ Iteration<n> wobei n die Hierarchieebene ist auf der sich die gesuchte Iteration befindet.

image

Die gewünschte Iteration zieht man nun per Drag & Drop auf die rechte Seite des Fensters und bekommt dort die ID der Iteration.

image

Diese muss jetzt noch URL-Encodiert werden. Dazu kann man beispielsweise den URLEncoder (http://code.msdn.microsoft.com/URLEncoder/Release/ProjectReleases.aspx?ReleaseId=3629) verwenden.

Damit sieht die IterationID nun so aus:
%5BWork%20Item%5D%2E%5BIteration%20Hierarchy%5D%2E%5BIteration1%5D%2E%26%5B%2D6991474436272448184%5D%26%5B%2D8595730757606272101%5D

Diese können wir nun als Parameter in unsere URL einfügen:
http://myReportServer/ReportServer/Pages/ReportViewer.aspx?%2fTfsReports%2fartisoProjects%2fReportingDemo%2fProject+Management%2fBurndown+and+Burn+Rate&rs%3aCommand=Render&StartDateParam=28.05.2010&EndDateParam=10.06.2010&IterationParam=%5BWork%20Item%5D%2E%5BIteration%20Hierarchy%5D%2E%5BIteration1%5D%2E%26%5B%2D6991474436272448184%5D%26%5B%2D8595730757606272101%5D

Damit bekommen wir alle Parameter wie gewünscht befüllt.

image

Über zusätzliche Parameter können wir nun das Parameterfeld und den Toolbar auch noch ausblenden. Dazu fügen wir noch die Kommandos &rc:Parameters=false&rc:toolbar=false an unsere URL an. És gibt noch eine ganze Reihe weiterer Commands, über die z.B. auch das Ausgabeformat gesteuert wreden kann. Eine genauerer Beschreibung der Commands findet sich hier: http://technet.microsoft.com/en-us/library/ms152835.aspx.

Damit können wir nun den Report schon über einen einfachen Link aufrufen. Um den Report in unser SharePoint Dashboard einzubauen sind jetzt nur noch wenige Schritte erforderlich. Dazu fügen wir in unser Dashboard zunächst ein Page Viewer Web Part ein.

image

In der Tool Pane können wir nun die URL für den Report angeben.

image

Damit lassen sich nun schöne Dashboards im SharePoint aufbauen die alle Reports bereits voreingestellt enthalten. Für einen neuen Sprint nutzt man dann die Funktion “Copy Dashboard” und passt die Parameter in den URLs entsprechend an.

image

Weitere Hinweise:

Manche Parameter lassen auch eine Mehrfachselektion zu. Diese können ebenfalls in der URL übergeben werden indem einfach der selbe Parameter mit unterschiedlichen Werten angegeben wird.

Weitere Links:

URL Parameter für SSRS: http://technet.microsoft.com/en-us/library/ms153586.aspx
Viewer Commands: http://technet.microsoft.com/en-us/library/ms152835.aspx
Parameter Prefixes: http://technet.microsoft.com/en-us/library/ms153579.aspx

Neues aus der Office-Welt

09.06.2010 11:25:00 | Jens Häupel

Am 14. (Karlsruhe) 15. (Düsseldorf/Neuss)  und 23. (München) Juni findet der TechDay Spezial zum Thema “Von der Schreibmaschine zur Integrationsplattform” statt. Unter anderem mit Live Demos meiner Kollegen Daniel Melanchthon und Steffen Krause.

 

Lust auf noch mehr SharePoint? Dann melden Sie sich zur ShareConf (22.-24. Juni) an. Sie erwarten interessante Vorträge bzw. Workshops (22.6.) zu SharePoint 2010, u.a. mit unserem MTC Architekten Sven Maier.

 

Office 2010 hat nun seine eigene neue Webseite.

Off2010

 

Für den Office Community Day am 17. Juni in München/Unterschleißheim gibt es noch ein paar Freie Plätze. Es geht hier um die Entwicklung von Office Business Anwendungen mit VSTO, Open XML und SharePoint.

Windows Phone 7: Ein kurzer Rundumblick für Entwickler

09.06.2010 08:04:26 | Peter Nowak

Windows Phone 7 ist nun auch schon seit einigen Tagen bekannt. Wer jedoch einmal in “Kürze” einen etwas umfassenderen Überblick für Entwickler haben mag, sollte sich folgenden Onlineartikel von mir auf mobile360.de einmal zu Gemüte führen.

Inhalte sind neben einem kurzen Überblick der Geräte- und Betriebssystemfunktionen auch das Anwendungsmodell, sowie die Plattformarchitektur. Auch das Thema Metro wird hier kurz angerissen.

Happy reading.



This posting is provided "AS IS" with no warranties, and confers no rights.

Microsoft® Visual Studio® 2010 Visualization and Modeling Feature Pack

08.06.2010 20:15:01 | Christian Binder

VC++ Directories mit Visual Studio 2010

08.06.2010 17:56:32 | Christian Binder

Wer wie in VS 2008 seine VC++ Directories konfigurieren möchte, findet in VS 2010 folgenden Dialog:

clip_image001

Wer aber dennoch User spezifische Pfade verwenden möchte, die nicht in den Properties der Solution abgelegt werden, kann diese mit dem Property Manager in Microsoft.cpp.Win32.user eintragen. Diese gelten dann für den User und sind nicht Projekt spezifisch.

image

Und hier dann Eintragen:

image

Ich hoffe das spart Zeit :-)

Chris

WM 2010 Webslice für Internet Explorer verfügbar

08.06.2010 14:29:30 | Oliver Scheer

Jetzt kann die WM kommen. image Rufen Sie die neuesten WM-Nachrichten und Spielstände aus dem Internet von unterwegs aus ab. Lesen Sie Neuigkeiten zu Spielen in Echtzeit im Browserfenster. Dank dieses praktischen Internet Explorer Webslice.

Link

BizSpark Camps im Juni!

07.06.2010 18:16:00 | Peter Kirchner

clip_image002Wir freuen uns sehr, Sie zusammen mit Netzwerkpartnern zu unseren BizSpark Camps in München, Berlin und Köln im Juni einzuladen!

Wir sind stolz, namhafte Vertreter der Deutschen Startup-Szene vor Ort begrüßen zu können, die spannende Ausblicke auf die Zukunftstrends der Technologiewelt geben. Darüber hinaus erhalten Sie Informationen von Microsoft Experten zu Gründerangeboten, hören Neuigkeiten zu Windows Phone 7 und heben ab in die Cloud – und das Ganze kostenlos!
Eine Übersicht aller Referenten finden Sie im Anhang.

Neben den Vorträgen wird es Gelegenheit geben, bei Getränken und Snacks sich mit anderen Startups, Netzwerkpartnern und Experten auszutauschen und zu “networken”.
Und natürlich haben wir auch an alle Fußballfans gedacht: ab 20:30 Uhr werden wir live ein WM Fußballspiel zeigen und in der Halbzeitpause wartet auf einen glücklichen Gewinner eine Xbox 360 inkl. FIFA Fußball Weltmeisterschaft Südafrika 2010 Spiel!

Wir würden uns freuen, wenn Sie auch Ihre Kollegen und befreundete Startups aus der Szene zu diesen Events einladen und mitbringen.

Melden Sie sich gleich zum BizSpark Camp in Ihrer Nähe an!

München: 15. Juni 2010 | Zur Agenda München
Berlin: 17. Juni 2010 | Zur Agenda Berlin
Köln: 24. Juni 2010 | Zur Agenda Köln

Webcast Serie – Silverlight in Deep - Silverlight als CMS verwenden

07.06.2010 11:43:53 | Gregor Biswanger

Ab heute gibt es den letzten Teil zu meiner Webcast-Serie – Silverlight in Deep. Die Serie besteht aus 5 Teilen und ist für fortgeschrittene Silverlight Entwickler.

Überblick der Serien „Silverlight in Deep“:

Teil 1 – AOP in Silverlight
Teil 2 – Das MVVM in Silverlight
Teil 3 – Das Testen von Silverlight Anwendungen
Teil 4 – Microkernel Unity in Silverlight
Teil 5 – Silverlight als CMS verwenden

http://www.microsoft.com/germany/msdn/webcasts/serien/MSDNWCS-0907-04.mspx

Silverlight als CMS verwenden

Bei Silverlight-Anwendungen können jederzeit neue Inhalte dazukommen. Umso ärgerlicher wird es, wenn die Anwendung zu wenig Flexibilität dafür bietet. Wünschenswert wäre eine Art Content Management System (CMS) für Silverlight. Hier kann "Reflection" weiterhelfen. Das Praktische an dieser Anwendung ist, dass jederzeit neue Pages hinzugefügt werden können, dafür aber kein anderer Code angepasst werden muss. Einzige Bedingung: die Definition der Page mittels Attribute. Dieser Webcast baut anhand eines Live-Coding-Beispiels eine einfache Silverlight-Anwendung mit CMS-Funktionalität auf.

 

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

 

Über weiteres Feedback zum Webcast freue ich mich jetzt schon.

Tag-Cloud Generator in Silverlight - Tagxedo

07.06.2010 10:21:00 | Oliver Scheer

Ist das cool? Einen Tag-Cloud Generator in Silverlight.

image

Link: www.tagxedo.com

Die Chronik eines Projektes

06.06.2010 11:49:27 | Nico Franze

Es war ein sehr aussichtsreiches Projekt. Vielversprechend, anspruchsvoll, innovativ und zukunftssicher, alles in .NET. Die entstehende Software sollte weltweit eingesetzt werden. Klasse... Wer träumt nicht von solch einem Projekt. Die beteiligten Entwickler sind fähige Leute im .NET-Umfeld. Sie können jedes Problem lösen. Das Projekt begann auf einer grünen Wiese. Sprich, man konnte alles selbst designen, planen und entwickeln. Es gab kaum technische Vorgaben.

Heute redet man über dieses Projekt nur noch mit Anwälten und versucht so viel Schadensersatz wie möglich herauszuholen. Alle sind enttäuscht, jeder sucht bei jedem die Schuld und alle sind unzufrieden… Was war passiert????

Die Entwickler sind fähige Leute, die in .NET alle möglichen Probleme lösen können. Technisch gesehen war das Projekt also handhabbar. Bei diesem Projekt arbeiten die Entwickler direkt mit dem “Kunden”. Diese Entwickler bzw. Programmierer sind normalerweise Angestellte, die von irgendeinem Projektleiter gesagt bekommen, was sie machen sollen und vllt. auch wie sie es machen sollen. Das oben angesprochene Projekt war ein Projekt auf selbstständigen Basis mit direktem Kundenkontakt… Und da ist auch schon das erste Problem.. Der “Kunde”. Eine ominöse Person oder Institution, die viele tolle Ideen hat aber leider oft nicht selbst genau weiß, was sie will. Wenn dann noch die eigentliche Leitung des Projektes gänzlich versagt, ist das Projekt zum Scheitern verurteilt… Egal wie gut die Entwickler sind. Ab einer bestimmten Größenordnung eines Projektes ist eine gute strukturierte Planung einfach unabdingbar. Ansonsten weiss niemand, was er machen soll. Die Entwickler sind Anfangs super motiviert und bauen und machen was das Zeug hält.. Obwohl der Kunde mehrfach pro Monat ein Release erhält, kommt erst nach langer langer Zeit heraus, dass das meiste, was die Entwickler tolles gebaut haben, gar nicht das ist, was der Kunde wollte. Wie kann sowas passieren? Hat sich der Kunde das alles nicht angeschaut? Oder gab es einfach nur zu wenig oder falsche Kommunikation? Hat der Kunde gedacht, “Na die Entwickler da machen das schon…”?

Ich wurde in das oben genannte Projekt geholt, weil die Anforderungen die Entwicklungskapazitäten überstiegen. Schon nach ein paar Tagen habe ich moniert, dass die Prozesse in diesem Projekt äußerst ungünstig ablaufen und dass das später zu großen Problemen führen kann. Der Kunde, der eigentlich nur Mittelkunde ist, redet ab und zu mit dem echten Endkunden (eine große Firma) und redet dann wieder ab und zu mit den Entwicklern. Natürlich alles via MSN. Ich sagte, Leute, lasst uns Dokumente erstellen, wo wir explizit aufschreiben, was wir entwickeln werden. Lasst uns aufschreiben, wie wir die Aufgabenstellung verstanden haben. Wenn der Kunde das nochmal gegenliest, dann kommen vllt. hier und da noch Dinge heraus, die wir übersehen oder falsch verstanden haben. Ich bekam als Antwort: “Nico, für Dokumente haben wir keine Zeit. Wir arbeiten agile. Da braucht man keine Dokumente. Die sind im Moment des Schreibens schon veraltet.” Ja. Da ich nur nebenläufiger Entwickler war und kein Projektleiter, habe ich zwar immer wieder betont, dass ich denke, dass diese Arbeitsweise irgendwann ein Nachspiel haben wird, habe mich aber noch den Prozessen (falls man es so nennen kann) untergeordnet und habe einfach nach besten Wissen und Gewissen entwickelt.

Ich schreibe diesen Blog-Eintrag, weil ich euch allen einen Rat aufgrund dieser Erfahrungen geben möchte. Es mag vllt. komisch klingen, aber es ist ein gewisser Lernprozess, mit dem Phänomen “Kunde” umzugehen. Das bedeutet: es gibt unterschiedliche Arten von Kunden. Die einen kommen mit einem 800-Seiten Pflichtenheft an, was entweder die IT-Abteilung oder andere IT-Spezialisten entwickelt haben. Dieses Pflichtenheft beantwortet alle Fragen und man braucht einfach nur noch losentwickeln. Dies ist sehr schön, aber auch sehr selten der Fall.

Die gänzlich andere Art von Kunden stellt sich hin und sagt: “Herr Franze, ich habe hier dieses Problem. Machen sie, dass es geht!” Dieses Satz “Machen Sie, dass es geht” habe ich schon öfter gehört. An dieser Stelle muss man wieder unterscheiden.

Die einen meinen damit, dass sie nur das Problem kennen, aber keine Ahnung haben, wie die Lösung aussehen könnte. Dafür bin ich ja dann da. Ich (respektive ihr, die das hier lest) seit die Entwickler der Lösung. Das bedeutet, dass ihr nicht einfach nur irgendein kleines Progrämmchen programmiert, ihr versetzt euch in die Lage des Kunden, versteht ihn und sein Problem und entwickelt mit ihm gemeinsam eine Lösung.

Die anderen meinen mit diesem Satz, dass sie glauben, wie die Lösung aussieht, und wenn sie selbst ein wenig C# oder VB könnten, könnten se das schnell selbst programmieren. Dass da vllt. ein Jahr Entwicklungszeit dahinter steht und man nebenbei noch Client-Server-Wissen sowie Datenbank-Knowhow braucht, weiß natürlich am Anfang keiner. Der Kunde steht eigentlich schon am Ziel und denkt, dass er uns Entwickler mit einigen kurzen Sätzen auch zum Ziel bringen kann. Damit wir die entsprechende Lösung genauso bauen können, wie er sich das vorstellt. Leider klappt das nur oft so nicht, weil der Kunde vllt. keine technische Erfahrung hat oder oft aneinander vorbeigeredet wird. Der Kunde ist am Ziel und wundert sich, dass wir (der Entwickler) da nicht auch einfach ankommen…

Zusammenfassung:

Was ich damit sagen möchte ist das Folgende. Wenn ihr ein Projekt für einen Kunden entwickelt, (ich rede hier nicht von Hello-World-Applikationen, sondern vllt. mit Client, Server und Datenbank und mit einer Dauer von ca. einem Mann-Jahr), dann versucht strukturiert vorzugehen. Das bedeutet, setzt euch hin und plant und entwickelt das Projekt, vorerst so weit es geht auf dem Papier (oder in Word oder so). Diese Dokumente bilden eine gemeinsame Basis. Der Kunde erklärt euch irgendwas. Ok, nehmt das mit ins Dokument auf, so wie ihr es verstanden habt. Wenn der Kunde das später noch einmal liest, dann sagt er vllt. “Ähh, so hab ich das aber nicht gemeint… Das sollte doch so und so sein..”. Wenn der Kunde keine Lust hat, das Dokument nochmal zu lesen, dann kann euch niemand einen Vorwurf machen. Ich sage nicht, dass ein solches Dokument immer 100%ig vollständig und korrekt ist (das ist es nie), aber es gibt doch schon viele Dinge, die im Vorfeld auffallen können und die man auch einfach schon auf dem Papier durchdenken kann. Vor allem Dinge, die nur nebenbei erledigt werden müssen, aber trotzdem essentiell sind. Zum Beispiel Tests, oder ein ordentliches Setup-Paket. Wie wird die Software später installiert? und wie kommen Initialdaten in die Datenbank? Wie ist der Ablauf im Programm. Von welchen Masken aus kommt man auf welche und wann sind wie welche Kommandos möglich?

Dieses Dokument verleiht euch auch sehr viel Sicherheit. Später, wenn der Kunde sagt, dass er das so alles gar nicht gemeint hat, könnt ihr das Dokument herausholen und sagen: “Guck mal, so steht’s hier, und so hab ichs gebaut…” Wenn dem Kunden später auf einmal einfällt, dass die Software doch mandantenfähig sein soll, und ihr somit in alle 500 Tabellen nochmal eingreifen müsst und einiges an der Businesslogik der Software ändern müsst, dann könnt ihr ebenfalls das Dokument herausholen und sagen: “Äh, ich hab in dem Dokument gerade mal nach dem Wort Mandant gesucht und es nicht gefunden. Es wurde im Vorfeld nichts von Mandanten gesagt. Deswegen kostet diese Anpassung nun leider xxx € mehr und von der Zeit her verschiebt sich das Ende des Projektes um zwei Wochen”. Bei solchen Aussagen ein Schwarz-auf-Weiss-Dokument zur Hand zu haben ist echtes Gold wert. Es gibt Kunden, die haben ganz viele tolle Ideen, Träume und Wünsche, die man auch alle gerne umsetzen kann, aber leider wird dabei immer der Kosten- und auch der Zeitrahmen unangetastet gelassen. Sprich, die Entwickler sollen mal eben schnell nebenbei hier ein Haufen Features einbauen, aber es darf keine Zeit und somit auch kein Geld kosten. Das Resultat ist, dass die Qualität leidet. Und wenn die Software den ganzen Tag nur abstürzt, hat auch niemand gewonnen.

So. Hier unten zeige ich nochmal das “magische Dreieck”, welches symbolisiert, dass Zeit, Kosten und Qualität immer zusammenhängen. Man kann nicht eines verändern, ohne die anderen Punkte unangetastet zu lassen. Erhöht man die Qualität, so kostet das Zeit und somit Geld. Spart man an Zeit, weil alles schnell schnell fertig werden muss, so verringert das die Qualität, und im Endeffekt steigert das sogar die Kosten. Weil später einen Bug finden, dauert länger, als es gleich richtig zu machen. Natürlich ist niemand mehr in der Lage, diesen Fehler den Problemen zu Beginn des Projektes zuzuschreiben. Es ist halt einfach nur ein fataler Bug in der Software.

magisches-dreieck

Magisches Dreieck für Kosten – Zeit – Qualität:
Quelle: http://www.realtime-solutions.de/softwareentwicklung/projektmanagement/index.php

wirkliche Zusammenfassung:

Ich appelliere an alle Softwareentwickler und Programmierer, die etwas von sich halten. Nehmt euch die folgenden Sätze zu herzen.

“Qualität zahlt sich aus”

“Qualität bemerkt man immer erst dann, wenn sie nicht da ist”

Arbeitet ordentlich, macht nichts schnell schnell, das geht eh nur nach hinten los (wie gesagt, wir reden hier nicht von einem winzigen hello-world-Projekt) und versucht hier und da immer mal auch ein wenig Dokument zu produzieren, wo drin steht, was ihr wie macht. So ist es auch anderen Entwickler möglich, sich ggf. in eure Software einzuarbeiten.

Windows Phone 7: Versionserkennung

06.06.2010 09:05:00 | Oliver Scheer

imageBei der Windows Phone 7 Entwicklung ist es manchmal ganz hilfreich zu wissen, ob man sich nun im Emulator oder auf einem tatsächlichen Gerät befindet.

Es gibt diverse Dinge die nicht sofort und ohne Einschränkungen im Emulator funktionieren. Dazu gehören Dinge, wie die Positionsermittlung oder die Sensoren (nein, ein Schütteln des Emulators bringt gar nichts, hab es ausprobiert).

Um zu Ermitteln wo und genau auf welcher Version von Windows Phone man sich befindet, kann der folgende Code verraten:

if (Environment.DeviceType == DeviceType.Device)
{
    // Yes, it's really a Windows Phone Device
}
else
{
    // Sorry, only an emulator. 
}

ILMerge

05.06.2010 06:55:00 | Ozgur Aytekin

ILMerge is a utility that can be used to merge multiple .NET assemblies into a single assembly. ILMerge takes a set of input assemblies and merges them into one target assembly. The first assembly in the list of input assemblies is the primary assembly. When the primary assembly is an executable, then the target assembly is created as an executable with the same entry point as the primary assembly. Also, if the primary assembly has a strong name, and a .snk file is provided, then the target assembly is re-signed with the specified key so that it also has a strong name.

ILMerge is packaged as a console application. But all of its functionality is also available programmatically.

There are several options that control the behavior of ILMerge. See the documentation that comes with the tool for details.

ILMerge runs in the v2.0 .NET Runtime, but it is also able to merge v1 or v1.1 assemblies. However it can merge PDB files only for v2 assemblies.

Currently, ILMerge works only on Windows-based platforms. It does not yet support Rotor or Mono.

http://www.microsoft.com/downloads/details.aspx?FamilyID=22914587-B4AD-4EAE-87CF-B14AE6A939B0&displaylang=en

Microsoft AjaxControlToolkit versus JQueryUI & JQuery

04.06.2010 13:42:35 | Daniel Schädler

Gestern habe ich mich ein wenig mit dem ListView und dem TabControl beschäftigt und gezeigt wie man das TabControl in jedem Item des ListViews verwenden kann. Nun damit das funktioniert muss man “nur” das OnItemCreated Ereignis des ListView SteuerElements anpassen. Ich habe das wie folgt gemacht.

   1: <asp:ListView ID="StepListView" runat="server" ItemPlaceholderID="ItemPlaceHolder" OnItemCreated="ListView_OnItemCreated">
   2:     <LayoutTemplate>
   3:         <div id="ItemPlaceHolder" runat="server">
   4:         </div>
   5:     </LayoutTemplate>
   6:     <ItemTemplate>
   7: <div id="StartDateContainer" runat="server" class="StartDateContainer">
   8:     <div id="StartDateLabeledTextBoxContainer" runat="server" class="StartDateLabeledTextBoxContainer">
   9:         <bgweb:LabeledTextBox ID="ScheduledStart_txtLbl" runat="server" CssClass="TextBoxAsLabel"
  10:             ReadOnly="true"></bgweb:LabeledTextBox>
  11:     </div>
  12:     <div id="StartDateImageContainer" runat="server" class="StartDateImageContainer">
  13:         <asp:ImageButton ID="Step_ScheduledStart_btn" runat="server" ImageUrl="~/Images/Calendar_scheduleHS.png"
  14:             Enabled="false" />
  15:     </div>
  16: </div>
  17: <div id="EndDateContainer" runat="server" class="EndDateContainer">
  18:     <div id="EndDateLabeledTextBoxContainer" runat="server" class="EndDateLabeledTextBoxContainer">
  19:         <bgweb:LabeledTextBox ID="ScheduledFinish_txtLbl" runat="server" CssClass="TextBoxAsLabel"
  20:             ReadOnly="true"></bgweb:LabeledTextBox>
  21:         <asp:Label ID="Step_Scheduled_Finish_Error_lbl" runat="server" Visible="false" ForeColor="Red"></asp:Label>
  22:         <asp:HiddenField ID="Step_ScheduledFinish_before_State_HiddenField" runat="server" />
  23:     </div>
  24:     <div id="EndDateImageContainer" runat="server" class="EndDateImageContainer">
  25:         <asp:ImageButton ID="Step_ScheduledFinish_btn" runat="server" ImageUrl="~/Images/Calendar_scheduleHS.png"
  26:             Enabled="false" />
  27:     </div>
  28: </div>
  29: <div id="RoleContainer" runat="server" class="RoleContainer">
  30:     <asp:DropDownList ID="RoleDropDownList" runat="server" AutoPostBack="false">
  31:     </asp:DropDownList>
  32: </div>
  33: <div id="StepDescription" runat="server" class="StepDescription">
  34:     <div id="StepDescriptionContainerLabeledTextBox" runat="server">
  35:         <bgweb:LabeledTextBox ID="Description_lblTxt" runat="server" CssClass="TextBoxAsLabel"
  36:             ReadOnly="true" Wrap="true" TextMode="MultiLine" Height="50" Width="600"></bgweb:LabeledTextBox>
  37:         <asp:HiddenField ID="Step_Description_HiddenField_before_State" runat="server" />
  38:     </div>
  39:     <div id="ButtonContainerOne" runat="server" class="ButtonContainerOne">
  40:         <div id="ButtonStepInsert" runat="server" class="ButtonStepInsert">
  41:             <asp:Button ID="Step_Insert_btn" runat="server" OnClientClick="WriteSourceStepIdToHdf(this); ShowPopUp('InsertActivityModalPopUpExtender'); return false; "
  42:                 CssClass="buttonsmall" />
  43:         </div>
  44:         <div id="ButtonStepDelete" runat="server" class="ButtonStepDelete">
  45:             <asp:Button ID="Step_Remove_btn" runat="server" CssClass="buttonsmall" />
  46:         </div>
  47:     </div>
  48: </div>
  49: <div id="TabContainer" runat="server">
  50:     <ul id="TabListing" runat="server">
  51:         <li id="TabListItemArticle" runat="server"><a id="ArticleAnchor" runat="server" ></a></li>
  52:         <li id="TabListItemStoreDevices" runat="server"><a id="StoreDevicesAnchor" runat="server"></a></li>
  53:         <li id="TabListItemDevices" runat="server"><a id="DevicesAnchor" runat="server"></a></li>
  54:         <li id="TabListItemSoftware" runat="server"><a id="SoftwareAnchor" runat="server"></a></li>
  55:     </ul>
  56:     <div id="TabArticles" runat="server">
  57:         <p>
  58:             Hier werden die Artikel angezeigt.</p>
  59:     </div>
  60:     <div id="TabStoreDevices" runat="server">
  61:         <p>
  62:             Anzeige der Geräte die ans Lager verschoben werden müssen.                         
  63:             </p>
  64:     </div>
  65:     <div id="TabDevice" runat="server">
  66:         <p>
  67:             Hier werden die Geräte angezeigt Das können sen.
  68:             - Drucker <br />
  69:             - NB oder WS <br />
  70:             - Zeiterfassungsgeräte                            
  71:             </p>
  72:     </div>
  73:     <div id="TabSoftware" runat="server">
  74:     <p>
  75:             Hier wird die Software angezeigt.
  76:     </p>
  77:     </div>
  78: </div>
  79: emTemplate>
  80: stView>

Das OnItemCreated Ereignis sieht dann so aus:

   1: protected void ListView_OnItemCreated(object sender, ListViewItemEventArgs e)
   2: {
   3:     // Finding the anchors the modify they're navigation target.
   4:     HtmlAnchor articleAnchor = (HtmlAnchor)e.Item.FindControl("ArticleAnchor");
   5:     HtmlAnchor storeDevicesAnchor = (HtmlAnchor)e.Item.FindControl("StoreDevicesAnchor");
   6:     HtmlAnchor devicesAnchor = (HtmlAnchor)e.Item.FindControl("DevicesAnchor");
   7:     HtmlAnchor softwareAnchor = (HtmlAnchor)e.Item.FindControl("SoftwareAnchor");
   8:  
   9:     // Finding the tab's shown as divs
  10:     HtmlGenericControl tabArticles = (HtmlGenericControl)e.Item.FindControl("TabArticles");
  11:     HtmlGenericControl tabStoreDevices = (HtmlGenericControl)e.Item.FindControl("TabStoreDevices");
  12:     HtmlGenericControl tabDevice = (HtmlGenericControl)e.Item.FindControl("TabDevice");
  13:     HtmlGenericControl tabSoftware = (HtmlGenericControl)e.Item.FindControl("TabSoftware");
  14:  
  15:     articleAnchor.HRef = string.Format(@"#{0}", tabArticles.ClientID);
  16:     storeDevicesAnchor.HRef = string.Format(@"#{0}", tabStoreDevices.ClientID);
  17:     devicesAnchor.HRef = string.Format(@"#{0}", tabDevice.ClientID);
  18:     softwareAnchor.HRef = string.Format(@"#{0}", tabSoftware.ClientID);
  19: }

Rein aus purer Neugier habe ich dann eine Seiter erstellt, welche die Komponenten TabContainer, ToolKitScriptManager beinhaltet und den Vergleich gemacht. Ohne das AjaxControlToolKit ist die Seite 20KB kleiner, wenn man bedenkt, dass es sicherlich einen exzessiven Gebrauch von AjaxControlToolkit-Controls gibt, dann könnte man für Performance-Verbesserungen sicherlich hier eingreifen.

Mit AjaxControlToolkit Site Source Ohne AjaxControlToolkit Site Source

Ich werde in Zukunft auf jedenfall vermehrt das Duo JQueryUI/JQuery einsetzen.


Individueller Splashscreen für Windows Phone 7 Anwendungen

04.06.2010 10:22:35 | Oliver Scheer

Ein typisches Feature viele Anwendungen ist ein Splashscreen, bzw. Startbildschirm der Infos zu einer Anwendung anzeigt und damit eigentlich verschleiert, das die Anwendung noch etwas Zeit zum Laden von Daten benötigt. ;)

Um so einen Bildschirm in seine eigene Windows Phone 7 Anwendung zu integrieren, sind nicht wirklich viele Schritte notwendig. Man benötigt lediglich ein neues JPEG oder PNG in der Größe 480x800 Pixel.

image

Das Ergebnis meines ersten kleinen Splashscreens:

image

Diesen importiert man nun einfach in das Windows Phone 7 Projekt.

image

Wichtig ist, das man das Bild in “splashscreenimage.jpg” umbenennt.

Zusätzlich muss das Bild als Content eingebunden werden. Standardmäßig wird es als Ressource eingebunden

image

Anschließend hat man einen benutzerdefinierten Splashscreen.

image

Mock Objekt - Wie generiere ich eine SQLException ohne Datenbank?

04.06.2010 09:27:00 | Timo Rehl

Folgendes Problem: Wie kann man für Unit Tests bestimmte SQL Exceptions provozieren? Vielleicht sogar noch ohne Datenbank? Bei mir war das Problem, dass wir standardisierte Retry-Mechanismen verwenden, die aber bei bestimmten Fehlerszenarien keinen Sinn machen. So haben wir diverse SQL Fehlermeldungen / Errorcodes definiert, bei denen kein Retry stattfinden soll. Wie testet man nun so etwas? Hier die Antwort:

Mit Hilfe der folgenden Klasse kann man beliebige SqlExceptions erzeugen lassen, und somit Datanbankfehlerszenarien testen, ohne die Fehler mit einer Datenbank reproduzieren zu lassen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Reflection;

namespace Testing.MockObjects
{
    /// <summary>
    /// Hilfsklasse, um SQL Exceptions zu generieren. Diese Klasse bietet nur statische
    /// Methoden an.
    /// </summary>
    public class MockSqlException
    {
        #region Constructor

        /// <summary>
        /// Standard Konstruktor, nicht öffentlich, da nur statische Methoden verfügbar sein sollen.
        /// </summary>
        protected MockSqlException()
        {}

        #endregion

        #region Public methods

        /// <summary>
        /// Erstellt eine SqlException über Reflection.
        /// </summary>
        /// <param name="errorMessage">Die Fehlermeldung, die für die SqlException.Message
        /// Eigenschaft vorgesehen werden soll.</param>
        /// <param name="errorNumber">Die Sqlspezifische Fehlernummer.</param>
        /// <returns>Die generierte SqlException.</returns>
        public static SqlException CreateSqlException(string errorMessage, int errorNumber)
        {
            // Eine SqlException enthält immer eine SqlErrorCollection
            SqlErrorCollection collection = GetErrorCollection();

            // Wir brauchen nur einen Fehler, den wir hiermit generieren
            SqlError error = GetError(errorNumber, errorMessage);

            // Dieser Fehler wird der Collection über die Eigenschaft "add" hinzugefügt
            MethodInfo addMethod = collection.GetType().GetMethod("Add", BindingFlags.NonPublic | BindingFlags.Instance);
            addMethod.Invoke(collection, new object[] { error });

            // Hier wird der Konstruktor der SqlException aufgerufen und die SqlErrorCollection
            // als Parameter übergeben (Standard Konstruktor)
            Type[] types = new Type[] { typeof(string), typeof(SqlErrorCollection) };
            object[] parameters = new object[] { errorMessage, collection };
            ConstructorInfo constructor = typeof(SqlException).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);
            SqlException exception = (SqlException)constructor.Invoke(parameters);

            // Die SQLException wird zurückgegeben
            return exception;
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Generiert über Reflection einen SqlError, der einer SqlErrorCollection hinzugefügt werden kann.
        /// </summary>
        /// <param name="errorCode">Die Sqlspezifische Fehlernummer.</param>
        /// <param name="message">>Die Fehlermeldung, die für die SqlException.Message
        /// Eigenschaft vorgesehen werden soll.</param>
        /// <returns>Das generierte SqlError Objetkt.</returns>
        private static SqlError GetError(int errorCode, string message)
        {
            // generiert über den Konstruktor und dessen Argumente eine SqlError Instanz
            object[] parameters = new object[] { errorCode, (byte)0, (byte)10, "server", message, "procedure", 0 };
            Type[] types = new Type[] { typeof(int), typeof(byte), typeof(byte), typeof(string), typeof(string), typeof(string), typeof(int) };
            ConstructorInfo constructor = typeof(SqlError).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, types, null);
            
            return  (SqlError)constructor.Invoke(parameters);
        }
        
        /// <summary>
        /// Generiert über Reflection eine leere SqlErrorCollection Instanz.
        /// </summary>
        /// <returns>Die generierte SqlErrorCollection Instanz.</returns>
        private static SqlErrorCollection GetErrorCollection()
        {
            // generiert über den Konstruktor eine SqlErrorCollection Instanz
            ConstructorInfo constructor = typeof(SqlErrorCollection).
            GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { }, null);
            SqlErrorCollection collection = (SqlErrorCollection)constructor.Invoke(new object[] { });

            return collection;
        }

        #endregion
    }
}


Wie aus dem Code gut zu erkennen ist, wird der ganze Aufbau der SqlException über Reflection getätigt, weil die SqlException leider nicht öffentlich zugänglich ist.

Die SqlException ist auch immer so aufgebaut, dass sie eine ErrorCollection entgegennimmt, deshalb der umständliche Weg über die Collection. Weiterhin wichtig ist, dass die Eigenschaft SqlException.ErrorCode NICHT den ErrorCode vom SqlServer liefert, sondern den HRESULT, mit dem meist nichts anzufangen ist. Für den SqlErrorCode muss man die Eigenschaft SqlException.Number abfragen. Witzigerweise entspricht der SqlErrorcode der SqlException immer des SqlErrorCodes des ersten SqlErrors aus der Collection (hardcoded!).

Ein Anwendungsbeispiel ist dann z.b. folgender:
        static void Main(string[] args)
        {
            try
            {
                throw MockSqlException.CreateSqlException(
                    "The conversion from datetime data type to smalldatetime data type resulted in a smalldatetime overflow error",
                    298);
            }
            catch (SqlException sqlex)
            {
                int test = sqlex.ErrorCode;
                Console.WriteLine(String.Format("Eine SQL Exception ist aufgetreten: ErrorCode: {0} Message {1}", sqlex.Number, sqlex.Message));
            }

            Console.WriteLine("If this is displayed, a sql exception was thrown, and everything is fine ;-)");
            Console.ReadKey();
        }


Übrigens eine Auflistung aller SQL Fehlermeldungen findet man in der Datenbank selbst:
In SQL 2005: sys.messages
In SQL 2000: master.dbo.sysmessages

Mit Hilfe des Verfahrens lassen sich Datenbank-Negativtests erheblich beschleunigen, weil keine Verbindung zu einer Datenbank notwendig ist.

Aktuellen Standort ermitteln mit Windows 7 und .Net 4 (fast schon gruselig)

03.06.2010 23:52:38 | Manfred Steyer

Als ich gesehen hab', wie gut die Standortbestimmung auch ohne interne Sensoren funktioniert, hab' ich eine Gänsehaut bekommen: Bei Verwendung von Windows 7 besteht die Möglichkeit mittels Sensoren den aktuellen Standort herauszufinden. Wer einen solchen Sensor nicht sein eigen nennt, findet unter http://www.geosenseforwindows.com/ einen softwarebasierten Sensor, welcher Daten, wie die aktuelle IP-Adresse oder Entfernung zu Drahtlosnetzwerken bzw. Mobiltelefonmasten nutzt. Nach der Installation muss der Sensor in der Systemsteuerung unter Ortung- und andere Sensoren aktiviert werden.

Sensoren dieser Art können via .Net 4 angesprochen werden. Das nachfolgende Listing demonstriert dies. Es ermittelt über eine Instanz von GeoCoordinateWatcher die aktuellen Koordinaten (Längengrad, Breitengrad) und versucht mit diesen unter Verwendung eines CivicAddressResolver die dazugehörige zivile Adresse herauszufinden. Die Methode TryStart startet die Verwendung des Sensors. Das erste Argument gibt an, ob der Dialog, welcher dem Benutzer um Erlaubnis zur Verwendung der aktuellen Position bittet, unterdrückt werden soll. Wird dieser Dialog unterdrückt, muss bereits die Verwendung des Sensors durch den Benutzer bewilligt worden sein, damit der aktuelle Standort ermittelt werden kann. Das zweite Argument gibt an, wie viel Zeit in die Ermittlung der aktuellen Position maximal investiert werden darf. Der bool'sche Rückgabewert gibt Aufschluss über den Erfolg der Standortermittlung. Im betrachteten Beispiel werden die ermittelten Geo-Daten sofort verwendet. Um über Standortänderungen informiert zu werden, kann zusätzlich das Ereignis PositionChanged der Klasse GeoCoordinateWatcher verwendet werden. Über die Eigenschaft MovementThreshold kann dabei in Meter angegeben werden, nach welcher Distanz dieses Ereignis aufgerufen werden soll.


GeoCoordinateWatcher watcher = new GeoCoordinateWatcher(GeoPositionAccuracy.Default);
bool started = watcher.TryStart(false, TimeSpan.FromMilliseconds(1000));

if (!started) Console.WriteLine("GeoCoordinateWatcher timed out on start.");

CivicAddressResolver resolver = new CivicAddressResolver();

if (!watcher.Position.Location.IsUnknown)
{
CivicAddress address = resolver.ResolveAddress(watcher.Position.Location);

if (!address.IsUnknown)
{
Console.WriteLine("Country: {0}, Zip: {1}, City: {2}",
address.CountryRegion,
address.PostalCode,
address.City);
}
}

ASP.NET und JQuery Tabs

03.06.2010 22:28:53 | Daniel Schädler

Lange Zeit hat man ja der Einfachheit halber, das AjaxControlToolkit TabControl genommen und man hatte “fast” keine Sorgen mit der Anzeige von Tabs. Seit ASP.NET 4.0 ist JQuery bereits als Boardmittel dabei und lädt ein zum ausprobieren. Wie ich mir einen Tab baue ist unter folgender URL zu finden (nur JQuery, keine eindeutigen ID’s der Controls wie wir es gerne hätten).

Wenn ich aber zum Beispiel ein ListView habe, in welchem ich immer wieder Tabs verwenden möchte, dann bin ich auf die eindeutige ID der Controls angewiesen. Zudem ist es einfacher per Codebehind darauf zuzugreifen, wenn das Attribut runat=”server” vergeben worden ist.

Als erstes habe ich mir alle Controls die im Tab verwendet werden mit einem runat ausgestattet:

   1: <div id="tabs" runat="server">
   2:     <ul id="tabsListing" runat="server">
   3:         <li id="itemOne" runat="server"><a id="tabLinkOne" runat="server" onload="HyperLink_OnLoad">Nunc tincidunt</a></li>
   4:         <li id="itemTwo" runat="server"><a id="tabLinkTwo" runat="server" onload="HyperLink_OnLoad">Proin dolor</a></li>
   5:         <li id="itemThree" runat="server"><a id="tabLinkThree" runat="server" onload="HyperLink_OnLoad">Aenean lacinia</a></li></ul>
   6:     <div id="tabsOne" runat="server" onload="TabPanel_OnLoad">
   7:     </div>
   8:     <div id="tabsTwo" runat="server" onload="TabPanel_OnLoad">
   9:     </div>
  10:     <div id="tabsThree" runat="server" onload="TabPanel_OnLoad">
  11:     </div>
  12: </div>

Dadurch lassen sich diese im Codebehing ganz praktisch ansprechen. Nun muss natürlich noch die ClientID der jeweiligen Controls auf die Anchors (Anker) gelegt werden, damit wir immer eindeutige ID’s zur Verfügung haben.

   1: protected void TabPanel_OnLoad(object sender, EventArgs e)
   2: {
   3:     HtmlGenericControl hc = (HtmlGenericControl)sender;
   4:  
   5:     switch (hc.ID)
   6:     {
   7:         case "tabsOne":
   8:             for (int index = 0; index < WebConfigurationManager.ConnectionStrings.Count; index++)
   9:             {
  10:                 hc.InnerText += WebConfigurationManager.ConnectionStrings[index].ConnectionString;
  11:             }
  12:             break;
  13:         case "tabsTwo":
  14:             hc.Style["background-color"] = "Black";                    
  15:             break;
  16:         case "tabsThree":
  17:             hc.InnerText = "Jawohl, jawohl es braucht nicht immer das AjaxControlToolkit...";
  18:             break;
  19:     }
  20: }
  21:  
  22: protected void HyperLink_OnLoad(object sender, EventArgs e)
  23: {
  24:     HtmlAnchor anchor = (HtmlAnchor)sender;
  25:  
  26:     if (anchor.ID.ToLower().Contains("one"))
  27:     {
  28:         anchor.HRef = string.Format(@"#{0}", tabsOne.ClientID);
  29:         anchor.Title = "Selektiere TabOne";
  30:     }
  31:     else if (anchor.ID.ToLower().Contains("two"))
  32:     {
  33:         anchor.HRef = string.Format(@"#{0}", tabsTwo.ClientID);
  34:         anchor.Title = "Selektiere TabTwo";
  35:     }
  36:     else if (anchor.ID.ToLower().Contains("three"))
  37:     {
  38:         anchor.HRef = string.Format(@"#{0}", tabsThree.ClientID);
  39:         anchor.Title = "Selektiere TabThree";
  40:     }
  41: }

Somit können den Links die eindeutigen ID’s als Referenz vergeben werden und der TabContainer kann zum Beispiel in einem ListView verwendet werden. Auf Anregungen und Kritik zum kleinen Beitrag freue ich mich.

Eine neue Folge von msdn tv ist online: Ausgabe 09/2010

02.06.2010 14:48:39 | Oliver Scheer

Sauber? Rein? Wo ist der Unterschied? Das fragt sich die besorgte Hausfrau aus der Waschmittelwerbung – und das fragt sich inzwischen auch mancher Entwickler, wenn’s um seinen Quelltext geht. Im Werbefernsehen half in solchen Fällen lange Jahre eine sprechende Südfrucht. Bei msdn tv hilft jetzt Ralf Westphal, seines Zeichens Autor, Referent und Mitbegründer einer Initiative, die sich erfolgreich ums Thema „Clean Code Development“ bemüht. Über Absichten und Hintergründe spricht er in der aktuellen Folge mit Jan Schenk.
In den Kurznachrichten vorab Infos zur Microsoft-Konferenz „Tech·Ed Europe“ in Berlin und wie man bis zum 5. Juli dabei Geld sparen kann, ein Hinweis auf die neue Webcast-Serie „Windows Phone 7“, auf einen wichtigen Termin für alle Anwender, die noch Vorversionen des Team Foundation Server 2010 einsetzen und ein neues Trainings-Kit für Office 2010-Entwickler. Außerdem: letzte Gelegenheit zur Teilnahme am kostenlosen Microsoft Web Camp, das am 7. & 8. Juni in Unterschleißheim stattfindet.

http://msdn-online.de/msdntv

Windows Phone 7 Webcast-Serie

02.06.2010 14:47:45 | Oliver Scheer

Microsofts neue Smartphone-Plattform "Windows Phone 7" startet im Herbst 2010 - mit einer frischen, neuen Optik, einer innovativen Anwendungsplattform und einigen grundlegenden Neuerungen für Benutzer, Entwickler und Designer. Diese Webcast-Serie will Ihnen dabei helfen, die neue Plattform besser zu verstehen. Sie vermittelt das notwendige Grundlagenwissen für den erfolgreichen Einstieg in die Entwicklung und das Design von Apps und Spielen, um die neuen Möglichkeiten voll auszuschöpfen und so die Nutzer zu begeistern.

Hier geht es zur Webcastserie.

Windows Phone 7 (Teil 1 von 10) - Neustart: Windows Phone kurz vorgestellt

Serien-Webcast | Frank Prengel | 26.05.2010
Microsoft erfindet seine mobile Plattform neu! Mit Windows Phone 7, das im Herbst 2010 auf den Markt kommt, werden Schwerpunkte neu gesetzt und neue Zielgruppen adressiert. Dieser Webcast erzählt die Windows Phone 7-Story und zeichnet ein Übersichtsbild der kommenden Smartphone-Plattform von Microsoft.

Windows Phone 7 (Teil 2 von 10) - Die neue Anwendungsplattform im Überblick

Serien-Webcast | Frank Prengel | 26.05.2010
Windows Phone 7 bringt eine neue Anwendungsplattform, die Benutzbarkeit, Performance und Stabilität in den Mittelpunkt stellt – Apps und Spiele mit reicheren Möglichkeiten lassen sich jetzt leichter erstellen. Dieser Webcast stellt die zugrunde liegenden Technologien wie .NET, Silverlight und XNA sowie die neuen, kostenlosen Tools für die Windows Phone-Entwicklung vor.

Windows Phone 7 (Teil 3 von 10) - Architektur der Anwendungsplattform von Windows Phone 7

Serien-Webcast | Frank Prengel | 31.05.2010
Windows Phone 7 ist die komplette Neuentwicklung einer modernen Smartphone-Plattform: Betriebssytem, Anwendungen und UI arbeiten zusammen, um bestmögliche Funktionalität zu garantieren - und zufriedene Benutzer. Dieser Webcast diskutiert im Detail, wie dies erreicht wird – Anwendungsmodell, Sicherheit, Web-Dienste, Sensoren, Softwareverteilung u.v.m. inklusive.

Windows Phone 7 (Teil 4 von 10) - Die neue Designsprache von Windows Phone 7

Serien-Webcast | Clemens Lutsch | 31.05.2010
Windows Phone 7 bringt ein radikal neues UI- und Interaktionskonzept. Das neue UI-Design "Metro", die informationszentrischen "Hubs" und viele andere Ansätze erfordern auch von Designern und Entwicklern eine neue Herangehensweise, wenn ihre Anwendungen sich harmonisch in das Geräte-Paradigma einfügen sollen. Dieser Webcasts liefert Hintergrundinformationen und Anleitungen für die Vorgehensweise beim Anwendungsdesign.

Windows Phone 7 (Teil 5 von 10) - Windows Phone 7 Basics mit Silverlight

Serien-Webcast | Oliver Scheer | 02.06.2010
Windows Phone 7 bringt zahlreiche neue Konzepte für die UI-Gestaltung mit. In diesem Webcast erfahren Sie, wie man die neue Application Bar anspricht, wie auf die Ausrichtung des Bildschirms reagiert wird und wie man Tasks des Betriebssystems ausführen kann. Darüber hinaus zeigt Oliver Scheer, wie Medien eingebunden werden und wie man unterschiedliche Formate der Tastatureingabe steuern kann.

Windows Phone 7 (Teil 6 von 10) - Einführung in die Anwendungsentwicklung mit Silverlig

Serien-Webcast | Oliver Scheer | 02.06.2010
Microsoft Silverlight ist die Anwendungstechnologie für Windows Phone 7. Dieser Webcast ist Pflicht für alle, für die Silverlight Neuland darstellt. Er behandelt die Grundkonzepte, Möglichkeiten, Werkzeuge und ersten Schritte beim Design und der Programmierung von Silverlight-Anwendungen. Ebenso Erwähnung finden die plattformübergreifenden Aspekte und Unterschiede zwischen PC und Windows Phone hinsichtlich des Silverlight-Einsatzes.

Stereoskopisches 3D im Web mit Silverlight

02.06.2010 11:21:41 | Oliver Scheer

Sascha Wolter hat es sich zur Aufgabe gemacht, echtes 3D mittels Stereoskopie in Silverlight zu implementiert. Dazu benötigt man zwei Webcams (möglichst baugleich und gut ausgerichtet) um aus zwei Bildquellen ein 3D-Bild zu erzeugen und natürlich eine 3D-Brille (mit roten und grünen “Gläsern”. Ich hab es direkt mal nachgebaut und muss sagen, es klappt, sogar richtig gut.

Er hat dazu einen sehr ausführlichen Artikel veröffentlicht und das Projekt auf Codeplex veröffentlicht.

Mein Beispiel (voll und ganz auf Saschas Code aufbauend) kann hier angesehen werden.

[deprecated] XslTransform wird zu XslCompiledTransform -> Umstellungsprobleme

02.06.2010 02:59:00 | Timo Rehl

Mit unserer Umstellung auf das neue Framework habe ich mich mit dem Problem beschäftigt, dass XslTransform veraltet ist. Die Anweisung, dass nun XslCompiledTransform zu verwenden ist, ist zwar schön und gut, aber wir stießen dabei auf 2 markante Probleme:

Fehler 1:
For security reasons DTD is prohibited in this XML document. To enable DTD processing set the DtdProcessing property on XmlReaderSettings to Parse and pass the settings into XmlReader.Create method.

Fehler 2:
The 'xsl:stylesheet' element is not declared.

Im Folgenden erkläre ich nun Schritt für Schritt, worin die Probleme lagen. Hierfür soll folgendes Ausgangsszenario gelten:

Ausgangssituation:

Gegeben sei folgender Quellcode:
        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XslTransform trans = new XslTransform();
            trans.Load("XSLTFile1.xslt");
            trans.Transform(doc, null, swriter);
        }

dabei ist das zu transformierende Dokument "PocTest1_log.xml" erst einmal unwichtig, es enthält ein valides und vollständiges Xml DOM Objekt.
Interessant ist das XSLT Stylesheet, das für eine Transformation zu einem HTML Dokument verwendet werden soll. Die Besonderheit ist, dass dieses einen DTD Teil definiert, also eine Entity mit definiert. Zu Demozwecken, und damit den Fehler zu provozieren, genügt folgendes Dummy Stylesheet:
<!DOCTYPE xsl:stylesheet [ <!ENTITY jquerysrc SYSTEM 'test.js'> ]>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
    <xsl:output method="xml" indent="yes"/>

    <xsl:template match="@* | node()">
        <xsl:copy>
            <xsl:apply-templates select="@* | node()"/>
        </xsl:copy>
    </xsl:template>
</xsl:stylesheet>

Wenn nun der o.g. Code ausgeführt wird läuft alles zunächst wunderbar, außer, dass die Warnung XslTransform ist deprecated ausgegeben wird.

Umstellung auf XslCompiledTransform Schritt 1:

Eine Umstellung auf XslCompiledTransform ergibt zunächst folgender Code:
        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XslCompiledTransform trans = new XslCompiledTransform();
            trans.Load("XSLTFile1.xslt");
            trans.Transform(doc, null, swriter);
        }

Die Laufzeit ergibt den o.g. Fehler 1 (Zeile trans.Load): "For security reasons DTD is prohibited in this XML document ..."

Umstellung auf XslCompiledTransform Schritt 2 (Lösung zu Schritt 1):

Im Netz findet sich hier die bereits etablierte Lösung, dass man mittels einem XmlReader und der darin enthaltenen Möglichkeit XmlReaderSettings mitzugeben die Lösung enthalten sei:
        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XmlReaderSettings xmlReadSet = new XmlReaderSettings();
            xmlReadSet.ValidationType = ValidationType.DTD;
            xmlReadSet.DtdProcessing = DtdProcessing.Parse;

            XslCompiledTransform trans = new XslCompiledTransform();
            trans.Load(XmlReader.Create("XSLTFile1.xslt", xmlReadSet));
            trans.Transform(doc, null, swriter);
        }

Übrigens, die Eigenschaft XmlReaderSettings.ProhibitDtd ist ebenso veraltet, hierzu kann man wie im Code angegeben die Eigenschaft XmlReaderSettings.DtdProcessing verwenden.

Die Laufzeit ergibt allerdings den o.g. Fehler 2 (Zeile trans.Load): "The 'xsl:stylesheet' element is not declared."

Diese Fehlermeldung ist alles andere als selbsterklärend, und total irreführend. Ich habe lange herumgespielt, aber im Netz war nichts zu finden, und auch ein intensives Debugging brachte leider keine Lösung. Ich habe nur folgende Erkenntnisse gehbt (zunächst):
- Entfernung des DTD (DOCTYPE Knoten) -> Code funktioniert
- Verwendung von XsltSettings mit diversen Einstellmöglichkeiten (z.B. TrustedXslt) -> keine Veränderung, Code funktioniert nicht
- XsltArgumentList kann nicht verwendet werden, da das Problem schon bei Load auftritt, nicht erst bei Transform
- ...

Umstellung auf XslCompiledTransform vollständige Lösung:
Ich weiß nicht warum ich versucht habe noch einmal mit den XmlReaderSettings herumzuspielen, aber die Änderung des ValidationType brachte dann die funktionierende Lösung:
        static void Main(string[] args)
        {
            XPathDocument doc = new XPathDocument("PocTest1_log.xml");
            StreamWriter swriter = new StreamWriter("PocTest1_log.html");

            XmlReaderSettings xmlReadSet = new XmlReaderSettings();
            xmlReadSet.DtdProcessing = DtdProcessing.Parse;
            xmlReadSet.ValidationType = ValidationType.Schema;

            XslCompiledTransform trans = new XslCompiledTransform();
            trans.Load(XmlReader.Create("XSLTFile1.xslt", xmlReadSet));
            trans.Transform(doc, null, swriter);
        }

So ganz kann ich die Fehlermeldung nicht nachvollziehen, ich wüsste nicht, wenn ich das Stylesheet als DTD behandle, was darin syntaktisch verkehrt wäre, und warum eine Validierung fehlschlägt, aber eine Umstellung auf Schema brachte dann schlußendlich die Lösung.

Stimmen zur dotnet Cologne 2012

01.06.2010 23:10:00 | Stefan Lange

Am 28.05.2010 fand die dotnet Cologne 2010 statt. Es hat sehr viel Spaß gemacht und wir haben von den Teilnehmern, Sprechern und Sponsoren ein durchgehend sehr positives Feedback erhalten. An dieser Stelle daher noch einmal ein großes Dankeschön an alle Beteiligten, die Ihr zum guten Gelingen der Veranstaltung beigetragen habt.

Als einer der Veranstalter möchte ich aber gar nichts weiter dazu sagen, sondern einfach auf das Echo im Web verweisen:

Dr. Joachim Fuchs: Gelungenes Wachstum

Dariusz Parys: Dariusz quatscht

Jürgen Gutsch: dotnet Cologne 2010

Gordon Breuer: dotnet Cologne 2010: Ein Rückblick

Thomas Bandt: Review: dotnet Cologne 2010

Jan Welker Ein perfekter Tag in der .NET Community

Oliver Sturm: Slides and samples from dotnet Cologne 2010

Martin Hey: Nachlese zur dotnet Cologne 2010

André Krämer: dotnet Cologne 2010 - was ein riesen Spaß

Michael Hülskötter: dotnet Cologne 2010, ein voller Erfolg, dotnet Cologne 2010, ein voller Erfolg – Teil 2]

Albert Weinert: Schreibt über die dotnet Cologne 2010, stürmt dotnet-kicks.de und gewinnt ein Tekpub Abo

Roland Weigelt: Das war die dotnet Cologne 2010

Mathias Raacke: dotnet Cologne 2010

Britt King: dotnet Cologne 2010 Winners, Typemock Isolator for Brownfield Projects

Thomas Mentzel: dotnet Cologne Tagebuch

Sergey Shishkin: DotNet Cologne 2010: WCF4 Live Coding with GitHub

msdn tv - Nachrichten für Entwickler (Ausgabe 09/2010)

01.06.2010 21:23:57 | Jan Schenk

Get Microsoft Silverlight


Sauber? Rein? Wo ist der Unterschied? Das fragt sich die besorgte Hausfrau aus der Waschmittelwerbung – und das fragt sich inzwischen auch mancher Entwickler, wenn’s um seinen Quelltext geht. Im Werbefernsehen half in solchen Fällen lange Jahre eine sprechende Südfrucht. Bei msdn tv hilft jetzt Ralf Westphal, seines Zeichens Autor, Referent und Mitbegründer einer Initiative, die sich erfolgreich ums Thema „Clean Code Development“ bemüht. Über Absichten und Hintergründe spricht er in der aktuellen Folge mit Jan Schenk.

In den Kurznachrichten vorab Infos zur Microsoft-Konferenz „Tech∙Ed Europe“ in Berlin und wie man bis zum 5. Juli dabei Geld sparen kann, ein Hinweis auf die neue Webcast-Serie „Windows Phone 7“, auf einen wichtigen Termin für alle Anwender, die noch Vorversionen des Team Foundation Server 2010 einsetzen und ein neues Trainings-Kit für Office 2010-Entwickler. Außerdem: letzte Gelegenheit zur Teilnahme am kostenlosen Microsoft Web Camp, das am 7. & 8. Juni in Unterschleißheim stattfindet.

 

Über msdn tv:
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.

About msdn tv:
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.

Microsoft BizSpark Camp

01.06.2010 15:54:09 | Oliver Scheer

clip_image003Wir freuen uns sehr, Sie zusammen mit Netzwerkpartnern zu unseren BizSpark Camps in München, Berlin und Köln im Juni einzuladen!

Wir sind stolz, namhafte Vertreter der Deutschen Startup-Szene vor Ort begrüßen zu können, die spannende Ausblicke auf die Zukunftstrends der Technologiewelt geben. Darüber hinaus erhalten Sie Informationen von Microsoft Experten zu Gründerangeboten, hören Neuigkeiten zu Windows Phone 7 und heben ab in die Cloud – und das Ganze kostenlos!
Eine Übersicht aller Referenten finden Sie im Anhang.

Neben den Vorträgen wird es Gelegenheit geben, bei Getränken und Snacks sich mit anderen Startups, Netzwerkpartnern und Experten auszutauschen und zu “networken”.
Und natürlich haben wir auch an alle Fußballfans gedacht: ab 20:30 Uhr werden wir live ein WM Fußballspiel zeigen und in der Halbzeitpause wartet auf einen glücklichen Gewinner eine Xbox 360 inkl. FIFA Fußball Weltmeisterschaft Südafrika 2010 Spiel!

Wir würden uns freuen, wenn Sie auch Ihre Kollegen und befreundete Startups aus der Szene zu diesen Events einladen und mitbringen.
Leiten Sie einfach diese Einladung direkt an Ihre Kontakte weiter. Vielen Dank!

Melden Sie sich gleich zum BizSpark Camp in Ihrer Nähe an!
München: 15. Juni 2010 | Zur Agenda München
Berlin: 17. Juni 2010 | Zur
Agenda Berlin
Köln: 24. Juni 2010 | Zur Agenda Köln

TT.DOM in der aktuellen DevDorado

01.06.2010 10:58:00 | Jörg Neumann

In der aktuellen Ausgabe der DevDorado (2/2010) ist mein Artikel “Thinktecture.DataObjectModel: Vermittler zwischen den Welten” erschienen. Aus dem Abstract:

Bei der Entwicklung verteilter Anwendungen kommen verschiedenste Technologien zum Einsatz: WCF für die Kommunikation, ein O/R-Mapper für den Datenzugriff, eine Clienttechnologie zur Präsentation und vieles mehr. Das Zusammenspiel funktioniert jedoch nicht immer reibungslos. Besonders bei den Datenobjekten treffen teilweise gegensätzliche Anforderungen aufeinander. Mit dem Thinktecture.DataObjectModel steht ein Open-Source-Framework zur Verfügung, das zwischen den Welten vermittelt und vor allem auf Clientseite eine Menge fehlender Funktionalität nachrüstet.

Mein jQuery Vortrag auf der dotnet Cologne

01.06.2010 02:25:11 | Andre Kraemer

Das Beispielprojekt meines jQuery Vortrags während der dotnet Cologne kann ab sofort hier herunter geladen werden.

Es handelt sich dabei um ein kleines ASP.NET MVC 2 Projekt, in dem folgendes genutzt wurde:

  • ASP.NET MVC 2 ;-)
  • StructureMap als IOC Container
  • SQLite als leichtgewichtige In-Memory-DB
  • NHibernate für den Datenbankzugriff
  • jQuery für den Wow-Faktor ;-)

Die Solution liegt passend zur Veranstaltung im VS 2010 Format vor. Bei Bedarf kann ich aber auch eine VS 2008 Solution bereit stellen.

Hauptaugenmerk solltet ihr auf die Datei aufgabenlist.js setzen. Hier befindet sich der relevante jQuery / JavaScript Code. Der ganze Rest ist nur "Infrastruktur", damit ich jQuery an einem halbwegs realistischen Beispiel zeigen kann ;-)

An Feedback zu den Quellcodes bin ich immer interessiert. Am besten über das Kontaktformular, oder die während des Vortrags mitgeteilte E-Mail Adresse.

Ich weiß übrigens, dass das ASP.NET MVC Projekt keine Unit Tests beinhaltet. Angesichts der Projektgröße und der verfügbaren Zeit habe ich hier ein wenig geschludert. Thomas Bandt hat mich während des Vortrags übrigens auch darauf aufmerksam gemacht, dass mein JavaScript Code nicht via Unit Tests geprüft wurde. Auch hier gelobe ich Besserung :-)

Literaturempfehlungen

Im Anschluss an den Vortrag wurde ich außerdem gefragt, welche Literatur ich zu dem Thema empfehlen könnte.

Nun, da sich jQuery hauptsächlich mit der Modifikation des DOMs, insbesondere dem Ein- / Ausblenden sowie dynamischem CSS befasst, sollte man meiner Meinung nach zunächst über solide (X)HTML und CSS Kenntnisse verfügen (kein Witz).

Zu diesem Thema kann ich das Buch Head First HTML with CSS & XHTML empfehlen:

Außerdem können generelle JavaScript Kenntnisse auch nicht schaden ;-) Hier habe ich persönlich sehr gute Erfahrung mit dem Buch Professional JavaScript for Web Developers gemacht.

Speziell zum Thema jQuery hat mir das Buch jQuery in Action, Second Edition sehr gut gefallen. Ich habe es mir im Rahmen des Manning Early Access Program als E-Book bestellt. Wer lieber ein gedrucktes Exemplar haben möchte, muss sich noch ein wenig gedulden, kann es aber dann auch z. B. bei Amazon bestellen.

Das war die dotnet Cologne 2010

01.06.2010 02:14:48 | Roland Weigelt

Als sich am späten Freitagabend hinter mir die Parkplatzschranke des Holiday Inn am Stadtwald in Köln schloss, wurde endgültig klar: das war’s. Etliche Monate Vorbereitungszeit, eine wochenlange heiße Phase und dann war irgendwie alles ganz schnell vorbei. Zurück blieb ein gutes Gefühl, dass bei all den Strapazen Motivation genug ist, auch 2011 eine dotnet Cologne in Angriff zu nehmen.

Der Konferenztag begann rund 16 Stunden vorher mit dem Aufbau der 300 Taschen für die Teilnehmer und anderen Vorbereitungen wie die Bereitstellung der Teilnehmermarken.

Taschen

Nach dem Einlass stürzten sich die Teilnehmer auf das Frühstück, das sowohl in Quantität und Qualität überzeugen konnte. Dies verringerte dann auch gleich meine Nervosität – denn gesättigte Teilnehmer sind gut gelaunte Teilnehmer…

Fruehstueck

Um 9:45 startete die offizielle Begrüßung, die leider von einigen Anlaufschwierig-keiten geplagt war. Die versagenden Batterien der Presenter-Maus konnten glücklicherweise schnell gewechselt werden (ich habe bei Vorträgen immer Ersatz in der Tasche). Die anderen Punkte wie die ungünstige Lautstärke-regelung (über ein vom Hotel fest verbautes Mischpult in einem fast schall-dichten Nebenraum) und die Verstopfung des Eingangbereichs durch mangelnde “Crowd Control” fallen unter die Rubrik “Abhaken und beim nächsten Mal irgendwie besser regeln”.

Die Anmerkung eines Teilnehmers, dies würde den Charme einer Community-Konferenz ausmachen, war zwar als Aufmunterung nett gemeint, aber mein Ehrgeiz es 2011 besser zu machen ist trotzdem geweckt.

Keynote

Meine Keynote ab 9:55 lief kurz gesagt erfreulich rund. Seit einiger Zeit halte ich meine Vorträge im “wenige Worte pro Folie, dafür viele Folien pro Minute”-Stil und die 50 Folien passten fast perfekt in die geplanten 20 Minuten. Woher ich wusste, dass es zeitlich hinkommen würde? Ehrlich gesagt: Keine Ahnung, denn für eine Probe in Echtzeit war in den Tagen vor der Konferenz keine Gelegenheit…

Nach der Keynote mussten noch schnell Teile der Mikrofonanlage umgestöpselt werden und dann war bei mir auch erst einmal die Luft raus. Die Anspannung war weg und ich gönnte mir eine Pause, bevor ich als “normaler Teilnehmer” die Vorträge von Stefan Lange zu Silverlight und Mathias Raacke zu Visual Studio Extensibility besuchte.

Das Mittagessen gestaltete sich danach leider etwas chaotischer als gedacht. Zur Erklärung: Ursprünglich war eine Staffelung in 15min-Schritten geplant – ein Vortrag sollte 30 Minuten, zwei 45 und einer 60 Minuten dauern. Dummerweise fiel der 30-Minüter weg (und wurde durch einen 60-Minüter ersetzt) und dann wurden bei einem der Vorträge aus 45 fast 60 Minuten. Das heißt: Die Teil-nehmer aus drei Tracks strömten gleichzeitig zum Mittagessen. Auch hier gilt wieder: Notieren und bei nächsten Mal besser machen.

Der Nachmittag ging im Nu vorrüber und bei der durch unsere Sponsoren reichhaltig bestückten Verlosung wurden jede Menge glückliche Gewinner mit Büchern und Software-Lizenzen ausgestattet.

Apropos Sponsoren: Besonders erfreulich war das positive Feedback der Sponsoren vor Ort, die sich über regen Besuch der Stände freuten. Für die Verlosung diente dieses Jahr nicht der Bewertungsbogen als Los (was anonymes und damit ehrliches Feedback ermöglichte), stattdessen gab es einen Laufzettel, der von mindestens fünf Sponsoren abzustempeln war. Dieser Zettel erfüllte bei vielen tatsächlich die angedachte Funktion, als “Eisbrecher” einen einfacheren Einstieg in ein Gespräch zu finden.

Da sich das Wetter im Laufe des Tages deutlich verbessert hatte, konnte die abschließende vom dotnet Forum gestiftete Grillfete tatsächlich im Freien stattfinden. Ein schöner Ausklang für einen gelungenen Konferenztag und eine gute Gelegenheit mal in Ruhe mit Leuten zu reden, die man sonst nur von Twitter-Einträgen u.ä. her kennt.

Danksagung

An dieser Stelle möchte ich mich ganz herzlich bedanken:

  • bei Stefan Lange, Albert Weinert und Melanie Eibl für die gute Zusammenarbeit
  • bei den Sprechern, die ohne Honorar (alleine gegen Erstattung der Reisekosten) aufgetreten sind
  • bei allen Helfern und Sponsoren, die diesen Tag möglich gemacht haben
  • bei dem Microsoft CLIP-Team um Dorothea Henke für das Abendessen am Abend vorher (und das “Doch-noch-möglich” am nächsten Tag).
  • und bei allen Teilnehmern für das Lob und die Ermunterung, auch 2011 eine Community-Konferenz auf die Beine zu stellen.

Link-Sammlung

Die dotnet Cologne 2010 hat mittlerweile ein deutliches Echo im Web hinterlassen, hier eine Auswahl:

  • Blogeinträge von Thomas Bandt, Mathias Raacke, Gordon Breuer, Martin Hey, Jürgen Gutsch, Dariusz Parys, Oliver Sturm und André Krämer
  • Artikel auf heise Developer
  • Fotogalerie von der dotnet Forum Grillparty.

  • dotnet Cologne 2010 - was ein riesen Spaß

    01.06.2010 02:03:46 | Andre Kraemer

    Letzten Freitag hatte ich die Freude, an der dotnet Cologne teilzunehmen. Mit über 300 Teilnehmern war es ein wirklich riesiges Event, dass sich vor "professionellen", oder besser gesagt kommerziellen Konferenzen nicht verstecken muss.

    Der Teilnehmer

    Vor Ort war ich in mehreren Rollen. Zum einen natürlich als Teilnehmer. In dieser Rolle nutzte ich die Möglichkeit, endlich mal die Gesichter zu einigen Bekannten aus der Community zu sehen und auch mal persönlich das ein oder andere Wort zu wechseln. Außerdem hörte ich mir auch spannende Vorträge, unter anderem von Jörg Krause zu Sharepoint als Entwicklungsplattform, Neues in Silverlight 4 von Stefan Lange sowie Neues in ASP.NET 4.0 von Jan Welker.

    Irritierend fand ich, dass gefühlte 90 % der Besucher von Jörg Krauses Sharepoint Vortrag keinerlei Sharepoint Vorkenntnisse hatten und somit wohl nicht im geringsten wussten, wie so eine Site, eine Sitecollection, ein Web, eine Liste, ein Webpart ... an der Oberfläche wohl aussehen. Die gleiche Situation habe ich übrigens auch mehrfach schon auf der Shareconnect (Basta Sharepoint Days) beobachtet. Vielleicht wäre hier einfach mal ein "Was ich über Sharepoint wissen sollte, bevor ich Visual Studio aufmache" Vortrag angebracht. Leider habe ich einen solchen Vortrag bisher noch auf keiner (Entwickler-)Konferenz im Angebot gesehen. Nichts desto trotz fand ich Jörgs Vortrag prima! Auch die anderen besuchten Vorträge haben mir gut gefallen, daher mein Fazit als Teilnehmer:

    Voller Erfolg! Gute Vorträge, gute Kontaktmöglichkeiten zur Community, was will man mehr.

    Der Aussteller

    Unter den Sponsoren des Events war unter anderem auch die Firma Infragistics. Wie auch auf anderen Konferenzen lies ich es mir als fleißiger Infragistics MVP  in den Pausen natürlich nicht nehmen, Kiril und Nils tatkräftig zu unterstützen. Dies war auch bitter nötig, da der Andrang am Stand weit höher war, als ich es von anderen Konferenzen gewohnt war. Kamen wir normalerweise zu zweit immer ganz gut zurecht, waren dieses Mal sogar drei Personen eigentlich schon fast zu wenig.

    Fazit als Aussteller: Tolle Veranstaltung! Viele Kontakte, interessante und zum Teil sogar sehr trickreiche Fragen, genauso muss es sein!

    Der User Group Leader

    Jeder der schon mal ein User Group Treffen besucht hat wird sich sicherlich fragen:

    Wo kommen eigentlich die Sprecher her?

    Nun ja, als sie ganz klein waren, wird sie voraussichtlich einer der beiden hier unten gebracht haben.

    image

    Foto: Valter Jacinto | Portugal   http://www.flickr.com/photos/valter/87429062/sizes/m/
    Creative Commons License

    Irgendwann werden die Jungs und Mädels dann aber groß und spätestens dann stellt sich für einen User Group Leiter die Frage:

    Wo bekomme ich eigentlich Sprecher her?

    Ein besonders guter Ort, Sprecher für die eigene User Group zu finden ist selbstverständlich eine Konferenz, denn dort treten Speaker häufig in Rudeln auf ;-)

    Also machte ich mich während der dotnet Cologne auf den Weg und zog Sprecher für die nächsten Treffen der .NET User Group Koblenz an Land.

    Die Ausbeute war übrigens mit zwei definitiven, einer relativ verbindlichen und einer losen Zusage recht gut. Daher auch hier: dotnet Cologne, 12 Points ;-)

    Der Sprecher

    Zu guter letzt (und angesichts der Agenda ist dies wörtlich gemeint), war ich auch als Sprecher unterwegs. Mein Thema war die Einführung in jQuery unter dem spontan geänderten Titel:

    jQuery - oder warum Sie JavaScript in Zukunft nicht mehr hassen werden.

    Den Verlauf des Vortrags würde ich wie folgt beschreiben

    • Der Saal füllt sich, die Menge wird still. Ich will loslegen, aber mein Mikro überlegt sich, dass es sich lieber in meinem T-Shirt verdreht. Kein Mensch hört mich ... so ein Mist
    • Mikro Problem gelöst, schnell durch die Folien gejagt. Auf gehts zur Demo!
    • Meine ASP.NET MVC Anwendung reißt niemand vom Hocker und stößt kaum auf Interesse
    • Ist zum Glück nicht schlimm, schließlich ist mein Thema ja auch jQuery und nicht ASP.NET MVC ;-)
    • Die ersten UI Gimmicks (alternierende Tabellenzeilen, Hover Effekte) zaubern ein müdes Lächeln auf die Gesichter der Menge - da muss wohl noch mehr her
    • Ich erstelle mit einer Zeile jQuery Code auf- und zuklappbare Bereiche in der Sidebar der Anwendung. Im Publikum sehe ich die ersten funkelnden Augen
    • Auf der Welle muss ich weiter reiten, also jetzt schnell ein wenig Ajax;-)
    • In der Einleitung habe ich etwas vom Update Panel erzählt. Heißt dann wohl ich sollte auch ein wenig WebForms zeigen. Ich entschließe mich also, im Firebug mal zu zeigen, was über die Leitung geht wenn man Ajax mit dem Update Panel erlegt erledigt. Als ich zum ViewState scrolle scheinen einige Teilnehmer zu glauben ich hätte gerade die Matrix gehacked oder zumindest gedebugged.
    • Oh je, nur noch 3 Minuten Zeit und ich habe doch versprochen früher Schluss zu machen - jetzt muss schnell etwas großartiges her. Ich greife also noch mal in die Trickkiste und greife zu meinem größten Trumpf:
      runde Ecken;-)
      Puh, geschafft, die Zuschauer jubeln. Ein Glück, dass es runde Ecken gibt ;-)

    Mein Fazit als Sprecher lautet also:

    Wahnsinn! Auch wenn es nur ein Einsteiger Vortrag war und laut Handzeichen mindestens die Hälfte der Anwesenden jQuery bereits kannte und nutzte war das Publikum allem Anschein nach während des Vortrags voll dabei. So macht vortragen Spaß!

    Der Grillfreund

    Zum Abschluss fand für einige Teilnehmer, Sprecher und Sponsoren dann noch die durch Microsoft gesponsorte und durch Jan Welker gestifftete Grill-Party des dotnet Forums statt. Essen und Getränke waren sehr lecker, die Gespräche spannend, von daher auch hier mein Kompliment.

    Fazit

    Der Besuch der dotnet Cologne hätte in keinster Weise besser laufen können. Großes Lob und alle Achtung an die Organisatoren! Nächstes Jahr bin ich - in welcher Form auch immer - sicherlich auch wieder mit dabei!

     

    Hey, du hast dir die Zeit genommen, den ganzen Beitrag zu lesen, oder zumindest bis hier hin zu scrollen. Nimm dir doch bitte auch noch die Zeit, ihn über den unten stehenden Button bei dotnet-kicks.de zu kicken!

    Schreibt über die dotnet Cologne 2010, stürmt dotnet-kicks.de und gewinnt ein Tekpub Abo

    01.06.2010 01:05:47 | Albert Weinert

    Aufruf zum Online-Flashmob ;)

    Schreibt einen Online-Artikel, oder einen Blog-Eintrag über die dotnet Cologne 2010  und lasst euch kicken!

    Wenn die Startseite von http://dotnet-kicks.de komplett mit Einträgen zur dotnet Cologne voll ist verlose ich unter allen Schreibern auf der dotnet-kicks.de Startseite 5 x ein Monatsabo von http://tekpub.com.

    Sollte bis zum 12. Juni 2010 nicht die ganze Startseite voll sein, dann werden nur drei Monatsabos von Tekpub unter den dotnet Cologne Berichterstattern auf der dotnet-kicks.de Startseite verlost.

    Der Rechtsweg ist ausgeschlossen, der Gewinn kann nicht ausgezahlt werden.

    Technorati-Tags: ,

    WPF Forum | ASP.NET Forum | ASP.NET MVC Forum | Silverlight Forum | Windows Phone 7 Forum | SharePoint Forum | Dotnet Jobs | Dotnet Termine | Developer Blogs | Dotnet News

    Das Team | Regeln | Impressum