Rash thoughts about .NET, C#, F# and Dynamics NAV.

Navision hat wie alle “größeren” Systeme bei der “ERP-Zufriedenheitsstudie Schweiz 2006” leider nicht so berauschend abgeschnitten – mySAP war sogar auf dem vorletzten Platz.

Besonders interessant an der Studie sind vor allem die Diagramme der Zufriedensheitsaspekte – demnach sind Formulare/Reports zwar stark vom Kunden beeinflußbar, erzeugen jedoch trotzdem den meisten Frust. Irgendwie kommt mir das bekannt vor.

Weitere Informationen:

• InfoWeek-Artikel (unbedingt die Diagramme ansehen)
• Präsentationsfolien
• Bilder der Präsentation

Microsoft scheint jetzt wieder ernst zu machen und versucht den Suchmaschinenmarkt wieder etwas spannender zu gestalten. Neuste Projekte sind ja neben der eigentlichen Maschine (live.com) die wunderbare Ms. Dewey und seit gestern der Live Rundflug durch 15 Städte der USA über Virtual Earth 3D (SDK). Das ist schon wirklich beeindruckend Städte wie Las Vegas in der 3D-Ansicht zu betrachten. Selbstverständlich werden da kaum noch Weltraumaufnahmen benutzt, sondern hauptsächlich Aufnahme aus Flugzeugen und Vans.

Der Suchbegriff “pussy” geht auf Live.com übrigens immer noch nicht 😉

“Der Suchbegriff pussy führt möglicherweise zu rechtswidrigen oder jugendgefährdenden Inhalten.”

Der Cocktail “pussy foot” wird jedoch gefunden und nicht durch das Jugendschutz-Feature gefiltert.

In jedem Fall wird es spannend zu sehen wie sich Google zur neuen “Konkurrenz” verhält und ob die Google-Dienste (wie Google Earth, usw.) etwas vom Kuchen abgeben. Am wichtigsten wäre es meiner Meinung nach aber, dass sich endlich eine zweite Suchmaschine (egal von wem) am Markt positionieren könnte – so ein Monopol bei der Informationsbeschaffung ist zumindest bedenklich.

Microsoft hat das .NET Framework 3.0 (englisch) als Final released. Bei Windows Vista ist .NET 3.0 dann auch vorinstalliert.

Es existieren folgende Downloads:

• Microsoft .NET Framework 3.0 Redistributable Package
• Windows Vista SDK samt .NET Framework 3.0 Runtime
• Visual Studio 2005 extensions for .NET Framework 3.0 (WF)
• Visual Studio 2005 extensions for .NET Framework 3.0 (WCF, WPF) als CTP
• .NET Framework 3 online ausprobieren (Virtual Labs)

Mit der Änderung von Googles Suchalgorithmen wurden auch die Richtlinien für Webmaster geändert. Früher wurden dynmische Seiten (also Seiten mit einem “?id=” in der url) nicht mit in den Index aufgenommen. Hier wird jetzt aber beschrieben, dass diese Seiten jetzt auch ohne URL-Rewriting in den Google-Index aufgenommen werden. Außerdem wird empfohlen die Parameterliste nicht zu lang werden zu lassen, da dies ein Problem für Bots darstelle. Es ist natürlich kein Fehler wenn man die Adressen trotzdem umschreibt, wenn man auch an andere Suchmaschinen denkt.

Nachdem ich nun endlich mal wieder etwas Zeit hatte, konnte ich mein Versprechen erfüllen und die Seite der Uwe Schlamann GmbH erneuern. Die Firma vertreibt Feuerlöscher, Löschanlagen, Rauch- und Wärmeabzugsanlagen und vieles mehr. Ich habe dabei entgegen meines bisherigen Plans WordPress als Basisplattform genommen. Ich finde WordPress ist für viele Anwendungsfälle einfach viel leichter anpassbar als z.B. Joomla – Joomla ist meiner Meinung nach mittlerweile schon zu aufgeblasen.

Es war übrigens auch problemlos möglich den existierenden Feuerlöscher-Produktkatalog als neues WordPress-Plugin samt eigener Permalink-Struktur umzusetzen.

