Excel mit C# lesen
In einem Ferialpraktikum hatte ich einmal das Problem, dass ich eine Exceldatei aus einer C# Anwendung lesen musste. Dazu habe ich mir 2 Klassen geschrieben. myExcelApplication, welches mir eine Instanz von Microsoft Excel öffnet und nach Beendigung wieder schließt. Und myWorkbook, welche mir den Zugriff auf ein Workbook ermöglicht.
Wichtig sind vor allem die Referenzen. Man muss Microsoft.Office.Core sowie Microsoft.Office.Interop.Excel einbinden, damit es sicher funktioniert 
using System; using System.Collections.Generic; using System.Text; using System.Windows.Forms; using Excel = Microsoft.Office.Interop.Excel; using System.Runtime.InteropServices; //Für DllImport! using System.Diagnostics; //Für Process
myExcelApplication:
public class myExcelApplication : IDisposable
{
#region user32 Funktionen
// Windows OS Funktionen deklarieren
[DllImport("user32")]
private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
[DllImport("user32.dll", SetLastError = true)]
static extern uint GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);
// Ende Os Funktionen
#endregion
public Excel.ApplicationClass ExApp; //Besitzt alle Excelfunktionen
private string ApplicationID; //Ist meine Programmid
private IntPtr hWnd; // Window Handle
private int iProcID; // Prozess ID des markierten EXCELs
private Process p = null; // entsprechendes Process object
public myExcelApplication()
{
//defaulteinstellungen
System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
this.ApplicationID = "Excel_" + System.Guid.NewGuid().ToString().ToUpper(); //ID erzeugen
this.ExApp = new Excel.ApplicationClass(); //Excelklasse zuweisen
this.ExApp.DisplayAlerts = false; //keine Warnmeldungen Anzeigen
this.ExApp.AskToUpdateLinks = false; //Updateabfrage deaktivieren
this.ExApp.Visible = false; //unsichtbar
this.ExApp.Caption = this.ApplicationID; //Id zuweisen
}
~myExcelApplication()
{
this.Dispose();
}
#region IDisposable Members
public void Dispose()
{
/*
* Folgendes funktioniert nicht:
* ExApp.Application.Quit(); oder this.ExApp.Quit();
* Leider weiß ich nicht mehr woher ich das habe.
* Aber deswegen haben wir die EXCEL Applikation markiert
*/
hWnd = FindWindow(null, ApplicationID);
if (hWnd == IntPtr.Zero) return;
// zu dem Fenster holen wir uns die Prozess-ID ...
GetWindowThreadProcessId(hWnd, out iProcID);
if (iProcID == 0) return;
// erzeugen ein entsprechendes .NET Prozess Objekt ..
p = Process.GetProcessById((int)iProcID);
if (p == null) return;
// jetzt ist Feierabend ...
p.CloseMainWindow(); // schliesse Fenster
p.Refresh(); // gebe alle Prozess-Informationen frei
if (p != null)
{
p.Kill(); // und tschuess ...
}
}
#endregion
}
myWorkbook:
public class myWorkbook
{
public Excel.Workbook myWb;
public string Datei;
public myExcelApplication ExApp;
public bool schreibschutz = false;
private bool _calculation;
public bool calculation
{
get { return this._calculation; }
set
{
this._calculation = value;
this.calculate();
}
}
public string aktivsheet;
public myWorkbook(string datei, myExcelApplication EApp)
{
this.Datei = datei;
this.ExApp = EApp;
}
public myWorkbook()
{
//leerer konstruktor
}
public void open()
{
try
{
this.myWb = ExApp.ExApp.Workbooks.Open(this.Datei, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing, Type.Missing);
}
catch (Exception e)
{
//
}
//this.myWb = ExApp.ExApp.Workbooks.Open(this.Datei, 0, true, 5, "", "", true,Excel.XlPlatform.xlWindows, "t", false, false, 0, true, false, false);
if (this.myWb.ReadOnly) { this.schreibschutz = true; }
this.calculation = false; //Abschalten der automatischen Berechnung
}
public void close()
{
object Save = Excel.XlSaveAction.xlSaveChanges; //Speichern oder nicht speichern Variable hier setzen
this.calculation = true; //Noch einmal schnell rechnen lassen vorm schließen
this.myWb.Close(Save, Type.Missing, Type.Missing); //schließen
}
private void calculate()
{
//Schaltet automatische Berechnung ab bzw. aktiviert sie wieder
if (!this.calculation)
{
this.ExApp.ExApp.Calculation = Excel.XlCalculation.xlCalculationManual;
}
else
{
this.ExApp.ExApp.Calculation = Excel.XlCalculation.xlCalculationAutomatic;
this.ExApp.ExApp.Calculate();
}
}
public Excel.Range Zelle(int Zeile, int Spalte)
{
return (Excel.Range)((Excel.Worksheet)this.myWb.Worksheets[this.aktivsheet]).Cells[Zeile, Spalte];
}
public Excel.Range Zelle(int Zeile, int Spalte, string Worksheet)
{
return (Excel.Range)((Excel.Worksheet)this.myWb.Worksheets[Worksheet]).Cells[Zeile, Spalte];
}
}
Hier ein Beispiel, wie man mit diesen Klassen, die Erste Zelle des Blattes “Tabelle1″ auslesen kann:
//Applikation starten
myExcelApplication EApp = new myExcelApplication();
//Workbook erzeugen
myWorkbook ExcelFile = new myWorkbook("c:\test.xls", EApp);
//Excelfile öffnen
ExcelFile.open();
//Sheet wählen
ExcelFile.aktivsheet = "Tabelle1";
//Zeile auslesen
String zelle1 = ExcelFile.Zelle(1, 1).Value2;
//Workbook schließen
ExcelFile.close();
//Applikation schließen
EApp.Dispose();
Tipp: Schaltet die automatische Berechnung von Zellen ab und erst kurz vorm speichern wieder an. Das spart oftmals wertvolle Rechenzeit
AJAX light – Kleine Abfragen ohne großes Framework
AJAX ist eine nette Sache! Dieses Akronym steht für „Asynchronous JavaScript and XML“ und ermöglicht unter anderem dynamisches Nachladen von Inhalten in die HTML Seite. Wer sich ganz genau dafür interessiert, kann ja auf WIKIPEDIA nachschauen
Natürlich findet man jetzt eine große Menge an Bibliotheken die man nutzen kann und sollte, aber hier möchte ich euch eine Quick and Dirty Lösung zeigen.
//AJAX Initialisieren und Funktionen zur Handhabung
var request = false;
// Request senden
function setRequest(url,send,irfunction) {
// Request erzeugen
if (window.XMLHttpRequest) {
request = new XMLHttpRequest(); // Mozilla, Safari, Opera
} else if (window.ActiveXObject) {
try {
request = new ActiveXObject('Msxml2.XMLHTTP'); // IE 5
} catch (e) {
try {
request = new ActiveXObject('Microsoft.XMLHTTP'); // IE 6
} catch (e) {}
}
}
// überprüfen, ob Request erzeugt wurde
if (!request) {
alert("Kann keine XMLHTTP-Instanz erzeugen");
return false;
} else {
// Request öffnen
request.open('post', url, true);
// Requestheader senden
request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')
// Request senden
request.send(send);
// Request auswerten
request.onreadystatechange = function() {
interpretRequest(irfunction);
}
}
}
// Request auswerten
function interpretRequest(irfunction) {
switch (request.readyState) {
// wenn der readyState 4 und der request.status 200 ist, dann ist alles korrekt gelaufen
case 4:
if (request.status != 200) {
alert("Der Request wurde abgeschlossen, ist aber nicht OKnFehler:"+request.status);
} else {
irfunction();
}
break;
default:
break;
}
}
//ENDE AJAX Funktionen
Wie verwendet man diese Funktionen nun richtig?
Angenommen wir haben eine Formular bei dem sich ein User registrieren muss und wir wollen checken ob der Nick schon vorhanden ist.
Dazu verwenden wir eine PHP Datei, die auf im selben Ordner liegt und abfrage.php heißt. Diese macht uns eine MYSQL Abfrage und liefert uns dann false zurück, wenn der Nickname schon vorhanden ist. Die 2 JavaScript Funktionen die wir zusätzlich noch in der HTML Datei brauchen sind folgende:
function check_name(nick) {
//Request abschicken mit Post Variable Nickname
setRequest("/abfrage.php","nickname="+nick,check_name_finish);
}
function check_name_finish() {
var content = request.responseText;
//Do something
}
Die Funktion check_name(nick) wird vom Inputfeld aufgerufen, wenn dieses nicht mehr beschrieben wird. (siehe Code vom Inputfeld). Ist Funktion check_name(nick) mit der Ausführung fertig, wird Funktion check_name_finish() aufgerufen und ausgeführt. Diese hat nun in der Variable content die Antwort der Abfrage und kann nun darauf reagieren.
Und das Inputfeld würde so aussehen:
<input type="text" name="nickname" value="" onblur="check_name(this.value)">
Wie bereits erwähnt ist das hier nur Quick and Dirty! Getestet habe ich es mit den neuesten Versionen von IE und FireFox. Viel Spass damit!
Variable Variablennamen in PHP
Ofmals kann es sehr Hilfreich sein, wenn man die Variablennamen variabel angeben kann. Dies ist in PHP sehr einfach möglich indem man noch ein zusätzliches $ vorransetzt.
$var = "test"; $test = "Hallo"; echo $$var;
Dieses Beispiel liefert ein schönes “Hallo” zurück.
Das ganze kann man sogar noch besser nutzen!
Besitzt man zum Beispiel mehrere Variablen die sich nur am Schluss durch eine Zahl unterscheiden (z.b.: Feld1, Feld2, Feld3, Feld4) so kann man diese schnell in ein Array umwandeln!
$Feld1 = "Das";
$Feld2 = " ist";
$Feld3 = " ein";
$Feld4 = " Test";
for($i=1;$i<=4;$i++){
$array[$i] = ${"Feld".$i};
echo $array[$i];
}
Dieses Beispiel gibt “Das ist ein Test” zurück.
Einfach oder? 
