Michael Niethammers Blog

4.11.2008

Daten per OleDB nach Excel ausgeben mit C#

Abgelegt unter: C#, Sonstiges — wmn @ 16:23
Über COM Interop kann man ja direkt auf Excel zugreifen. Hier kommt ein Beispiel , wie man Daten dorthin schreibt.

Beispiel stammt von hier:


http://dotnet-snippets.de/dns/excel-datatable-mittels-oledb-in-excel-dokument-exportieren-SID272.aspx(Autor Hagen Sigel)

C#

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

using System;

using System.Collections.Generic;

using System.Text;

using System.Data;

using System.Data.OleDb;

using System.Runtime.Remoting;

using System.Reflection;

using System.Runtime.InteropServices;

namespace Rainbird.Examples.Office.Excel.OLEDBAccess

{

    /// <summary>

    /// Exportiert den Inhalt einer DataTable in ein neues Excel-Dokument.

    /// </summary>

    public
class ExcelExport

    {

        /// <summary>

        /// Privater Standardkonstruktor.

        /// </summary>

        private ExcelExport() { }

        /// <summary>

        /// Schreibt das Schema einer bestimmten Tabelle in eine neue Excel-Datei.

        /// </summary>

        /// <param name=”table”>Tabelle</param>

        /// <param name=”fileName”>Dateiname</param>

        public
static
void WriteTableSchemaToExcelFile(DataTable table, string fileName)

        {

            // Excel im Hintergrund öffnen

            object excel = Activator.CreateInstance(Type.GetTypeFromProgID(”Excel.Application“));

            // Auflistung der Mappeen abrufen

            object books = excel.GetType().InvokeMember(”Workbooks“, BindingFlags.IgnoreCase | BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, excel, new
object[0]);

            // Neue Mappe erstellen

            object book = books.GetType().InvokeMember(”Add“, BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, books, new
object[0]);

            // Auflistung der Tabellenblätter abrufen

            object sheets = book.GetType().InvokeMember(”Sheets“, BindingFlags.IgnoreCase | BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, book, new
object[0]);

            // Neues Tabellenblatt erstellen

            object sheet = sheets.GetType().InvokeMember(”Add“, BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, sheets, new
object[0]);

            // Name des Tabellenblatts festlegen

            sheet.GetType().InvokeMember(”Name“, BindingFlags.SetProperty, null, sheet, new
object[1] { table.TableName });

            // Zähler

            int i = 0;

            // Spalten der Tabelle durchlaufen

            foreach (DataColumn column in table.Columns)

            {

                // Zähler erhöhen

                i++;

                // Feldnamen einfügen

                object range = sheet.GetType().InvokeMember(”Cells“, BindingFlags.GetProperty | BindingFlags.OptionalParamBinding, null, sheet, new
object[2] { 1, i });

                range.GetType().InvokeMember(”Value“, BindingFlags.SetProperty | BindingFlags.OptionalParamBinding, null, range, new
object[1] { column.ColumnName });

            }

            // Dokument speichern

            book.GetType().InvokeMember(”SaveAs“, BindingFlags.InvokeMethod | BindingFlags.OptionalParamBinding, null, book, new
object[1] { fileName });

            // COM-Verweise freigeben

            Marshal.ReleaseComObject(sheet);

            Marshal.ReleaseComObject(sheets);

            Marshal.ReleaseComObject(book);

            Marshal.ReleaseComObject(books);

            // Excel schließen

            excel.GetType().InvokeMember(”Quit“, BindingFlags.InvokeMethod, null, excel, new
object[0]);

            // Excel.Application COM-Verweis freigeben

            Marshal.ReleaseComObject(excel);

        }

        /// <summary>

        /// Erzeugt eine OLEDB-Verbindungszeichenfolge für ein bestimmtes Excel-Dokument.

        /// </summary>

        /// <param name=”fileName”>Dateiname (.XLS)</param>

        /// <returns>Verbindungszeichenfolge</returns>

        private
static
string BuidExcelConnectionString(string fileName)

        {

            // Verbindungszeichenfolge erzeugen un zurückgeben

            returnProvider=Microsoft.Jet.OLEDB.4.0;Data Source=” + fileName + “;Extended Properties=Excel 8.0“;

        }

        /// <summary>

        /// Erzeugt aus einer Tabelle ein Excel-Dokument.

        /// </summary>

        /// <param name=”table”>Tabelle</param>

        /// <param name=”fileName”>Dateiname des Ziel-Excel-Dokuments</param>

        public
static
void FillExcelSheet(DataTable table, string fileName)