Im fünften Teil meiner Serie möchte ich auf erweiterte Möglichkeiten der Konfiguration des Dienstes eingehen. Über die ApplicationSettings ist es in Visual Studio ganz einfach möglich Strings, Integer usw. als globale Anwendungseinstellungen (web.config bei ASP.NET – sonst app.config) abzuspeichern:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <sectionGroup name="userSettings" type="...">
            <section name="DBCopyService.Properties.Settings"
              type="..." 
              allowExeDefinition="MachineToLocalUser" 
              requirePermission="false" />
        </sectionGroup>
    </configSections>
    <userSettings>
        <DBCopyService.Properties.Settings>
            <setting name="ServerName" serializeAs="String">
                <value>serverName</value>
            </setting>
        </DBCopyService.Properties.Settings>
    </userSettings>    
</configuration>

Der Zugriff auf die Einstellung “ServerName” erfolgt dann ganz einfach über Properties.Settings.Default.ServerName. Man kann sogar zur Laufzeit die Settings ändern und wieder abspeichern.

Wenn man jedoch komplexere Strukturen in den Einstellungen ablegen möchte, kommt man um etwas Code nicht mehr herum. Im folgenden Beispiel lege ich die neue Sektion “entrances” an, um dort dann beliebig viele Eingangsverzeichnisse überwachen zu lassen:

Eintrag in der app.config:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
      <sectionGroup name="DBCopyService">
        <section name="entrances" 
          type="DBCopyService.EntranceSection,DBCopyService" />
       </sectionGroup>
    </configSections>
    <DBCopyService>
      <entrances>
        <entrance name="entrance1" path="C:\Eingang\" 
          mailAddress="mail@server.de"  />
        <entrance name="entrance2" path="C:\Eingang2\" 
          mailAddress="mail2@server.de"  />
      </entrances>
    </DBCopyService>    
</configuration>

