Asp.Net 2.0

ADO.Net und Excel

Sascha — Thu, 05 Jul 2007 19:51:49 GMT

Der Zugriff auf Exceldateien unter .Net 2.0 ist dank ADO.Net erstaunlich einfach. Dazu wird der OleDbProvider verwendet.

string connectionString = @"Provider=Microsoft.Jet.OLEDB.4.0;
    Data Source=D:\Excel\Workbook.xls;Extended Properties=""Excel 8.0;HDR=YES;""";

Dieser ConnectionString enthält den Speicherort der Datei und gibt an, dass die erste Zeile der Worksheets die Spaltennamen enthält.

Nachdem die Connection geöffnet ist, verhält sich alles, wie von ADO.Net gewohnt.
Mit Hilfe der GetSchema() Methode lassen sich Informationen zu den vorhandenen Tabellen (gleich Worksheets) und Spalten abrufen.

using (OleDbConnection connection = new OleDbConnection(connectionString))
{
    connection.Open();

    DataTable tables = connection.GetSchema("Tables");
    DataTable columns = connection.GetSchema("Columns");
}

In den nachfolgenden Screenshots sieht man die jeweilige DataTable mit den Schemainformationen im DataSet-Visualizer des Visual Studio Debuggers. Achtung: Excel hängt für den Tabellenname ein $ an den Namen des Worksheets. Hier: Worksheetname "Studenten" wird zu Tabelle "Studenten$".

Select-Abfragen funktionieren auch mit Parameter und das Ergebnis lässt sich an Steuerelemente binden.

OleDbCommand selectCommand = new OleDbCommand(
    "SELECT [MatrikelNr], [Vorname], [Nachname] FROM [Studenten$] " +
    "WHERE [Nachname] LIKE @Nachname", 
    connection);
selectCommand.Parameters.AddWithValue("Nachname", "A%");

OleDbDataAdapter adapter = new OleDbDataAdapter(selectCommand);

DataTable studenten = new DataTable();
adapter.Fill(studenten);

this.GridView1.DataSource = studenten;
this.GridView1.DataBind();

Auch die Insert- und Update-Commands funktionieren wie erwartet:

OleDbCommand insertCommand = new OleDbCommand(
    "INSERT INTO [Studenten$] ([MatrikelNr], [Vorname], [Nachname]) " +  
    "VALUES (@MatrikelNR, @Vorname, @Nachname)",
    connection);
insertCommand.Parameters.AddWithValue("MatrikelNr", "123459");
insertCommand.Parameters.AddWithValue("Vorname", "Bert");
insertCommand.Parameters.AddWithValue("Nachname", "Becker");
int rowsAffected = insertCommand.ExecuteNonQuery();

Access Datenbank mit relativem Pfad aus web.config öffnen

Sascha — Mon, 02 Jul 2007 21:37:22 GMT

Das hat mich einige Zeit gekostet: per Code eine OleDbConnection zu einer Access Datenbank zu öffnen, die im ConnectionStrings-Abschnitt der web.config Datei mit einem relativen Pfad konfiguriert ist.

Während das AccessDataSource Control in der DataFile-Eigenschaft eine relative Pfadangabe wie

DataFile="~/App_Data/datenbank.mdb"

richtig umzusetzen weiß, funktioniert das nicht mir einer Connection, die in der web.config konfiguriert ist. Obwohl "DataSource=<absoluter Datenbankpfad>" einwandfrei funktioniert, brachten weder

<connectionStrings>
    <add name="DatenbankConnectionString" 
        connectionString="Provider=Microsoft.Jet.OLEDB.4.0;
        DataSource=~App_Data/datenbank.mdb"
        providerName="System.Data.OleDb"/>
</connectionStrings>

noch folgende Variationen des ConnectionStrings den gewünschten Erfolg:

connectionString="Provider=Microsoft.Jet.OLEDB.4.0;
    Data File=~App_Data/datenbank.mdb"

connectionString="Provider=Microsoft.Jet.OLEDB.4.0;
    DataFile=~App_Data/datenbank.mdb"

Die Lösung:

"~App_Data/" muss im ConnectionString der web.config Datei durch "|DataDirectory|" ersetzt werden.

<connectionStrings>
  <add name="DatenbankConnectionString" 
    connectionString="Provider=Microsoft.Jet.OLEDB.4.0;
    Data Source=|DataDirectory|datenbank.mdb" 
    providerName="System.Data.OleDb"/>
</connectionStrings>

Dann lässt sich eine OleDbConnection im Code mit

OleDbConnection db = new OleDbConnection(
    ConfigurationManager.ConnectionStrings["DatenbankConnectionString"].ConnectionString);
db.Open();

wie gewünscht öffnen.

Das gleiche gilt auch für Verbindungen zu SQLExpress-Datenbanken.

SelfSSL - eigene Zertifikate auf die Schnelle

Sascha — Thu, 12 Apr 2007 18:44:07 GMT

Nicht immer hat man für die Entwicklungsumgebung ein Serverzertifikat zur Hand, mit dem sich eine SSL-verschlüsselte Website testen lässt. Mit SelfSSL aus den Internet Information Services (IIS) 6.0 Resource Kit Tools hat man sich schnell selbst ein Zertifikat erstellt und in IIS importiert. Nach der Installation der Resource Kit Tools auf dem Webserver, lässt sich SelfSSL über das Startmenü aufrufen. Genauer gesagt, wird eine Kommandozeile mit einem Hilfetext geöffnet.

Die Standardeinstellungen sind ausreichend, also das Tool mit selfSSL aufrufen, die Nachfrage für die Installation des Zertifikats in der Standardwebsite des IIS bestätigen. - Das war's. Im Webbrowser kann die Installation mit https://<computername> überprüft werden.

Da wir uns das Zertifikat selbst ausgestellt haben, werden alle gängigen Webbrowser eine Warnmeldung ausgeben. Die Funktionalität wird durch diese Meldung aber nicht beeinträchtigt. Selbst ausgestellte Zertifikate sollten aber nur in der Testumgebung verwendet werden.

Konfiguration in ASP.NET 2.0 - Nachtrag

Sascha — Mon, 24 Jul 2006 08:41:45 GMT

Verwendung von benutzerdefinierten Konfigurationsabschnitten mit verschachtelten Elementen.

<demoConfiguration oneStringProperty="Ein Textwert!" oneNumericProperty="25">
    <demoSubElement anotherStringProperty="SubElement Property" />
</demoConfiguration>

Wenn die Konfiguration verschachtelte Elemente enthalten muß, wird das Subelement in einer Eigenschaft in der Elternklasse mit dem ConfigurationProperty Attribut gekennzeichnet. Wichtig ist hier der Cast auf den Typ des Subelements beim Lesen der Eigenschaft.

[ConfigurationProperty("demoSubElement")]
public DemoSubElement DemoSubElement
{
get { return (DemoSubElement)this["demoSubElement"]; }
set { this["demoSubElement"] = value; }
}

Das Subelement selbst wird in einer neuen Klasse abgebildet, die von System.Configuration.ConfigurationElement abgeleitet wird. Die Eigenschaften dieser Klasse werden wie gehabt mit ConfigurationProperty Attributen auf die entsprechenden Attribute in der .config-Datei gemappt.

public class DemoSubElement : ConfigurationElement
{
    [ConfigurationProperty("anotherStringProperty", DefaultValue = "Standardwert", IsRequired = true)]
public string AnotherStringProperty
    {
get { return this["anotherStringProperty"].ToString(); }
set { this["anotherStringProperty"] = value; }
    }
}

Auf der Webseite ist das neue Subelement jetzt verwendbar.

WebConfigurationCustom.DemoSection dc =
(DemoSection)WebConfigurationManager.GetSection("demoConfiguration");
string prop = dc.DemoSubElement.AnotherStringProperty; // = "SubElement Property"

Konfiguration in ASP.NET 2.0

Sascha — Thu, 20 Jul 2006 14:40:45 GMT

Konfiguriert wird immer, daher hier eine kleine Auffrischung.

Die in den Beispielen verwendete web.config:

<?xml version="1.0"?>
<configuration>
    <configSections>
        <section name="demoConfiguration" type="WebConfigurationCustom.DemoSection, WebConfigurationCustom"/>
    </configSections>
    <demoConfiguration oneStringProperty="Ein Textwert" oneNumericProperty="25">
    </demoConfiguration>
    <appSettings>
        <add key="OneSetting" value="http://www.OneUrl.com/services/OneService.asmx" />
        <add key="AnotherSetting" value="http://www.AnotherUrl.com/services/AnotherService.asmx" />
    </appSettings>
    <connectionStrings>
        <add name="AdventureWorksConnectionString"
            connectionString="Data Source=COMPANION\SQL2005;Initial Catalog=AdventureWorks;Integrated Security=True"
            providerName="System.Data.SqlClient" />
    </connectionStrings>
    <system.web>
        <compilation debug="true"/>
        <authentication mode="Windows"/>
    </system.web>
</configuration>

Die Application Settings sind schon von NET 1.1 bekannt. Der Zugriff erfolgt jetzt über die ConfigurationManager Klasse.

string setting = ConfigurationManager.AppSettings["OneSetting"].ToString();

Neu ist der Konfigurationsabschnitt für Verbindungszeichenfolgen. Im connectionStrings Element der .config-Datei werden alle Datenbankverbindungen abgespeichert. Zugriff darauf gewährt ebenfalls die ConfigurationManager Klasse.

string connInfo = ConfigurationManager.ConnectionStrings["AdventureWorksConnectionString"].ProviderName
+ "\r\n" + ConfigurationManager.ConnectionStrings["AdventureWorksConnectionString"].ConnectionString;

Um auf die übrigen Konfigurationsabschnitte der web.config Datei zuzugreifen, wird für ASP.NET Anwendungen die WebConfigurationManager Klasse im System.Web.Configuration Namespace verwendet.

Die Configuration Klasse ist der Ausgangspunkt beim Zugriff auf die Konfigurationsdatei einer Anwendung. Sie bietet ebenfalls Zugriff auf die Application Settings und den Abschnitt für Connection Strings. Darüber hinaus kann man von ihr aber auch für jeden anderen Konfigurationsabschnitt in der web.config Datei ein passendes Section Objekt bekommen.

Nachfolgendes Beispiel liest den Authentifizierungsmodus ("Windows") aus der Konfigurationsdatei.

using System.Web.Configuration;
…
// den Pfad zur web.config im gleichen Verzeichnis basteln
String path = Request.CurrentExecutionFilePath;
path = path.Substring(0, path.LastIndexOf('/'));
// Configuration öffnen
Configuration config = WebConfigurationManager.OpenWebConfiguration(path);
// Authentication Section, Cast erforderlich
AuthenticationSection auth = (AuthenticationSection)config.GetSection("system.web/authentication");
string authInfo = string.Format("Authentication Mode: {0}",auth.Mode.ToString());

Genauso funktioniert das auch für andere Bereiche der Konfigurationsdatei. Der GetSection Methode den Pfad mitgeben und die Rückgabe entsprechend casten (CompilationSection, PagesSection, …)

Eine Section Klasse für den benutzerdefinierten Konfigurationsabschnitt demoConfiguration ist schnell erstellt. Eine Klassenbibliothek WebConfigurationCustom hinzufügen und darin eine Klasse DemoSection erzeugen, die von System.Configuration.ConfigurationSection erbt. Über das ConfigurationProperty Attribut wird die Zuordnung von Attributen und Elementen in der .config-Datei auf die Eigenschaften der Klasse hergestellt. Das wars.

using System.Configuration;
namespace WebConfigurationCustom
{
    public class DemoSection : ConfigurationSection
    {
        [ConfigurationProperty("oneStringProperty", DefaultValue = "Standardwert", IsRequired = true)]
        public string OneStringProperty
        {
            get { return this["oneStringProperty"].ToString(); }
            set { this["oneStringProperty"] = value; }
        }
        [ConfigurationProperty("oneNumericProperty", DefaultValue = 666, IsRequired = false)]
        public int OneNumericProperty
        {
            get { return (int)this["oneNumericProperty"]; }
            set { this["oneNumericProperty"] = value; }
        }
    }
}

In der web.config muß nun die neue Section im Abschnitt configSections noch bekanntgegeben werden.

<section name="demoConfiguration" type="WebConfigurationCustom.DemoSection, WebConfigurationCustom"/>

Der Typ wird dabei als "Namespace.KlassenName, AssemblyName" angegeben. Auf der Webseite kann jetzt auf den neuen Konfigurationsabschnitt zugegriffen werden.

WebConfigurationCustom.DemoSection dc =
(DemoSection)WebConfigurationManager.GetSection("demoConfiguration");
string prop = dc.OneStringProperty; // = "Ein Textwert"

Einen guten Überblick mit vielen Beispielen zur Konfiguration von ASP.NET 2.0 im Allgemeinen und auch zur Verwendung der Management API gibt es unter http://www.asp.net/QuickStart/aspnet/doc/management/default.aspx