        {

            // Neue leere Excel-Datei aus dem Tabellenschema erzeugen

            WriteTableSchemaToExcelFile(table, fileName);

            // Verbindungszeichenfolge erzeugen

            string connectionString = BuidExcelConnectionString(fileName);

            // Neue OLEDB-Verbindung erzeugen

            OleDbConnection connection = new OleDbConnection(connectionString);

            connection.Open();

            // String-Generator für Parameter erzeugen

            StringBuilder parameterBuilder = new StringBuilder(”) VALUES (“);

            // Spalten zählen

            int columnCount=table.Columns.Count;

            // INSERT SQL-Anweisung für Excel erzeugen

            StringBuilder builder = new StringBuilder(”INSERT INTO [“);

            builder.Append(table.TableName);

            builder.Append(”$] (“);

            // Alle Spalten durchlaufen

            for (int i = 0; i < columnCount; i++)

            {

                // Spaltennamen anfügen

                builder.Append(table.Columns[i].ColumnName);

                // Parameter anfügen

                parameterBuilder.Append(”?“);

                // Wenn eine weitere Spalte folgt …

                if (i < (columnCount - 1))

                {

                    // Kommas anfügen

                    builder.Append(”,“);

                    parameterBuilder.Append(”,“);

                }

            }

            // SQL-Anweisung fertigstellen

            builder.Append(parameterBuilder.ToString());

            builder.Append(”)“);

            string insertStatement = builder.ToString();

            // Preisliste durchlaufen

            foreach (DataRow row in table.Rows)

            {

                // Neuen OLEDB-Befehl erzeugen

                OleDbCommand command = new OleDbCommand(insertStatement, connection);

                // Alle Spalten durchlaufen

                foreach(DataColumn column in table.Columns)

                {

                    // Parameter übergeben                   

                    command.Parameters.Add(new OleDbParameter(column.ColumnName,row[column]));

                }

                // Befehl ausführen

                command.ExecuteNonQuery();

            }

            // Verbindung schließen

            connection.Close();

        }

    }

}

Assemblies signieren Schritt für Schritt

Abgelegt unter: C#, Visual Studio — admin @ 16:12

Mein Assembly bekommt einen starken Namen - Erstellen und Signieren einer Assembly mit strong name
Was ist ein ?Strong Name??

Ein Assembly, das mit dem Anwendungsverzeichnis ausgeliefert wird, benötigt in der Regel keinen besonderen Namen. Ein Assembly aber, das von mehreren Anwendungen gleichzeitig benutzt werden soll, braucht einen absolut eindeutigen Namen ? den sogenannten ?strong name? (starken Namen).
Dieser strong name ist ein einfacher Textstring, der sich aus dem Namen der Assembly, einem öffentlichen Schlüssel und einer digitalen Signatur zusammensetzt.
Ein strong name erfüllt folgende Anforderungen:
? Namenseindeutigkeit durch die Verwendung eindeutiger Schlüsselpaare
? Schutz der Versionsherkunft ? nur der Entwickler des Codes kann eine Folge-Version des Assemblies erstellen
? garantiert Integrität der Assembly
? Installation im Global Assembly Cache (GAC) möglich

Um die Vorteile eines Assemblies mit starkem Namen zu behalten und Dll-Konflikte zu vermeiden, können Assemblies mit strong name nur auf Assemblies mit strong name verweisen.

Wie erstelle ich eine Assembly mit einem starken Namen?
Um ein Assembly mit einem starken Namen zu erstellen, muß man zuerst ein Schlüsselpaar aus einem öffentlichen und einem privaten Schlüssel generieren.
Dafür gibt es das Kommandozeilen-Tool sn.exe im Verzeichnis %FrameworkSDK%\bin.
In der Eingabe aufforderung geben Sie folgenden Befehl ein:
Sn -k meinKey.snk
Es wird dabei ein Schlüsselpaar in der Datei meinKey.snk angelegt.
Dieses Schlüsselpaar muß dann der Assembly zugewiesen, d.h. signiert werden. Dafür haben Sie zwei verschiedene Möglichkeiten.