Zugriff über Ableitung von ConfigurationElement, ConfigurationElementCollection und ConfigurationSection:

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace DBCopyService
{
    public sealed class EntranceElement : ConfigurationElement
    {
        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>The name.</value>
        [ConfigurationProperty("name", IsKey = true, IsRequired = true)]
        public string Name
        {
            get { return (string)base["name"]; }
            set { base["name"] = value; }
        }

        /// <summary>
        /// Gets or sets the mail address.
        /// </summary>
        /// <value>The mail address.</value>
        [ConfigurationProperty("mailAddress", IsRequired = true)]
        public string MailAddress
        {
            get { return (string)base["mailAddress"]; }
            set { base["mailAddress"] = value; }
        }

        /// <summary>
        /// Gets or sets the path.
        /// </summary>
        /// <value>The path.</value>
        [ConfigurationProperty("path", IsRequired = true)]
        public string Path
        {
            get { return (string)base["path"]; }
            set { base["path"] = value; }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace DBCopyService
{
    public sealed class EntranceCollection 
      : ConfigurationElementCollection
    {
        protected override ConfigurationElement 
          CreateNewElement()
        {
            return new EntranceElement();
        }

        protected override object GetElementKey(
          ConfigurationElement element)
        {
            return ((EntranceElement)element).Name;
        }

        public override ConfigurationElementCollectionType 
          CollectionType
        {
            get
            { 
               return 
                 ConfigurationElementCollectionType.BasicMap; 
            }
        }

        protected override string ElementName
        {
            get{ return "entrance"; }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;

namespace DBCopyService
{
    public sealed class EntranceSection : ConfigurationSection
    {
        [ConfigurationProperty("", IsDefaultCollection = true)]
        public EntranceCollection Entrances
        {
            get { return (EntranceCollection)base[""]; }
        }
    }
}

Mit Hilfe dieser Klassenstruktur (Element, Collection, Section) kann man nun bequem auf die Section zugreifen:

EntranceSection entranceSection = 
  ConfigurationManager.GetSection("DBCopyService/entrances") 
    as EntranceSection;
        
foreach (EntranceElement element in entranceSection.Entrances)
  Console.WriteLine(
    string.Format("Path {0}, Mail {1}",
      element.Path,
      element.MailAddress));

Im vierten Teil meiner kleinen Serie zur überwachten Kopierfabrik, soll es nun darum gehen den Kopiervorgang in einen anderen Thread auszulagern. Das Problem ist nämlich, dass der lang anhaltende Kopiervorgang sonst das Erkennen weiterer Dateisystem-Ereignisse verhindert und der Dienst für die Zeit des Kopierens “eingefroren” ist. Um nun den Kopiervorgang “parallel” zu starten, kann man in C# 2.0 den sogenannten BackgroundWorker benutzen. Dieser bietet auf ganz einfache Weise die Möglichkeit ein lang andauernden Vorgang in einen Hintergrundthread zu verlagern und über Events sogar Fortschrittsmeldungen nach Außen zu geben. Im speziellen Fall des Kopierens könnte man also einfach von BackgroundWorker ableiten:

using System;
using System.Collections.Generic;
using System.Text;
using System.ComponentModel;
using System.IO;
using System.Diagnostics;

namespace DBCopyService
{
    /// <summary>
    /// This BackgroundWorker copies the file async 
    /// from source to target
    /// </summary>
    public class BackgroundCopyWorker : BackgroundWorker
    {
        private string sourceFile;
        private string targetFile;

        public BackgroundCopyWorker
          (string sourceFile, string targetFile) : base()
        {
            this.sourceFile = sourceFile;
            this.targetFile = targetFile;
            DoWork += new DoWorkEventHandler(bcw_DoWork);
            RunWorkerCompleted += 
               new RunWorkerCompletedEventHandler                
                 (bcw_RunWorkerCompleted);
            RunWorkerAsync();  // Start new Thread
        }

        void bcw_RunWorkerCompleted(
          object sender, RunWorkerCompletedEventArgs e)
        {
            Trace.WriteLine(string.Format("{0} copied to {1}", 
               sourceFile, targetFileName));
        }

        void bcw_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                Trace.WriteLine(string.Format("Copy {0} to {1}", 
                  sourceFile, targetFile));

                FileInfo SourceFile = new FileInfo(sourceFile);
                FileInfo TargetFile = new FileInfo(targetFile);

                SourceFile.CopyTo(TargetFile.FullName, true);
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.Message);
            }
        }
    }
}

Das Starten eines asyncronen Kopiervorgangs erfolgt dann ganz einfach über:

new BackgroundCopyWorker(originalFileName, targetFileName);

Steven Jean beschreibt in einem umfangreichen Artikel die Versionsverwaltungsfeatures des Team Foundation Server aus der Sicht von VSS-Nutzern. Er zeigt u.a. die veränderten Arbeitsabläufe und die neuen Sicherheitsfeatures die sich mit dem TFS ergeben. Eines der größten Vorteile aus meiner Sicht ist übrigens, dass beim Check-In die definierten Policies überprüft werden und so nur Code eingecheckt werden kann, der bestimmten selbstdefinierbaren Richtlinien entspricht.

Interessant in diesem Zusammenhang ist auch ein Channel 9 Video in dem John Lawrence, seines Zeichens Development Manager des “Visual Studio 2005 Team Foundation’s Source Code Management Teams”, interessante Anwendungsmöglichkeiten des Team Foundation Servers zeigt – zum Beispiel auch automatisch generierte RSS-Feeds mit den Bugmeldungen.

Letzte Woche aufgeschnappt:

“A mathematician is a person who can find analogies between theorems; a better mathematician is one who can see analogies between proofs and the best mathematician can notice analogies between theories. One can imagine that the ultimate mathematician is one who can see analogies between analogies.”

Stefan Banach – polnischer Mathematiker

Bei Google ist es Tradition, dass die Entwickler 20% ihrer Arbeitszeit (das ist ein ganzer Tag in der Woche) in Projekte stecken dürfen, die sie besonders interessieren und die so eigentlich nicht in ihrer Stellenbeschreibung stehen. Einige der neueren Google-Features (wie Gmail, Google News, AdSense und orkut) resultieren angeblich aus einigen dieser “überwachten” Hobbyprojekte. Nach Marissa Mayer, einer Abteilungsleiterin bei Google, kommen mittlerweile sogar 50% aller neuen Google-Features ursprünglich aus der “twenty percent”-Zeit.

Meiner Meinung nach ist das ein interessanter Ansatz, um den 5.ten Punkt (“Haben Sie Spaß an Ihrer Arbeit!”) meiner 10 Tipps für erfolgreiche Software-Entwicklung zu erfüllen und gleichzeitig der eigenen Firma auch noch Gewinn zu bringen – wie Google zeigt teilweise sogar extreme Gewinne.

Quellen:

1. http://en.wikipedia.org/wiki/Google
2. http://www.google.com/support/jobs/bin/static.py?page=about.html
3. http://www.google.com/jobs/reasons.html