.NET und PDF Software

Bei der Suche nach einem praktischen SQL-Skript für eine Statistik, bin ich auf die Möglichkeit gestoßen, den SQL Count Befehl zu verwenden:

SELECT a.BewertungId, 	
 COUNT(*) Gesamt,
 COUNT(E_Datum) Offen, 
 COUNT(CASE WHEN ((a.Abgelehnt = 0) OR (b.OFI = 0)) THEN NULL ELSE 1 END) Abgelehnt
FROM Aktivitaeten a, Bewertung b
WHERE a.BewertungId = b.Id
GROUP BY a.BewertungId
ORDER BY a.BewertungId

Die Nutzungsmöglichkeit des COUNTs ist dabei vielfältig:

• Üblicherweise wird Count mit dem Parameter (*) aufgerufen. Dieser Aufruf führt zur vollständigen Zählung der Datenmenge.
• Gibt man aber als Parameter einen Spaltennamen ein, so werden nur die Datensätze gezählt, die in der gewünschten Spalte einen Eintrag ungleich NULL haben.
• Aber auch die Angabe eines Ausdrucks, der NULL oder einen Wert liefert, ist möglich.

Das aufgeführte Beispiel zählt also auf einmal: alle Datensätze, alle Datensätze mit einem Eintrag in der Spalte E_Datum und als letzten Punkt alle Datensätze, die eine Ablehnung enthalten.

Bei dem Security Update for Microsoft Visual Studio 2008 Service Pack 1 (KB971092) zeigten sich auf meinem Rechner massive Installationsprobleme. Das Update scheint sich problemlos zu installieren, es wird aber immer wieder angeboten. Nach einigem Suchen scheint das Problem darin zu liegen, dass ich die C++ Komponenten nicht mit installiert habe.

Aber es sich auch schon Workarounds verfügbar:

• Herunterladen der VS90SP1-KB971092-x86.exe
• Installation der VS90SP1-KB971092-x86.exe starten und den Pfad merken, wohin die Dateien entpackt werden.
• Auf die Fehlermeldung warten und das Fehlerfenster unbedingt offen lassen!
• In den Ordner der entpackten Dateien gehen und den Inhalt in einen anderen Ordner kopieren
• Die Fehlermeldung und Installation beenden
• {Program Files}\Microsoft Visual Studio 9.0\Common7\Tools öffnen und die Datei vsvars32.bat suchen
• Die Rechte dieser Datei auf „Jeder kann ändern“ stellen
• Die VS90SP1-KB971092-x86.msp aus dem kopierten Ordner starten
• Die Sicherheiten der Datei vsvars32.bat wieder zurück setzen

Seit geraumer Zeit zeigte die Code-Vervollständigung unter C# folgendes Bild:

Dabei sind viele unnütze if-Kombination zu sehen, welche sich auf vorhandene Namespace-Definitionen beziehen. Nach längerer Suche konnte ich den Verursacher ausmachen. Ich verwende in den betroffenen Projekten VistaDB. In der Version 3.5 build 84 wurde die Library mittels Obfuscation unleserlich gemacht. Leider hat genau diese Verschlüsselung der Bibliothek den Effekt, dass jedes nicht öffentliche Objekt in einen eigenen neuen Namespace gelegt wird, hier also beispielsweise:

if
If
IF
@if

Diese Namespace-Definitionen bietet der Resharper per Code-Vervollständigung. Leider steht sowohl seitens VistaDB als auch seitens JetBrains eine Lösung noch aus.

Bei der Installation vom SQL-Server 2008 und dem dafür notwendigen .NET Framework 3.5 hatte ich auf einem virtuellen Windows 2003 Webserver unerwartete Problem. Keine der Installation funktionierte, obwohl der Server zuvor frisch initialisiert wurde.
Nach einiger Suche bin ich dann doch noch in einem anderen Blog fündig geworden.

Die Probleme treten in der Kombination Windows Server 2003 x64 SP2 und Virtuozzo scheinbar reproduzierbar auf. Der Installer des .NET Frameworks schließt mit Fehlern der Art

XPSEPSC x64 Installer: [2] Error code 1603
 for this component means "Fatal error during installation."

ab. Die Aktualisierung vom Windows-Installer oder das Setup der Powershell melden Probleme beim Cryptographic-Dienst.

Geholfen hat letztendlich:

• das Starten des Printer Spooler-Dienstes
• das Umbennen des System32\Catroot2-Verzeichnises nach dem Neustart des Viruozzo-Panels

Danach liefen alle Installation ohne Probleme.