1. Signieren über Attribute unter Verwendung der Datei AssemblyInfo.vb bzw .cs:
[C#]
[assembly: AssemblyKeyFileAttribute(@”..\..\meinKey.snk”)]

Falls Sie eine IDE, z. B. Visual Studio .NET, verwenden, müssen Sie wissen, wo diese nach der Schlüsseldatei sucht. Visual Basic .NET sucht die Schlüsseldatei beispielsweise in dem Verzeichnis, in dem die Visual Studio-Projektmappe enthalten ist, wohingegen der C#-Compiler die Schlüsseldatei in dem Verzeichnis sucht, in dem die Binärdatei enthalten ist.

2. Signieren über die Nutzung des Kommandozeilen-Tools Assembly-Linker al.exe:
al /out:meinAssembly.dll meinModul.netmodule /keyfile:meinKey.snk

Bei beiden Möglichkeiten wird der öffentliche Schlüssel als sogenannter Token im Manifest der Assembly abgelegt. Ein Token ist ein Teilabschnitt des vollständigen öffentlichen Schlüssels und wird aus Platzgründen oft an Stelle des eigentlichen Schlüssels verwendet. Zusätzlich wird die Assembly mit dem privaten Schlüssel signiert. Diese Signatur ist wiederum Teil des Manifests.

Durch die Umkehrung der Signatur mit Hilfe des öffentlichen Schlüssels kann man nun sicher feststellen, ob eine Assembly auf dem Weg vom Autor zum Empfänger verändert wurde.
Somit kann kein Unbefugter den Code ändern, wenn er nicht im Besitz des vollständigen Schlüsselpaares ist.

Es ist zu empfehlen, ein Schlüsselpaar nur einmal für eine Firma bzw. für ein Projekt zu generieren und diese Datei, vor allem den privaten Schlüssel, gut unter Verschluß zu halten.

Da Sie eine Assembly nach dem Erstellen nicht mehr mit einem strong name signieren können, stellt sich die Frage, was ich als Entwickler tun kann, wenn ich gerade nur über den öffentlichen, nicht aber den privaten Schlüssel verfüge. Darauf gibt es eine einfache Antwort: das verzögerte Signieren.

Wie funktioniert das verzögerte Signieren?
Beim verzögerten Signieren (delayed signing) wird die Assembly vorerst nur teilweise signiert. Dabei wird nur der öffentliche Schlüssel verwendet. Für den privaten Schlüssel und die vollständige Signierung wir Platz reserviert.

Zuerst müssen Sie über den öffentlichen Schlüssel verfügen.

Sollten Sie über das vollständige Schlüsselpaar verfügen und das verzögerte Signieren aus einem anderen Grund anwenden wollen, können Sie den öffentlichen Schlüssel so aus der Schlüssel-Datei herausfiltern:
Sn -p meinKey.snk meinPublicKey.snk
meinPublicKey.snk enthält nun nur den öffentlichen Schlüssel der Datei meinKey.snk.

Nun fügen Sie der AssemblyInfo-Datei zwei benutzerdefinierte Attribute aus dem System.Reflection Namespace hinzu:

[C#]
[assembly:AssemblyKeyFileAttribute(”meinPublicKey.snk”)]
[assembly:AssemblyDelaySignAttribute(true)]

Dabei wird der Name der Datei mit dem öffentlichen Schlüssel angegeben und das verzögerte Signieren durch den Wert ?true? aktiviert.
Wird das Assembly dann kompiliert, ist es zwar nur teilweise signiert, besitzt aber einen starken Namen und kann im GAC installiert und dort verwendet werden.
Zuvor muß allerdings noch die Überprüfung der Signatur deaktiviert werden, da die Assembly ja über keine gültige starke Namenssignatur verfügt. Diese Deaktivierung können Sie wieder mit dem Strong Name-Tool vornehmen:

Sn -Vr meinAssembly.dll

Zu einem späteren Zeitpunkt, üblicherweise unmittelbar vor der Weitergabe, signieren Sie dann die Assembly mit dem kompletten Schlüsselpaar:

Sn -R meinAssembly.dll

Danach schalten Sie die Verifizierung für die Assembly wieder ein:

Sn -Vu meinAssembly.dll

Hinweis: Bei allen Optionen für Sn.exe wird die Groß- und Kleinschreibung beachtet. Eine vollständige Liste aller Optionen finden Sie in der .NET Framework SDK-Dokumentation unter dem Stichwort ’sn.exe’.

mit LINQ ein Verzeichnis auslesen

Abgelegt unter: C#, LINQ — admin @ 16:03


Mit LINQ kann man ja nun alle möglichen Datenquellen abfragen. Ein Beispiel dafür ist eine Abfrage auf ein Verzeichnis und dessen Inhalt:

 

var files = from file in new DirectoryInfo(@”C:\”).GetFiles()

            where file.Name.StartsWith(”_”)

            select file;

 

 

TFS Projekte komplett löschen

Abgelegt unter: TFS, Visual Studio — wmn @ 15:21

Auf dem Team Foundation Server ist das Löschen von Projekten irgendwie gar nicht vorgesehen. Jedenfalls geht es nicht auf direktem Weg.

- Im Sourcecontrolexplorer kann man nur Dateien aus der Quellcodeverwaltung löschen

- Mit dem Commandozeilentool tfdelete kann man nur die Quellcode-Dateien löschen

- Eines komplettes Team-Projekts lscht man mit dem Tool TfsDeleteProject

Warum diese Funktion nicht in der Oberfläche zur Verfügung steht bleibt weiter unklar. Wenigstens Administratoren sollten da ja eigentlich können. Vielleicht ist das ja Bestandteil der neuen Version.


Debugging von WPF Anwendungen

Abgelegt unter: C#, Visual Studio, WPF — wmn @ 15:15

WPF Anwendunggen sind ja derzeit nur recht umständlich zu debuggen. Inzwischen gibt’s ein Zusatztool namens Mole: Mole for WPF

Eine ausführliche Dokumentation, Link zu Videos und natürlich der Download selbst, ist auf CodeProject.com zu finden.

Das Tool ist dabei eine große Hilfe da man die aktuellen Werte sehen und verändern kann.

http Verkehr mit Fiddler analysieren

Abgelegt unter: Uncategorized — wmn @ 15:12

Fiddler ist ein HTTP Debugging Proxy. Damit kann der HTTP-Traffic mitsamt allem was dazugehört (Request- / Response-Headers, Bilder, CSS, …) analysiert werden.

Fiddler is freeware and can debug traffic from virtually any application, including Internet Explorer, Mozilla Firefox, Opera, and thousands more.

Fiddler ist eine Standalone-Software, alle Microsoft Programme d.h. Internet Explorer, Outlook Express, etc… sind automatisch so konfiguriert, dass der Verkehr analysiert werden kann.

Um auch den Verkehr mit Firefox analysieren zu können, muss dieser konfiguriert werden.

Erste Möglichkeit (Für Firefox):

  1. Fiddler installieren
  2. Zu “Eigene Dateien/Dokumente” navigieren, dort in den Ordner “Fiddler\Scripts” wechseln
  3. In diesem Verzeichnis gibt es eine Datei Namens “BrowserPAC.js
  4. Den kompletten Pfad mit der genannten Datei in die Zwischenablage kopieren
  5. Im Firefox auf Extras -> Einstellungen -> Erweitert
  6. Dort das Tab “Netzwerk” auswählen und im Verbindungsbereich auf “Einstellungen” klicken
  7. Im nächsten Fenster die Option “Automatische Proxy-Konfigurations-URL auswählen, den vorher kopierten Pfad (inkl. Dateinamen) einfügen und auf “Neu laden” klicken.

Ein solcher Pfad kann bspw. so lauten: C:/Users/<Benutzername>/Documents/Fiddler2/Scripts/BrowserPAC.js

Ab sofort wird auch der Verkehr mit Firefox im Fiddler analysiert.

Zweite Möglichkeit (Auch für alle andere Programme):

  1. Im Firefox ins selbe Menü wie oben wechseln
  2. “Manuelle Proxy-Konfiguration” auswählen und dort die IP “127.0.0.1″ und den Port “8888″ festlegen

Hierbei sollte die Einstellung nach der “Fiddler-Session” wieder rausgenommen werden.
Wichtig: Auch die automatische Konfiguration muss wieder herausgenommen werden, da Firefox ansonsten keine Verbindung herstellen kann (Wenn Fiddler nicht läuft).

Siehe auch:

Aus Universalthread: ShellObjects.Net 2008 released with full support for Visual Studio 2008 and Vista

Abgelegt unter: C#, Visual Studio — wmn @ 15:09

ShellObjects.Net 2008 is a set of components which allow your applications to create quick-launch like appbars with drag-docking and autohide functionality [ShellAppBar], display MSN/Office2003 style popups [ShellPopupNotification], create back-forward navigating wizards [Wizard], display Explorer-like progress dialogs [ShellProgressDialog], monitor system idle time [SystemIdleTimer], perform multiple file/folder operations with Explorer-like progress dialog support [ShellFileOperation], add automatic resizing and resolution-independence to your forms [Resizer], define and listen to system-wide hotkeys [ SystemHotkey], create system tray icons with support for animations, multiple icons and balloon styles [ShellNotiyIcon], display Vista-style task-dialogs [TaskDialog], SingleInstanceComponent, TaskScheduler library, shortcut/internet shortcut library and more. ShellObjects.Net is written in 100% C# managed code; it fully supports Visual Studio 2008 with Net 3.5/3.0 and Vista; it has a royalty-free redistribution license; it has no external dependencies and it comes with comprehensive documentation and numerous samples.

http://www.ssware.com/shlobj/shlobj.htm

Informationen zu den neuen LINQ DataServices

Abgelegt unter: C#, Visual Studio, LINQ — wmn @ 15:06

LINQ to SQL ist ja bisher nicht in der Lage gewesen in einer richtigen mehrschichtigen Architektur zu laufen. Seit kurzem sind die sogenannten DataServices von Microsoft released worden. Damit ist es dann möglich die Datenabfragen per http-Request an einen entfernten DataService Endpoint “auszulagern”.

Nähere Informationen findet man hier:

http://msdn.microsoft.com/en-us/library/cc956153.aspx

http://msdn.microsoft.com/en-us/library/cc907912.aspx

http://msdn.microsoft.com/en-us/library/cc907912.aspx


läuft stressfrei mit WordPress ( WordPress.de )