Aber: So ganz sicher, damit eine langfristig sinnvolle Lösung gefunden zu haben, bin ich mir nicht. 1&1 schreibt dazu in der Hilfe sinngemäß, dass von der Installation von Hotfixes und Windows Updates abzusehen sei. Grund können Versionsprobleme im Zusammenspiel mit Aktualisierungen von Virtuozzo sein.

Evtl. habe ich so nur einen Weg gefunden, die Absicherung von Virtuozzo zur Verhinderung von Windows-Updates zu umgehen. Mir war das auf lange Sicht für ein Produktivsystem zu riskant.

Zur Zeit findet auf der MSDN ein Gewinnspiel statt. Darin wird man aufgefordert, einen Beitrag über seine 3 besten Entwicklungstools zu erstellen. Hier kommt meine Liste:

1. JetBrains ReSharper
Der ungeschlagene Favorit ist der ReSharper. Das Tool bietet einmal die Hervorhebung der aktuellen Zeile im Source (klingt trivial, ist mir aber wichtig). Weiterhin prüft und korrigiert es die Groß/Kleinschreibung, was den Source lesbarer macht. Es hat zudem unheimlich mächtige Navigationsfeatures (in Ableitungen springen…) und bietet eine Funktion, um alle Aufrufe einer Funktion/Property/Klasse einfach zu finden.

2. SQL Server Management Studio
Das Management-Studio ist die Software, wenn eine Datenbank für den SQL-Server administriert wird. Was das Tool so wertvoll macht, ist die unheimliche Geschwindkeit, mit der Datenbanken auch übers Web administriert werden können.

3. .NET Reflector
Wenn man unerklärlichen Problemen auf die Spur kommen möchte, oder Warnung nicht versteht, hilft manchmal der Blick in den Reflektor. Damit kann man die wirkliche Umsetzung des Kompilats nachvollziehen und auch ohne Source gelieferte Anwendungen teilweise einfach nachvollziehen.

Windows 64 Bit setzt sich in Zeiten fallender RAM-Preise immer mehr durch, als Vista64. Bei dem Zugriff auf die Registry stolpert man dabei aber über ungeahnte Probleme.

32Bit Programme legen Ihre Einträge nämlich nicht in der normalen Registry ab, sondern im Unterschlüssel Wow6432Node (wird von Windows umgeleitet):

Was bedeutet das für eigene Programme:
Möchte man von einem 64-Bit Programm aus auf Einstellungen eines 32-Bit Programms zugreifen, ist der Unterschlüssel Wow6432Node zu öffnen. Will man von einem 32-Bit Programm Einstellungen eines 64-Bit Programms auslesen, so steht man vor einem Problem. Will man auf die 64-Bit Schlüssel zugreifen, so muss man die Registry mit speziellen Parametern öffnen. Für Delphi findet man eine Lösung in Delphi-PRAXIS. Für .NET ist die Sache erstaunlicherweise komplizierter.

Wer immer wieder auf 2 Computern gleichzeitig arbeitet, vermisst evtl. auch die einfache Übertragung der Zwischenablage zwischen diesen PCs. Ich habe dafür das Tool Ditto clipboard manager entdeckt, was meiner Meinung nach eine ideale Möglichkeit bietet, die Zwischenablage aufzubohren.

Ditto kann unter SourceForge direkt herunter geladen werden. Es handelt sich dabei um ein Archiv, welches ich direkt in meine Eigenen Dateien entpackt habe, da eine Datenbank im Programmverzeichnis von Ditto schreibbar sein muss. Nach dem Start erscheint das Tool im Tray und kann in den Eigenschaften auch auf Deutsch umgestellt werden.

Zur Grundfunktion: Ditto überwacht nach dem Start automatisch die Zwischenablage und sichert diese auch automatisch in einer Datenbank (letzte 500 Einträge, letzte 5 Tage). Systemweit wird der Hotkey Strg + ö registriert. Man kann also etwas in die Zwischenablage nehmen, irgendwo hin wechseln, Strg + ö drücken und beispielsweise den vorletzten Eintrag einfügen.

Standardmäßig werden nur einige Text-Typen überwacht, dieses kann man aber in den Einstellungen von Ditto unter Unterstützte Typen einstellen. Sinnvoll ist dazu, wenn ein zu überwachender Inhalt bereits in der Zwischenablage ist, dann ist der Typ direkt wählbar:

Interessant wird es auf der Konfigurationsseite Freunde:

Soll der betreffende PC Zwischenablage-Inhalte empfangen können, so muss die Option Empfang von Ausschnitten deaktivieren entfernt werden! Dann muss im unteren Abschnitt der PC, an den Zwischenablagen-Inhalt einzeln oder permanent übertragen werden, konfiguriert werden:

Fertig: Ist alles korrekt eingestellt, überträgt ein PC seine aufgefangenen Inhalt der Zwischenablage automatisch an eine weitere Instanz von Ditto im Netzwerk. Das ganze macht das Übertragen von Komponenten im Designer fast zum Kinderspiel…

Möchte man Listen (System.Collection.Generic.List<>) an Comboboxen mittels einer Master-Detail-Beziehung anbinden, so bietet sich die hier dargestellte Vorgehensweise an.

Code der Listen:

    public class Detail
    {
        public String Caption { get; set; }
        public int Id { get; set; }
 
        public Detail(string caption)
        {
            Caption = caption;
        }
    }
 
    public class DetailList: List<Detail>
    {
        public String DetailListCaption { get; set; }
 
        public DetailList(string masterCaption)
        {
            DetailListCaption = masterCaption;
        }
    }
 
    public class Master: List<DetailList>
    { }

Zur Anwendung wird die Liste bespielhaft befüllt:

    private Master master = new Master();
...
    master.Add(new DetailList("Cap Master 1"));
    master.Add(new DetailList("Cap Master 2"));
 
    master[0].Add(new Detail("Cap Detail 1.1"));
    master[0].Add(new Detail("Cap Detail 1.2"));
    master[1].Add(new Detail("Cap Detail 2.1"));
    master[1].Add(new Detail("Cap Detail 2.2"));

Nun werden noch zwei BindingSource-Komponenten erzeugt und initialisiert:

    masterBindingSource = new BindingSource {DataSource = typeof (Master)};
    comboBox1.DataSource = masterBindingSource;
    comboBox1.DisplayMember = "DetailListCaption";
 
    detailBindingSource = new BindingSource {DataSource = typeof (DetailList)};
    comboBox2.DataSource = detailBindingSource;
    comboBox2.DisplayMember = "Caption";
 
    masterBindingSource.CurrentChanged += masterBindingSource_CurrentChanged;
...
    private void masterBindingSource_CurrentChanged(object sender, EventArgs e)
    {
        detailBindingSource.DataSource = masterBindingSource.Current;
    }

Wichtig ist dann nur noch die Initialisierung der Datasource mit einem konkreten Wert:

    masterBindingSource.DataSource = master;

Es gibt in Microsoft .NET alle gebräuchlichen Möglichkeiten, Zahlen zu runden:

using System;
 
namespace RoundTest
{
    class Program
    {
        static void TestOutput(double value)
        {
            Console.WriteLine();
            Console.Write(value);
            Console.Write("\t Truncate: " + Convert.ToInt32(Math.Truncate(value)));
            Console.Write("\t Ceiling : " + Convert.ToInt32(Math.Ceiling(value)));
            Console.Write("\t RoundAFZ: " + Convert.ToInt32(Math.Round(value, MidpointRounding.AwayFromZero)));
            Console.Write("\t RoundToE: " + Convert.ToInt32(Math.Round(value, MidpointRounding.ToEven)));
        }
 
        static void Main(string[] args)
        {
            TestOutput(10.0);
            // ...
            TestOutput(-10.51);
            Console.ReadLine();
        }
    }
}

Hier ist die Ergebnisausgabe davon zu finden:

10       Truncate: 10    Ceiling : 10    RoundAFZ: 10    RoundToE: 10
10,49    Truncate: 10    Ceiling : 11    RoundAFZ: 10    RoundToE: 10
10,5     Truncate: 10    Ceiling : 11    RoundAFZ: 11    RoundToE: 10
10,51    Truncate: 10    Ceiling : 11    RoundAFZ: 11    RoundToE: 11
 
-10      Truncate: -10   Ceiling : -10   RoundAFZ: -10   RoundToE: -10
-10,49   Truncate: -10   Ceiling : -10   RoundAFZ: -10   RoundToE: -10
-10,5    Truncate: -10   Ceiling : -10   RoundAFZ: -11   RoundToE: -10
-10,51   Truncate: -10   Ceiling : -10   RoundAFZ: -11   RoundToE: -11

Möchte man Extensions in C# verwenden, scheint man auf das 3er Net-Framework angewiesen zu sein. Dies ist aber nicht ganz richtig. Legt man folgende Klasse in dem Projekt an:

namespace System.Runtime.CompilerServices
{
    public class ExtensionAttribute : Attribute {}
}

so kann man Extensions, eine 3er Compiler vorrausgesetzt (VS2008), problemlos mit dem .NET Framework 2 als Ziel verwenden.