Office Development is more than VBA

installierte .NET Versionen ermitteln

jensha — Mon, 21 Nov 2011 10:33:00 GMT

Eine einfache Möglichkeit, die installierten Versionen des .NET Frameworks zu ermitteln bietet dieses kleine Tool von ASoft. Außerdem kann man auch gleich das benötigte Framework oder SDK von Microsoft herunterladen. Die Links sind eingebaut.

Kollege Aaron Stebner hat ein Code-Beispiel für C++ veröffentlicht, das sich ebenfalls diesem Thema widmet.

VSTO PowerTools: ImageMSO Window in Visual Studio 2010

jensha — Fri, 18 Nov 2011 12:52:23 GMT

Wenn bei installiertem Visual Studio 2010 die VSTO PowerTools installiert werden, wird das Visual Studio Add-In ImageMSO Window zum Anzeigen und Auswählen des gewünschten in Office integrierten Icons nicht angezeigt. Mit folgendem kleinen Trick funktioniert es wieder:

In der Konfigurationsdatei ImageMsoVS2008.AddIn muss die Version des Hosts (also Visual Studio) geändert werden:

<HostApplication>
<Name>Microsoft Visual Studio</Name>
<Version>10.0</Version>
</HostApplication>

Die Datei befindet sich im Ordner C:\Users\<UserName>\AppData\Roaming\Microsoft\MSEnvShared\Addins\ (unter Windows 7).

(getestet mit der englischen Version von VS 2010)

Microsoft Germany is hireing …

jensha — Thu, 03 Nov 2011 13:07:36 GMT

Wir suchen engagierte Softwarespezialisten, die Spaß an Teamwork haben, gerne unterwegs bei Kunden sind und einen von folgenden Bereichen abdecken können:

Bewerbt Euch entweder direkt über den Link oder meldet Euch bei mir.

Office Business Application Day bei Microsoft in München

jensha — Mon, 10 Oct 2011 14:19:51 GMT

Am 04.11.11 findet zum dritten Mal die Community Veranstaltung Office Business Applikation (OBA) Day in Unterschleißheim bei Microsoft Deutschland statt. Dieser Tag widmet sich der Entwicklung rund um MS Office. Themen sind VSTO, SharePoint und Office 365. Des Weiteren bleibt auch viel Zeit für das Netzwerken und den Erfahrungsaustausch. Als Sprecher sind dabei: Thorsten Hans, Tom Wendel, Helmut Obertanner, Andreas Aschauer, Mario Meir-Huber und Lars Keller.
Weitere Informationen & die Anmeldung finden Sie unter http://www.oba-day.de

Say Good Bye to Hollywood…

jensha — Fri, 26 Aug 2011 14:02:59 GMT

Nach 8 Jahren in der DPE als Technical Evangelist und Platform Strategy Manager (wie schnell doch die Zeit vergeht…) habe ich mich entschlossen, etwas anderes zu machen. Seit Kurzem bin ich jetzt bei Premier Services for Developers (@ Microsoft) als Application Development Manager tätig. Das wird auch bedeuten, dass in diesem Blog nur noch gelegentlich Informationen auftauchen.

Auf jeden Fall sage ich erst mal Danke an alle, die hier mehr oder weniger regelmäßig vorbeigesehen haben.

Ist das das Ende vom Lied? Gewiß nicht. Eigentlich schwebt mir vor, mal dort mitzuarbeiten, wo am Ende auch etwas heraus kommt, was man anfassen kann ;-) - nämlich reale Produkte. Im Product Management oder der Entwicklungsleitung eines ISV zum Beispiel. Wenn das dann noch im Münchner Raum ist und etwas mit Cloud Computing und Windows Azure zu tun hat, dann bin ich interessiert.

Also dann, bis demnächst mal. Und paßt auf Euch auf.

- Jens

Die nächste PDC heisst //build

jensha — Fri, 10 Jun 2011 19:02:00 GMT

Die Professional Developer’s Conference 2011 heißt //build. Diesen Termin unbedingt vormerken: 13.- 16. September 2011, in Anaheim, Ca. Es gibt spannende Neuigkeiten! Einen Vorgeschmack gibt es hier. Die Registrierung ist offen!

PS: Die //Build wird die PDC nicht ersetzen. Es handelt sich um eine neue Konferenz.

Sneak Peek: Visual Studio vNext

jensha — Thu, 09 Jun 2011 09:50:04 GMT

Highlights in Visual Studio vNext kurz als deutsches Video erklärt – 30 Minuten die sich lohnen!

Einen kurzen Überblick über die bisher angekündigten Highlights in Visual Studio vNext – der nächsten Version von Visual Studio – gibt ALM Architekt und Visual Studio-Experte Christian Binder in seinem 30 Minuten dauernden Webcast. Hier bekommen Sie einen Ausblick auf einige der neuen Funktionen von Visual Studio vNext.

Schwerpunkte:

Requirements Storyboarding
Sprint Planning & Durchführung
Entwicklerproduktivität abrunden
Stakeholder-Feedback
IntelliTrace in Production
System Center-Integration
TFS on Azure

Alle bisherigen und zukünftigen Beiträge zu Visual Studio vNext finden Sie immer aktuell unter diesem Link.

Cloud Computing verständlich erklärt

jensha — Mon, 06 Jun 2011 11:29:04 GMT

Ich muss zugeben, inzwischen hasse ich den Begriff Cloud. Inzwischen ist es ein Buzz Word, dass jeder in den Mund nímmt. Das ist wie damals mit .NET. Auf einmal muss alles in der Cloud sein, notfalls macht man diese dann einfach privat. Aber was bedeutet das überhaupt? Und welche Rolle spielen hierbei die Begriffe SaaS, IaaS und PaaS? Wo paßt Windows Azure hinein?

Also vielleicht zuerst zu SaaS – Software as a Service. Software wird auf einer Web-Plattform zur Verfügung gestellt. Kostenlos oder im Mietmodell über monatliche Abrechnung. Im einfachsten Fall ist das eine Web-Applikation. Beispiele sind Google Apps, SalesForec Sales Cloud oder Microsoft Office Web Apps bzw. CRM Online, also Applikationen, mit denen Dokumente erstellt oder Daten erfaßt und bearbeitet werden können. Die Ablage der Dokumente oder Daten liegt oftmals ebenfalls in der Cloud.

Als Infrastructure as a Service (IaaS) bezeichnet man die Möglichkeit, eigene Virtuelle Maschinen in einem zentralen Rechenzentrum zu hosten. Man nimmt i.d.R. eine vorgefertigte VM mit dem Betriebssystem seiner Wahl (der Dienstleister unterstützt normalerweise nur bestimmt Versionen), installiert seine Services oder Anwendungen und betreibt das Ganze in einem zentralen Rechenzentrum. Für Updates der Virtuellen Maschinen ist der Betreiber (also Sie) zuständig. Das Paradebeispiel hierfür ist Amazon mit EC2 (Elastic Compute Cloud ).
Der Unterschied zum klassischen Hoster ist die Verfügbarkeit von globalen Services, wie Storage, Message Queues, relationales Datenbankservices und ähnlichem sowie Mechanismen zum automatischen Skalieren (bei Bedarf werden neue Instanzen meiner VM automatisch hochgefahren [Elastic BeansTalk bei Amazon]).

Zu Guter Letzt PaaS – Platform as a Service. Hier ist der Abstraktionsgrad höher als bei IaaS, weil es eine Art Betriebssystem über den vielen einzelnen PCs/Blades gibt und die einzelnen virtualisierten Betriebssysteminstanzen verwaltet. Der Entwickler schreibt seine Software also gegen ein Cloud-Betriebssystem und kümmert sich dort eigentlich nur um die Rollen, in die seine Services/Anwendungen fallen (Web, Worker). Das Cloud-Betriebssystem kümmert sich um die Ausführung der Anwendung nach den vorgegebenen Eckdaten oder Regeln. Load Balancing, OS-Servicing (Patches, Updates), Desaster Recovery, Fail Over, etc. wird durch die Cloud Platform durchgeführt. Desweiteren stehen Komponenten wie Storage (no-SQL like, wie Tables, Blobs und Queues) zur Verfügung. Manche Anbieter, wie Microsoft, bietet ebenfalls eine relationale Datenbank in der Cloud. PaaS hat immer auch Komponenten von IaaS enthalten, allerdings gekapselt und meist nicht direkt erreich- oder konfigurierbar.

David Chappell hat dazu einmal eine sehr aussagekräftige Matrix gezeigt, welcher Anbieter mit welchen Services in welcher Rubrik zuhause ist:

Ein typischer Vertreter für PaaS ist Microsoft Windows Azure. Es werden von Windows Azure auch weitere Komponenten für den Entwickler von Software geboten, die die Kommunikation zwischen dem eigenen Rechenzentrum und den Cloud Services regelt (Azure Connect, Service Bus) oder für Sicherheit und Zugriffsrechte (Access Control Service) bzw. Caching (Caching Services) zuständig sind. Nicht zu vergessen, die Tools für den Software LifeCycle: mit Visual Studio und .NET sind Sie dabei. Aber auch PHP, Ruby, Java, Eclipse, C++ u.a. werden unterstützt.

Je weiter man also die Abstraktion voran treibt, um so mehr fallen die Betriebskosten.

Einen guten allgemeinen Überblick über Windows Azure bieten folgende gut 7 Minuten Video:

Welche Szenarien sind für Windows Azure prädestiniert? Das sind Anwendungen, die

massive skalieren sollen
hochverfügbar sind
eine variable Last aufweisen
eine kurze oder unvorhersehbare Lebenszeit haben
Daten parallel verarbeiten
die Realisierung der Ideen von StartUps (fail fast/scale fast) darstellen
schnell verteilt bzw. zur Verfügung stehen müssen

Das sind einige, sicher aber nicht alle Szenarien für eine Cloud Plattform.

Windows 8 Sneak Peek

jensha — Thu, 02 Jun 2011 20:02:00 GMT

Jetzt war es endlich soweit: Auf der D9 - All Things Digital-Konferenz wurde zum ersten Mal enthüllt, was uns alle mit Windows 8 erwartet.

Hier einige Schlagzeilen:

komplett neue, dynamische Shell (Explorer) im Metro-Design (Windows Phone 7 sehr ähnlich, und das mit Absicht)
schnelle und super flüssige Touch-Bedienung (aber auch – ohne Kompromisse - mit Maus und Tastatur bedienbar)
natürliches Umschalten zwischen laufenden Anwendungen per Wischbewegung
volle Kompatibilität mit bisherigen Windows-Anwendungen, die im Windows 7-Stil gezeigt werden
der Internet Explorer 10 nutzt wirklich jedes Pixel an vorhandenem Platz

Man muss es selbst sehen, um einen Eindruck davon zu bekommen. Das offizielle Microsoft Video zum Windows 8 Sneak Peek ist hier zu finden.

Home Screen mit interaktiven Kacheln (Tiles), die wichtige Informationen aus den dahinter stehenden Applikationen zeigen:

Internet Explorer 10, hier im Eingabemodus:

… und im Full Screen Mode (Standard):

Eingabe per Touch-Keyboard:

umschaltbar auf ein Slate-Keyboard für die Bedienung mit zwei Daumen:

Side by side: Windows 8-optimierte Apps und herkömmliche Anwendungen, wie Excel

touch-optimierter FileBrowser:

Fazit:

Windows 8 wird für Touch-Bedienung optimiert sein, läßt sich aber auch ganz “normal” bedienen. Per HMTL 5 können Web Apps direkt mit den Live Tiles des Startbildschirms kommunizieren, ohne dass diese im Vordergrund sein muss.

In diesem sehr ausführlichen und interessanten Video zeigt Microsoft VP Mike Angiulo auf der Computex 2011 die ersten Highlights von Windows 8

Die offizielle Pressemitteilung findet sich hier.

But that’s not all we have to say …

Den nächsten Termin unbedingt vormerken: 13.- 16. September 2011, die Konferenz für Windows 8 [// Build Windows] von Microsoft in Anaheim, Ca. Die Registrierung ist offen!

Open XML ist schnell ! - Immer?

jensha — Thu, 26 May 2011 14:03:15 GMT

Ich habe in der Vergangenheit einige Artikel, Samples und WebCasts zum Thema Open XML bereitgestellt. Jetzt tauchte die Frage – oder vielmehr die Beobachtung – auf, dass das Einfügen von 50.000 Datensätzen á 10 Werten einige Stunden benötige. Dabei soll doch Open XML so schnell sein. Wie paßt das zusammen?

Es kommt natürlich auf den Source Code an . Wie immer. Der in den Beispielen gezeigte Code war gedacht zum Einfügen einzelner Zellen in bestehende Tabellen. Dabei wurde Rücksicht auf viele Fälle genommen:

1. Die Zeile/Zelle existiert schon oder auch nicht
2. Es gibt vor der Zeile/Zelle oder danach weitere Zeilen/Zellen

Demensprechend verändert sich die Art und Weise Wie und vor allem Wo die Zelle bzw. Zeile eingefügt werden muss. Ich habe den Fall nachgestellt und mit dem gezeigten Beispiel 50.000 Datensätzen geschrieben. Das dauerte knapp 27 Minuten.

Danach habe ich den Code umgeschrieben. Wenn so viele Datensätzen nacheinander geschrieben werden, dann kann man davon ausgehen (oder zumindest sollte man diese Voraussetzung schaffen), dass diese Schreibvorgänge in einen leeren Bereich fallen, also erstens in der zu schreibenden Zeile noch nichts steht und es zweitens keine Zeilen nach diesem Bereich gibt, die Daten enthalten. Ein entsprechendes Template vorausgesetzt, kann jetzt ohne jegliche Prüfungen geschrieben werden. Und das spart richtig Zeit. Mit diesem Code:

SheetData sd = new SheetData();
ws.AppendChild(sd);
char c;
Row r = new Row();
for (uint i = 1; i < 50000; i++ )
{
r.RowIndex = i;
for (int si = 65; si < 75; si++)
{
    c = Convert.ToChar(si);
    string cellRef = c.ToString() + i.ToString();
    r.AppendChild(CreateCellWithInlineString(cellRef, "Microsoft DPE Test"));
}
sd.AppendChild(r);
r = new Row();
}
ws.Save(partWS);

habe ich die Zeit auf knapp 15 Sekunden gedrückt. Das sind gerade mal 0,9% der vorher benötigten Zeit.

Es kommt also immer darauf an, welchen Zweck der eingesetzte Code erfüllen soll und es lohnt sich, für verschiedene Einsatzgebiete angepaßte Voraussetzungen zu schaffen.

Using WPF and Silverlight to fight Cancer :: eBay Auction

jensha — Fri, 18 Mar 2011 09:31:17 GMT

Gregor Biswanger (MVP für Client App Dev, Solution Architect & Silverlight Experte) hat seit gestern Nachmittag eine Aktion auf seinem Blog unter dem Titel „WPF 4 und Silverlight 4 gegen Krebs!“ gestartet. Bei seinem letzten Besuch in Redmond hatte er seine DVD von den WPF-, Silverlight- und Expression Blend-Produktteams signieren lassen. Diese signierte DVD wird auf eBay versteigert und der Erlös geht direkt an die Deutsche Krebshilfe e.V.. Weitere Informationen auf seinem Blog unter: http://www.dotnet-blog.net/post/2011/03/15/WPF-4-und-Silverlight-4-gegen-Krebs!.aspx

Also dann, wer helfen kann und will, bitte mitbieten.

Visual Studio LightSwitch und Team Foundation Server erleben

jensha — Wed, 16 Mar 2011 15:04:19 GMT

Ab 21. März, jeweils ab 15 Uhr, begrüßt Sie Uwe Baumann auf der

RAPID APPLICATION DEVELOPMENT ROADSHOW 2011

Hier können Sie Visual Studio LightSwitch 2011 (Beta), Team Foundation Server 2010 und Windows Azure live erleben. Sprecher sind u.a. Christian Binder und Bernhard Frank.

Microsoft TechSummit Cloud – die Roadshow für Developer & IT Professionals

jensha — Wed, 16 Mar 2011 08:27:29 GMT

“CLOUD Computing” ist wohl das Buzzword des Jahres. Aber was steckt wirklich dahinter? Macht das Sinn für mich? Welche Dienste gibt es? Was ist der Unterschied zwischen SaaS, PaaS, IaaS und was hat es mit Public und Private Cloud auf sich? Ist das Ganze eigentlich sicher? Muss ich als Entwickler oder Administrator alles neu lernen? Und was hat Microsoft eigentlich mit Cloud zu tun?

Antworten hierzu gibt es auf unserer Roadshow Microsoft TechSummit Cloud.

Vom 28. März bis zum 8. April 2011 touren Experten von Microsoft TechNet und MSDN durch sechs deutsche Metropolen um Best Practices und technische Hintergründe zu den neuesten Microsoft Cloud-Technologien zu vermitteln und Anwenderfragen zu beantworten.
Wir geben einen Überblick über die Microsoft Cloud, stellen für Administratoren, Entwickler und IT-Manager die neuesten Produkte und Technologien vor und zeigen Ihnen, wie Sie Cloud Services in Ihre bestehende Infrastruktur integrieren und Ihre Software an die Cloud anpassen bzw. in der Cloud bereitstellen können.

Für IT-Professionals und Administratoren dürften besonders die Vorträge "Windows InTune" (Ralf Schnell), "Office 365 für Administratoren" (Steffen Krause, Daniel Melanchthon) oder "Private Cloud selber aufbauen" (Frank Koch) interessant sein.
Relevant für Entwickler sind u.a. Vorträge zur "Migration von Anwendungen in die Cloud" (Dariusz Parys), zur "Entwicklung von SaaS Lösungen auf Basis der Windows Azure Platform" (Patric Boscolo) und zu dem "Betrieb und Entwicklung mit der Microsoft Cloud" (Holger Sirtl).

Neue WebCasts zum Open XML SDK 2.0

jensha — Mon, 14 Mar 2011 13:30:38 GMT

Im Februar habe ich mir mal die Zeit genommen, ein paar der Beispiele und Ideen aus meinem Blog in Video-Tutorial umzusetzen. Herausgekommen sind diese 4 WebCasts:

Dateimanipulation mit den Open XML SDK 2.0-Excel-Dateien (Teil 1 von 4) - Benannte Bereiche in Excel: Anlegen und Auslesen von Named Ranges

Dateimanipulation mit den Open XML SDK 2.0-Excel-Dateien (Teil 2 von 4) - Excel-Dateien erzeugen, Zellen und Zeilen in Excel-Tabellen anlegen und einfügen

Dateimanipulation mit den Open XML SDK 2.0-Excel-Dateien (Teil 3 von 4) - Die Handhabung von Shared Strings

Dateimanipulation mit den Open XML SDK 2.0-Excel-Dateien (Teil 4 von 4) - Formatvorlagen für Excel: Der Umgang mit StyleSheets

Beherrsche Deine Maschine und fliege nach Las Vegas…

jensha — Tue, 08 Feb 2011 09:00:08 GMT

An alle Windows 7 Maschinisten und solche die es werden wollen.

Der Auftrag

Du bist der Maschinist und nur du kennst die Maschine wirklich. Welche Funktion suchst du in deinem System vergeblich? Die Mäusejagd, das Schneetreiben oder etwas ganz Anderes? Stell dich der Herausforderung und baue deine eigene verrückte Wunsch-Anwendung. Dabei sollte mindestens eine der vielen neuen Windows 7 Funktionen verwendet werden. Lade dir dein Werkzeug kostenlos herunter und zeig wie kreativ du bist. Wie dein Windows 7 aussehen soll – das kannst du jetzt selbst bestimmen.

Die Anforderungen:

Programmiert für Windows 7
Verwendung einer Version von Visual Studio 2010
.NET Framework oder Visual C++ basierend
Verwendung von Windows 7 Funktionen
Möglichst wenig Zeilen (gibt Pluspunkte)
Sämtliche Bestandteile (Bibliotheken, Bilder, etc.) müssen mit eingereicht werden
Der Teilnehmer muss die Software selber erstellt haben und sämtliche Rechte an allen eingebundenen Bestandteilen besitzen.

Weitere Informationen und Teilnahmebedingungen

Der Hauptgewinn (3x) : Großer Las Vegas Gambling-Trip mit Besuch der MIX und Helikopterflug.

Dieser Trip besteht aus:

Flug nach Las Vegas inkl. Flughafentransfer per Limousine
Besuch der MIX 2011, der Microsoft-Konferenz für Web-Entwickler
6 Übernachtungen im Mandalay Bay Hotel
300 US$ in Gambling Chips zum Verzocken
Helikopterflug zum Grand Canyon inkl. Transfer

Also dann, ran an die Tastatur….

Testing Leadership Award 2011

jensha — Fri, 04 Feb 2011 16:08:12 GMT

Softwaretester und -entwickler: Machen Sie mit beim Testing Leadership Award 2011

Unbestritten, IT-Systeme werden immer komplexer und sind damit anfälliger für Softwarefehler. Die Folgen sind Schäden in wirtschaftlicher Hinsicht, aber auch unzufriedene Kunden. Der Testing Leadership Award zeigt Ihren Kunden, dass die von Ihnen getestete Software den höchsten Ansprüchen an Bedienungskomfort, Qualität und Zuverlässigkeit entspricht.

Die BQI Leadership Awards sind Teil eines internationalen Award-Programms, das den Erfolg von Unternehmen bei Innovationen, Produkten oder Dienstleistungen würdigt und auszeichnet. Das BQI zeichnet Unternehmen aus, die in anerkannter Weise besondere Leistungen in den Bereichen Produktentwicklung, Innovation, Geschäftsprozesse oder Management erbracht haben.

Mit der Auszeichnung Leadership Award gewinnen Sie ein wertvolles Marketinginstrument, um Ihre Produkte und Dienstleistungen noch erfolgreicher am Markt zu positionieren.

Melden Sie sich jetzt zum Testing Leadership Award 2011 an. Meldeschluss ist 31.März 2011. Direkt zur Anmeldung: http://www.bqi-research.com/de-user-AwardRegistration-index-Testing+Leadership+Award.html?param1=Testing+Leadership+Award

Wer braucht keine Code Samples?

jensha — Mon, 10 Jan 2011 14:40:23 GMT

Code-Beispiele sind für mich meist mehr wert als eine ausführliche Dokumentation. Nichts gegen Dokumentationen. Im Gegenteil. Wenn diese gut und aussagekräftig sind und natürlich Code Samples enthalten. Leider sind die kleinen Snippets oftmals viel zu kurz und aus dem Zusammenhang gerissen. Dem kann man jetzt etwas entgegen stellen. Für alle, die es noch nicht gesehen haben, Microsoft hat einen All-In-One Code Framework Sample Catalog veröffentlicht mit folgenden Inhalten:

MSDN Bus mit Vorträgen on Tour

jensha — Mon, 10 Jan 2011 12:15:48 GMT

Der MSDN on Tour-Bus ist vom 26.01. bis zum 05.03.2011 quer durch Deutschland unterwegs. Der Tour-Bus ist ein rollendes Präsentationsstudio, in dem ein breitgefächertes Vortragsangebot zu aktuellen Entwicklerthemen (zwei parallele oder ein gemeinsamer Vortrag) bereit steht. Der Eintritt ist frei.

Man kann den Tour-Bus auch in seine Stadt oder zu seiner Firma holen! (Themenwünsche werden nach Möglichkeit ebenfalls berücksichtigt)
Lassen Sie sich benachrichtigen über die aktuelle Stationen des Busses
Nehmen Sie an unseren MSDN on Tour-Gewinnspielen online und vor Ort teil.
Unser Charity-Bonbon: Busbesitzer für einen Tag werden!

Alle weiterführende Informationen: http://www.msdn-on-tour.de

Open XML Dateien aufbauen und verändern (Teil 6)

jensha — Mon, 10 Jan 2011 11:18:00 GMT

Zeichenketten zu bestehenden Dateien hinzufügen

Bisher haben wir uns nur mit dem Neuerzeugen von Arbeitsmappen beschäftigt. Deshalb jetzt noch ein Blick hinter die Kulissen für den Fall, dass die Datei schon existiert.

private void AddSharedStringsToExistingWorksheet(string FName, 
                                                 string sheetName, 
                                                 string cellRef, 
                                                 string sharedString)
{
   using (SpreadsheetDocument xlDoc = SpreadsheetDocument.Open(FName, true))
   {
      // Gibt es einen SharedStringTablePart?
         // Nein ==> erzeugen
 
      // Gibt es das Worksheet?
         // Nein ==> erzeugen
 
      // Gibt es die gesuchte Zeile?
         // Nein ==> erzeugen
        
      // Gibt es die gesuchte Zelle in der Zeile?
         // Nein ==> erzeugen

      // String einfügen
 
      // Dokument speichern
   }
}

Gibt es einen SharedStringTablePart?

Wir könnten jetzt natürlich wieder mit Inline Strings arbeiten (und es spricht eigentlich nichts dagegen), aber wir wollen streng “by the book” vorgehen die Zeichenketten in die Shared Strings-Tabelle eintragen. Dazu muss zuerst einmal geschaut werden, ob diese überhaupt vorhanden ist. Wenn nicht, muss sie erzeugt werden. GetPartsOfType() liefert eine Sammlung aller gefundenen Parts eines bestimmten Typs. Da es nur einen geben kann, können wir mit der Extension Method FirstOrDefault() die gewünschte Referenz erhalten. First() kann hier nicht verwendet werden, da nur FirstOrDefault() bei leerer Liste null liefert. In dem Fall müssen wir den Part selbst erzeugen.

SharedStringTablePart sstPart = 
   xlDoc.WorkbookPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
if (sstPart == null)   
   sstPart = xlDoc.WorkbookPart.AddNewPart<SharedStringTablePart>();

Gibt es das Worksheet?

Zuerst müssen wir den WorkbookPart holen, da dort die Referenzen auf die Worksheets gehalten werden. Daraus läßt sich über Lambda Functions das Worksheet mit den gesuchten Namen ermitteln oder erzeugen, falls noch nicht vorhanden.

WorkbookPart wbPart = xlDoc.WorkbookPart;
Workbook wb = wbPart.Workbook;
Sheet sheet = wb.GetFirstChild<Sheets>().Elements<Sheet>()
                .Where(s => s.Name == sheetName).FirstOrDefault();

WorksheetPart wsPart;
Worksheet ws = null;
if (sheet == null)  // nicht da ==> erzeugen
{
   wsPart = InsertWorksheetPart(wbPart, tbWorksheetName.Text);
   ws = new Worksheet(new SheetData());  // worksheet.xml erzeugen
}

Wenn es schon existiert, könnten wir uns eigentlich zurücklehnen, da wir weiter ober ja schon das Sheet mit den entsprechenden Namen gefunden hatten. Weit gefehlt. Oben wird eine Referenz auf ein Sheet zurückgegeben, wir brauchen aber die Referenz auf das Worksheet. Das ist ein kleiner, aber feiner Unterschied. Über die ID des Sheets können wir den WorksheetPart extrahieren (GetPartById) und von dort kommen wir an das Worksheet.

else // es existiert
{
   string rId = sheet.Id.Value;
   wsPart = (WorksheetPart)xlDoc.WorkbookPart.GetPartById(rId); 
   ws = wsPart.Worksheet;  
}

Aus dem Worksheet muss nun noch das Root Element der Tabelle geholt werden - da wir ja vorher nicht wissen können, ob das Worksheet existiert.

SheetData sd = ws.GetFirstChild<SheetData>();

Gibt es die gesuchte Zeile?

Eine Excel-Tabelle ist zeilenweise aufgebaut. Unterhalb des SheetData Elements befinden sich die Tabellen-Zeilen im Markup. Also müssen wir die mit dem vorgegebenen Zeilenindex finden oder erzeugen. Die Hilfsfunktion RemoveAllButNumbers ist eine eigene Extension Method, die aus einer Zelladresse (AB123) nur die Zeilenreferenz (123) zurück liefert.

UInt32 rowIndex = (UInt32)cellRef.RemoveAllButNumbers();
Row row = sd.Elements<Row>()
            .Where(r => r.RowIndex.Value == rowIndex) 
            .FirstOrDefault();
if (row == null)
   row = CreateNewRow(ref sd, rowIndex);

Gibt es die gesuchte Zelle?

In etwa das Gleiche machen wir mit der Zelle innerhalb der eben gefundenen Zeile.

Cell cell = row.Elements<Cell>()
               .Where(c => c.CellReference == cellRef)
               .FirstOrDefault();
if (cell == null)
   cell = CreateNewCell(ref row, cellRef);

Zellwerte schreiben und speichern

Zum Abschluß wird die Zeichenkette in der Shared Strings-Tabelle gespeichert bzw. - falls dort schon vorhanden - deren Index ermittelt und dieser in die ermittelte oder erzeugte Zelle eingetragen. (Die Routine zum Eintragen des Shared Strings wurde schon in Teil 2 beschrieben.)

cell.DataType = CellValues.SharedString;
cell.CellReference = cellRef;
cell.CellValue = 
  new CellValue(InsertSharedStringItem(sharedString, sstPart).ToString());

ws.Save(wsPart);

So, wie man sieht, kann man sich auf nichts verlassen ;-) und muss ständig prüfen, ob bestimmte Teile schon vorhanden sind. Es wird in der Praxis wohl weitaus häufiger vorkommen, schon existierende Dateien abfragen oder ändern zu müssen als neue zu erzeugen. Nichtsdestotrotz lohnt sich ein Blick auch hinter diese Kulissen, um die Zusammenhänge zu verstehen. So ein Dateiformat ist verdammt komplex und man wird als Einzelner wohl nie alles verstehen können, was in einer Excel- oder Word-Datei so alles vor sich geht. Das Gute an der Sache ist, das man nie alles braucht, sondern einzelne Teilbereiche relativ gut von anderen abgetrennt sind. So kommt man dann Schritt für Schritt voran.

Das Beispielprojekt kann übrigens hier heruntergeladen werden.

[Fortsetzung folgt]

Open XML Dateien aufbauen und verändern (Teil 5)

jensha — Tue, 04 Jan 2011 14:03:17 GMT

Stylesheets erzeugen und verwenden

So, ich hoffe, alle hatten ein einigermaßen geruhsames Weihnachtsfest und die Nachwirkungen des Silvesterparty sind überwunden.

Im letzten Teil haben wir bereits die Zusammenhänge aufgezeigt. Jetzt geht es weiter mit der Implementierung der Routine zum Erzeugen des Stylesheets. Wie schon mehrfach erwähnt muss das nicht immer getan werden. Verwendet werden kann auch ein Stylesheet aus einer vorhandenen Excel-Arbeitsmappe, sofern alle gewünschten Formatvorlagen dort definiert wurden.

Grob betrachtet gliedert sich die Routine in 7 Teile:

static class StylesClass
{
  internal static Stylesheet GenerateStylesXml()
  {
    Stylesheet ssh = new Stylesheet();
    
    #region +++ Add Number Formats +++
 
    #region +++ Add Font Information +++   

    #region +++ Add Fill Styles +++

    #region +++ Add Border Styles +++

    #region +++ Add Cell Style Formats +++

    #region +++ Add Cell Formats // Master Formatting Records +++

    #region +++ Add Cell Styles +++

    return ssh;
  }
}

Zuerst müssen die Zahlenformate definiert werden, die dann in der Zellformatierung und in Formatvorlagen verwendet werden. Darin wird eine ID verwendet, die jedes einzelne Format eindeutig identifiziert. Da Excel schon eingebaute Formate besitzt, müssen wir hinter deren ID starten. Die Werte von 0 bis 164 sind m.W. für interne Formate reserviert. Neben der ID ist der Formatcode erforderlich, den wir aus Excel selbst kennen.

Mit Hilfe der Object Initializer kann der Code verkürzt werden.

#region +++ Add Number Formats +++

uint NumFmtId = 165;  
NumberingFormats nfs = new NumberingFormats();
NumberingFormat nf1 = new NumberingFormat() 
  { NumberFormatId = NumFmtId++, 
    FormatCode = "0" };
nfs.Append(nf1);
NumberingFormat nf2 = new NumberingFormat() 
  { NumberFormatId = NumFmtId++, 
    FormatCode = "#.##0,00 €;[Red]-#.##0,00 €" };
nfs.Append(nf2);
NumberingFormat nf3 = new NumberingFormat() 
  { NumberFormatId = NumFmtId++, 
    FormatCode = "0 \"km/h\"" };
nfs.Append(nf3);
NumberingFormat nf4 = new NumberingFormat() 
  { NumberFormatId = NumFmtId++, 
    FormatCode = "dd.mm.yyyy" };
nfs.Append(nf4);
NumberingFormat nf5 = new NumberingFormat() 
  { NumberFormatId = NumFmtId, 
    FormatCode = "dddd, dd. mmmm yyyy" };
nfs.Append(nf5);
nfs.Count = (uint)nfs.ChildElements.Count;

ssh.Append(nfs);

#endregion

Nun folgen die Font-Informationen. Da Fonts per Index referenziert werden, ist keine ID nötig. Wenn allerdings derselbe Font zusätzlich jeweils mit dem Schnitt kursiv bzw. fett benötigt wird, so sind 3 verschiedene Font-Einträge erforderlich.

#region +++ Add Font Information +++

Fonts fts = new Fonts();
Font ft = new Font() 
  { FontName = new FontName() { Val = "Calibri" }, 
    FontSize = new FontSize() { Val = 11D } };
fts.Append(ft);
ft = new Font() 
  { FontName = new FontName() { Val = "Aharoni" }, 
    FontSize = new FontSize() { Val = 18D } };
fts.Append(ft);
ft = new Font() 
  { FontName = new FontName() { Val = "Bradley Hand ITC" }, 
    FontSize = new FontSize() { Val = 20D }, 
    Bold = new Bold() };
fts.Append(ft);
ft = new Font() 
  { FontName = new FontName() { Val = "Bernard MT Condensed" }, 
    FontSize = new FontSize() { Val = 16D } };
fts.Append(ft);
fts.Count = (uint)fts.ChildElements.Count;

ssh.Append(fts);

#endregion

Die Füllmuster der Zelle werden hier definiert und ebenfalls über den Index referenziert:

#region +++ Add Fill Styles +++

Fills fis = new Fills();
Fill fi = new Fill() 
  { PatternFill = new PatternFill() 
    { PatternType = PatternValues.None } 
  };
fis.Append(fi);
fi = new Fill() 
  { PatternFill = new PatternFill() 
    { PatternType = PatternValues.LightGray } 
  };
fis.Append(fi);
fis.Count = (uint)fis.ChildElements.Count;

ssh.Append(fis);

#endregion

Die Randeinstellungen der Zelle sind hier nur gekürzt dargestellt:

#region +++ Add Border Styles +++

Borders bos = new Borders();
Border bo = new Border()
{
  …
};
bos.Append(bo);
bo = new Border()
{
  LeftBorder = new LeftBorder() { Style = BorderStyleValues.Thin },
  RightBorder = new RightBorder() { Style = BorderStyleValues.Thin },
  TopBorder = new TopBorder() { Style = BorderStyleValues.Thin },
  BottomBorder = new BottomBorder() { Style = BorderStyleValues.Thin }
};
bos.Append(bo);
bos.Count = (uint)bos.ChildElements.Count;

ssh.Append(bos);

#endregion

Für die weiter unten mit Namen definierten eingebauten Formatvorlagen werden hier Standardeinstellungen definiert. Diese können jederzeit durch direkte Formatierung (Master Cell Records) überschrieben werden.

#region +++ Add Cell Style Formats +++

CellStyleFormats cstfs = new CellStyleFormats();

CellFormat cfmt = new CellFormat() 
  { NumberFormatId = 0, 
    FontId = 0, 
    FillId = 0, 
    BorderId = 0 };
cstfs.Append(cfmt);
cstfs.Count = (uint)cstfs.ChildElements.Count;

ssh.Append(cstfs);

#endregion

Ein Beispiel aus einer Arbeitsmappe zeigt mögliche Definitionen:

Bei den Master Cell Records laufen alle Fäden zusammen. Jeder Zelle bezieht sich auf einen Index in dieser Tabelle. Hier werden die Abweichungen vom Standardformat „Normal“ definiert. Alles, was nicht definiert wurde, wird von „Normal“ übernommen. Über die FormatId wird auf die benannten Formatvorlagen verwiesen.

#region +++ Add Cell Formats // Master Formatting Records +++

CellFormats cfx = new CellFormats();
CellFormat cf;
cf = new CellFormat() 
  { NumberFormatId = nf1.NumberFormatId, 
    FontId = 0 , 
    FormatId = 0 }; 
cfx.Append(cf);
cf = new CellFormat() 
  { NumberFormatId = nf1.NumberFormatId, 
    FontId = 0 , 
    FormatId = 0 }; 
cfx.Append(cf);
cf = new CellFormat() 
  { NumberFormatId = nf3.NumberFormatId, 
    FontId = 1 , 
    FormatId = 0 }; 
cfx.Append(cf);
cf = new CellFormat() 
  { NumberFormatId = nf5.NumberFormatId, 
    FontId = 2, 
    BorderId = 1, 
    FillId = 1 , 
    FormatId = 0 }; 
Alignment al = new Alignment() 
  { Horizontal = HorizontalAlignmentValues.Center };
cf.Append(al);
cfx.Append(cf);
cf = new CellFormat() 
  { NumberFormatId = nf1.NumberFormatId, 
    FontId = 2 , 
    FormatId = 0 }; 
al = new Alignment() 
  { Horizontal = HorizontalAlignmentValues.Right };
cf.Append(al);
cfx.Append(cf);
cf = new CellFormat() 
  { NumberFormatId = nf1.NumberFormatId, 
    FontId = 3 , 
    FormatId = 0 }; 
cfx.Append(cf);
cf = new CellFormat() 
  { NumberFormatId = 12, 
    FontId = 3 , 
    FormatId = 0 }; 
al = new Alignment() 
  { Horizontal = HorizontalAlignmentValues.Center };
cf.Append(al);

cfx.Append(cf);
cfx.Count = (uint)cfx.ChildElements.Count;

ssh.Append(cfx);

#endregion

Die Definition der Namen benannter Formatvorlagen erfolgt hier. Im Anhang H der ISO/IEC 29500 Formatbeschreibung findet man eine Auflistung der vordefinierten Formate. Die BuildInID verweist darauf. Es muss zumindest die Vorlage „Normal“ definiert werden, da alle Zellen erst mal diese Formatvorlage erhalten.

#region +++ Add Cell Styles +++

CellStyles csts = new CellStyles();
CellStyle cst = new CellStyle() 
  { Name = "Normal", FormatId = 0, BuiltinId = 0 };
csts.Append(cst);
csts.Count = (uint)csts.ChildElements.Count;

ssh.Append(csts);

#endregion

Ein Beispiel aus einer Arbeitsmappe zeigt mögliche verwendete Formatvorlagen:

Der in Teil 1 schon einmal rudimentär aufgezeigte Code zum Erstellen der Zellinhalte sieht ausformuliert so aus:

// worksheet.xml erzeugen:
Worksheet ws = new Worksheet();
SheetData sd = new SheetData();
ws.AppendChild(sd);

Row r1 = new Row();
r1.RowIndex = 1;

// Create InlineString:
r1.AppendChild(CreateCellWithInlineString("A1", "Der Zellwert als String", 0));

// Create Number Entry:
r1.AppendChild(CreateCellWithNumber("B1", "42", 2));

// Create Formula:
r1.AppendChild(CreateCellWithFormula("C1", "B1*5", 1));

// Create SharedString:
r1.AppendChild(CreateCellWithSharedString("D1", "Microsoft", partSharedStrings, 4));

Row r3 = new Row();
r3.RowIndex = 3;
r3.AppendChild(CreateCellWithSharedString("A3", "Jens Häupel", partSharedStrings, 4));
r3.AppendChild(CreateCellWithSharedString("B3", "Microsoft", partSharedStrings, 5));

Row r5 = new Row();
r5.RowIndex = 5;

// Create Date Entry:
r5.AppendChild(CreateCellWithNumber("A5", "40536", 3));

// Create Fraction:
r5.AppendChild(CreateCellWithNumber("B5", "2.75", 6));

sd.AppendChild(r1);
sd.AppendChild(r3);
sd.AppendChild(r5);
ws.Save(partWS);

Daraus ergibt sich diese Tabelle in Excel. Man sieht die verschiedenen Formatierungenin Bezug auf Zeichensatz, Schriftschnitt und –größe sowie Ausrichtung.

Aber halt, das ist eigentlich nicht das korrekte Ergebnis. Das sieht nämlich so aus:

Hier wird eine Limitierung deutlich: Open XML ist zwar sehr gut geeignet, Daten aus Dateien zu extrahieren oder auch Inhalte zu verändern oder erzeugen, auf eine Sache hat Open XML aber keinen Einfluss: das Rendering. Dafür werden Informationen über Drucker- und Grafikengine benötigt. Letztendlich ist es möglich, z.B. die optimale Breite einer Zelle, ausgehend von einer gegebenen Schrift (incl. Größe, Schnitt und Skalierung) zu berechnen und auch per Open XML einzustellen.

Die exakte Definition, wie die Berechnung zu erfolgen hat, findet sich in Abschnitt 18.3.1.13 der Open XML Dokumentation.

Die Spaltenbreite kann man wiederum setzen, indem einzelne Spalten definiert und der Columns Collection hinzugefügt werden:

Columns cols = new Columns(
  new Column() { Min = 1, Max = 1, Width = 12, CustomWidth = true },
  new Column() { Min = 1, Max = 1, Width = 12, CustomWidth = true }
  );
ws.Append(cols);

Ganz am Ende noch ein Blick in die Shared String Tabelle. Obwohl der Begriff „Microsoft“ zweimal verwendet wurde, erscheint er richtigerweise nur einmal als Shared String:

[Fortsetzung folgt]

Open XML Dateien aufbauen und verändern (Teil 4)

jensha — Wed, 22 Dec 2010 15:51:13 GMT

Formatierte Zellen in Excel:

Um Zellen in Excel formatieren zu können, muss auf ein Stylesheet zurückgegriffen werden. Im Zellenmarkup wird lediglich ein Verweis auf den (Style-) Index des sog. Master Cell Style Records gesetzt, einer Stelle im Stylesheet, an der alle Fäden zusammen laufen und das Format der Zelle definiert wird.

private Cell CreateCellWithNumber(string cellRef, string cellValue, uint styleIndex)
{
Cell c = new Cell();
c.DataType = CellValues.Number;
c.CellReference = cellRef;
c.StyleIndex = styleIndex;
c.CellValue = new CellValue(cellValue);
return c;
}

Das XML Markup der Zelle könnte danach so aussehen:

<x:c r="B1" s="2" t="n">
  <x:v>42</x:v>
</x:c>

Dieser Master Cell Style Record holt seine Daten aus anderen Bestandteilen des Stylesheets, wie den Abschnitten für Zahlenformate, Rahmen, Zellfüllmuster, Zeichensätze und Formatvorlagen. Die Formatvorlagen verweisen wiederum auf einen Definitionsabschnitt und enthalten Informationen über (in Excel) eingebaute Formate, die nicht explizit definiert werden müssen.

Die Zusammenhänge sind im folgenden Diagramm zu erkennen:

Wichtig ist, dass einige Beziehungen durch den Index des entsprechenden Eintrags und andere durch dessen ID referenziert werden. Zahlenformate (ebeneso wie Formatvorlagen) sind schon vordefiniert und im Anhang H der Open XML Markup Definition erklärt. Ein Ausschnitt ist hier zu sehen:

40	#,##0.00;[Red](#,##0.00)
45	mm:ss
46	[h]:mm:ss
47	mmss.0
48	##0.0E+
49	@

Wenn man man eine befüllte Excel-Datei mit den Package Explorer (Open XML SDK 2.0 Productivity Tool), oder auch in Visual Studio öffnet, so sieht man diese Zusammenhänge:

Das ist nur rein Ausschnitt aus dem gesamten Bild. Mindestens müssen folgende Bestandteile implementiert werden:

Zahlenformatedefinitionen (<numFmts …>)
Zeichensatzdeinitionen (<fonts …>)
Definition der Zellfüllungen (<fills …>)
Definition der Umrandungen (yborders …>)
Die Zellenformate (<cellXfs…>)
Die Formatvorlagen (cellStyles …>) … mind. „Normal“
Die Definition der Formatvorlagen (<cellStyleXfs…>)

Wie das dann implementiert wird, erfahren Sie im nächsten Teil.

[Fortsetzung folgt]

Open XML Dateien aufbauen und verändern (Teil 3)

jensha — Fri, 17 Dec 2010 12:50:31 GMT

Zeichenketten in existierende Excel-Dateien eintragen

In den ersten beiden Teilen haben wir das jeweilige Open XML Dokument neu erzeugt. Während man sich dabei darauf verlassen kann, dass die zu erzeugenden Teile noch nicht vorhanden sind, hat man es beim Einfügen in bestehende Dokumente schwerer. Es muss jedes Mal überprüft werden, ob eine Komponente nicht evtl. doch schon vorhanden ist, da jeder Bezeichner bzw. jede ID nur genau einmal vorkommen darf.

Es soll ein String in eine Zelle eingetragen werden. Der String wird als Shared String eingebettet. Als Übergabeparameter benötigen wir:

Name der Arbeitsmappen mit Pfadangabe
Name der Tabelle
Adresse der Zelle, z.B. “A1”
Die einzufügende Zeichenkette

Ausgehend von diesen Parametern könnten Tabelle, Zeile bzw. Zelle noch nicht vorhanden sein. Um das Erzeugen werden wir uns hier kümmern. Die Grundaufgabe ist allerdings das Einfügen der Zeichenkette in die Zelle.

Der Rumpf der Prozedur wäre erst mal folgender. Wir gehen nun Schritt für Schritt durch die Entscheidungen.

private void AddSharedStringsToExistingWorksheet(string FName, 
   string sheetName, string cellRef, string sharedString)
{
   using (SpreadsheetDocument xlDoc = SpreadsheetDocument.Open(FName, true))
   {
     …
   }
}

Das Erste, was beim Einfügen eines Shared Strings gemacht werden muss ist die Prüfung, ob die Shared Strings-Tabelle existiert, also ob ein SharedStringTablePart vorhanden ist. Wenn nicht, wird sie erzeugt.

SharedStringTablePart sstPart = 
   xlDoc.WorkbookPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
if (sstPart == null)   
   sstPart = xlDoc.WorkbookPart.AddNewPart<SharedStringTablePart>();

Dann schauen wir, ob ein Worksheet mit dem vorgegebenen Namen zu finden ist. Dazu müssen wir im Workbook.xml nachschauen, da dort alle enthaltenen Worksheets gelistet sind. Das Markup der workbook.xml kann man einer vorher erstellten Excel-Datei entnehmen:

<sheets>
  <sheet name="Bilanzen 1998" sheetId="1" r:id="rId1" /> 
  <sheet name="Zusammenfassung" sheetId="2" r:id="rId2" /> 
  <sheet name="Externe Ressourcen" sheetId="3" r:id="rId3" /> 
</sheets>

(Die angegebene Relationship ID (rIdx) kann jeder eindeutige String sein, z.B. auch eine GUID. Excel selbst vergibt durchnummerierte IDs, die sehr einfach zu lesen aber für uns schwierig zu verwalten sind. Das Open XML SDK verwendet deshalb auch GUID-Strukturen.)

Aus diesem Sheet-Element wird über die ID der dazugehörige WorkbookPart ermittelt (GetPartById). Dieser Part beherbergt dann auch das entsprechende Worksheet.
Wenn kein Sheet-Element in der Workbook.xml gefunden wurde, wird ein WorksheetPart eingefügt, das XML Document mit dem Root-Element Worksheet erzeugt und das SheetData-Element angehängt.

WorkbookPart wbPart = xlDoc.WorkbookPart;
Workbook wb = wbPart.Workbook;
Sheet sheet = (Sheet)wb.GetFirstChild<Sheets>().Elements<Sheet>()
   .Where(s => s.Name == sheetName).FirstOrDefault();
 
WorksheetPart wsPart;
Worksheet ws = null;
if (sheet == null)  
{
  wsPart = InsertWorksheetPart(wbPart, tbWorksheetName.Text);
  ws = new Worksheet(new SheetData());  
}
else  
{
  string rId = sheet.Id.Value;
  wsPart = (WorksheetPart)xlDoc.WorkbookPart.GetPartById(rId); 
  ws = wsPart.Worksheet;  
}

SheetData sd = ws.GetFirstChild<SheetData>();

Wichtig ist es zu wissen, dass das o.g. Sheet Element nichts mit dem worksheet Element zu tun hat. Ersteres bezieht sich auf die Auflistung der in der Arbeitsmappe enthaltenen Tabellen (also in der workbook.xml) und letzteres ist die Definition des Inhalts dieser Tabellen (worksheet.xml).

Jetzt haben wir das SheetData-Element, also die Stelle, an der die Tabellenzeilen aufgelistet sind. Die Zelladresse wird hier im Format „A1“ übergeben. Um an die Zeilennummer zu kommen, habe ich eine kleine Extensions Class geschrieben, die die Methode RemoveAllButNumbers für den Typ String bereit stellt.

UInt32Value rowIndex = (UInt32Value)cellRef.RemoveAllButNumbers();

Mit dem so gewonnenen RowIndex wird die Referenz auf die Zeile geholt. Sollte die nicht existieren, erzeugen wir eine neue Zeile. Dabei ist unbedingt zu beachten, dass die Reihenfolge stimmt (aufsteigend). Die Funktion CreateRow weiter unten erledigt das.

IEnumerable<Row> rows = sd.Elements<Row>()
   .Where(r => r.RowIndex.Value == rowIndex);
Row row = rows.FirstOrDefault();
if (row == null)
  row = CreateNewRow(ref sd, rowIndex);

Dasselbe gilt für die Zelle.

Cell cell = row.Elements<Cell>()
   .Where(c => c.CellReference == cellRef).FirstOrDefault();
if (cell == null)
  cell = CreateNewCell(ref row, cellRef);

Am Ende wird nur noch der Shared String mit der Zelle verlinkt und das Worksheet gespeichert. Die Funktion dafür wurde schon in Teil 2 beschrieben.

cell.DataType = CellValues.SharedString;
cell.CellReference = cellRef;
cell.CellValue = new CellValue(
   InsertSharedStringItem(sharedString, sstPart).ToString());
 
ws.Save(wsPart);

Hilfsfunktionen zum Erzeugen einer neuen Zeile bzw. Zelle. Beide müssen in aufsteigender Reihenfolge im Markup erscheinen.

private Row CreateNewRow(ref SheetData sd, UInt32Value rowIndex)
{
  Row newRow = new Row();
  newRow.RowIndex = rowIndex;
  Row lastRow = (Row)sd.Elements<Row>()
    .Where(r => r.RowIndex < rowIndex).LastOrDefault();
  if (lastRow != null)  
    sd.InsertAfter(newRow, lastRow);
  else
    sd.InsertAt(newRow, 0);
  return newRow;
}

private Cell CreateNewCell(ref Row row, string cellRef)
{
  Cell lastCell = row.Elements<Cell>().Where
     (c => string.Compare(c.CellReference.Value, cellRef, true) < 0)
        .LastOrDefault();

  Cell newCell = new Cell();
  if (lastCell != null)
    row.InsertAfter(newCell, lastCell);
  else
    row.InsertAt(newCell, 0);

  return newCell;
}

Die Extensions Class, welche die Funktion RemoveAllButNumbers für Strings zur Verfügung stellt. Damit werden aus der Zelladresse alle Zeichen herausgenommen, die keine Ziffern darstellen. Das Ergebnis entspricht der Zeilennummer.

internal static class MyExtensions
{

  internal static UInt32 RemoveAllButNumbers(this string s)
  {
    string res = string.Empty;
    char[] numbers = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    foreach (char c in s)
    {
      if (numbers.Contains(c))
      {
        res += c;
      }
    }
    return UInt32.Parse(res);
  }

}

[ Fortsetzung folgt ]

Open XML Dateien aufbauen und verändern (Teil 2)

jensha — Wed, 15 Dec 2010 11:26:06 GMT

Der Umgang mit Inline und Shared Strings in Excel

Beim Quellcode aus Teil 1 muss noch einiges erklärt werden. Das Erste wäre das Einfügen des Worksheet Parts und das Anlegen einer Tabelle in demselben. Ich habe dort die Funktion InsertWorksheetPart aufgerufen, die jetzt noch implementiert werden muss. Der komplizierteste Teil dabei ist das Ermitteln der neuen ID für die einzufügende Tabelle. Wichtig ist, dass die neue ID nicht schon vorkommt. Dabei hilft ein wenig LINQ. Mit Hilfe einer Lambda Function kann man schnell die höchste Sheet ID herausfinden.

private WorksheetPart InsertWorksheetPart(WorkbookPart wbPart, string sheetName)
{
  // Hinzufügen eines Worksheet Parts zum Workbook.
  WorksheetPart wsPart = wbPart.AddNewPart<WorksheetPart>();
  string rId = wbPart.GetIdOfPart(wsPart);

  // eindeutige ID ermitteln = höchste sheetID + 1:
  uint sheetId = 1;
  Sheets sheets = wbPart.Workbook.GetFirstChild<Sheets>();
  if (sheets.Elements<Sheet>().Count() > 0)
    sheetId = sheets.Elements<Sheet>().Select(s => s.SheetId.Value).Max() + 1;

  // Das Worksheet mit dem Workbook verbinden:
  Sheet sheet = new Sheet() { Id = rId, SheetId = sheetId, Name = sheetName };
  sheets.Append(sheet);
  wbPart.Workbook.Save();

  return wsPart;
}

Die Funktion ist relative praktisch, da es unerheblich ist, ob man eine neue Datei anlegt oder einfach eine neue Tabelle in eine bestehende Arbeitsmappe hängt.

Nun zum Hinzufügen von Zellen mit Strings. In Teil 1 wurde schon angedeutet, dass Tabellen zeilenweise aufgebaut sind. Wir hatten auch festgehalten, dass es Inline Strings und Shared Strings gibt.

private Cell CreateCellWithInlineString(string cellRef, string cellValue)
{
  Cell c = new Cell();
  c.DataType = CellValues.InlineString;
  c.CellReference = cellRef;
  InlineString istr = new InlineString(
                        new Text(cellValue));
  c.AppendChild(istr);
  return c;
}

Die Markup-Repräsentation eines Inline Strings würde folgendermaßen aussehen:

<x:c r="A1" t="inlineStr">
   <x:is>
      <x:t>Der Zellwert als String</x:t> 
  </x:is>
</x:c>

Shared Strings sind etwas aufwändiger zu handhaben, da immer zuerst geschaut werden muss, ob der String als solcher schon in der Shared Strings Tabelle vorhanden ist bzw. diese überhaupt da ist. Das Grundgerüst für die Zelle sieht so aus:

private Cell CreateCellWithSharedString(string cellRef, string sharedString, 
                                        SharedStringTablePart sstPart)
{
  Cell c = new Cell();
  c.CellReference = cellRef;
  c.DataType = CellValues.SharedString;
  c.CellValue = 
    new CellValue(InsertSharedStringItem(sharedString, sstPart).ToString());
  return c;
}

Einen String in die Shared Strings Tabelle eintragen:

private static int InsertSharedStringItem(string newString, 
                                          SharedStringTablePart sstPart)
{
  // SharedStringTable erzeugen, falls nicht vorhanden
  if (sstPart.SharedStringTable == null)
    sstPart.SharedStringTable = new SharedStringTable();

  // SharedStringTable durchsuchen. Wenn String vorhanden, Index zurück geben
  int i = 0;
  foreach (SharedStringItem ssi in sstPart.SharedStringTable.Elements<SharedStringItem>())
  {
    if (ssi.InnerText == newString)
      return i;
    i++;
  }

  // String ist nicht da ==> SharedStringItem erzeugen
  sstPart.SharedStringTable.AppendChild 
  (new SharedStringItem(new Text(newString)));
  sstPart.SharedStringTable.Save();

  return i;
}

Die Markup-Repräsentation eines Shared Strings würde folgendermaßen aussehen:

<c r="D1" t="s">
  <v>0</v>
</c>

Der Verweis zeigt auf den String an der Position 0 in der Shared Strings Tabelle, die im Markup so aussehen könnte:

<sst xmlns="http://schemas...spreadsheetml/2006/main" count="5" uniqueCount="3">
  <si>
    <t>Microsoft</t> 
  </si>
  <si>
    <t>Jens Häupel</t> 
  </si>
  <si>
    <t>Der Zellwert als String</t> 
  </si>
</sst>

[ Fortsetzung folgt ]

Open XML Dateien aufbauen und verändern (Teil 1)

jensha — Tue, 14 Dec 2010 15:28:28 GMT

Der Umgang mit Strings in Excel

Nach längerer Zeit der Funkstille, begründet durch emsiges Herumreisen, gemeinsames Herumsitzen in eingeschneiten Fliegern auf dem Rollfeld sowie sonstiger allgemeiner vorweihnachtliche Hatz, will ich mir wieder etwas Zeit für die Technologie nehmen. Gerade in letzter Zeit wurde an einigen Stellen – wohl im Zuge der Erneuerung – die Frage in Richtung Open XML gelenkt. Oftmals sollten Dateien (Reports) aufgebaut oder ergänzt werden. Diesem Thema will ich mich in den nächsten Wochen widmen.

Da Excel-Dateien eine Art dreidimensionaler Struktur aufweisen – Zeilen, Spalten und Tabellen), verkompliziert sich deren Aufbau im Vergleich zu Word etwas. Um Speicherplatz zu sparen, wird eine Shared Strings-Tabelle verwendet, die für alle in einer Arbeitsmappe enthaltenen Tabellen zuständig ist. Der gesamte Inhalt einer Zelle innerhalb einer Tabelle entspricht einem Shared String, sofern er nicht eine Formel oder Zahl darstellt. In der Reihenfolge des Anlegens werden die Strings in der Shared Strings-Tabelle indiziert und über den Indexwert in der Zelle verlinkt.

Daneben gibt es noch Inline Strings, also Zeichenketten, die direkt innerhalb der Zelle in deren Markup gespeichert werden. Inline Strings werden von Excel allerdings automatisch in Einträge in der Shared Strings-Tabelle umgewandelt. Welchen Sinn haben sie dann? Nun, sie stellen einen einfachen Weg dar, Tabellen aufzubauen, ohne sich um die Komplexität der (externen) Shared Strings-Tabelle kümmern zu müssen.

Neben der WindowsBase Assembly wird die Bibliothek für das Open XML SDK 2.0 benötigt. Diese liefert zum einen eine höhere Abstraktion als die Methoden von System.IO.Packaging und zum anderen werden die Elemente des Markups (WordML, SpreadsheetML, etc.) als Objekte zur Verfügung gestellt. Damit werden viele Fehler (sofern es denn Leute gibt, die welche machen…) in die Compiletime verlagert (statt sie zur Laufzeit zu bekommen).

Wir unterscheiden zwischen den Parts, die eine logische Einheit innerhalb eines Open XML Files darstellen (Workbook, Worksheet) und dem XML, das die Repräsentation des eigentlichen Inhalts der Tabellen ist. Beides muss angelegt werden. Das grobe Gerüst ist hier zu sehen:

private void CreateExcelFile(string FName)
{

using (SpreadsheetDocument sDoc =
SpreadsheetDocument.Create(FName, SpreadsheetDocumentType.Workbook))

{
WorkbookPart partWB = sDoc.AddWorkbookPart();

   // Formatvorlagen hinzufügen:
   WorkbookStylesPart partStyles = …

   // Basisdokument Workbook.xml anlegen:
   Workbook wb = new Workbook(new Sheets());
   wb.Save(partWB);

   // Basis-WorksheetPart hinzufügen:
   WorksheetPart partWS =
      InsertWorksheetPart(partWB, "Open XML SDK Samples");

   // SharedStringTable hinzufügen:
   SharedStringTablePart partSharedStrings =
      partWB.AddNewPart<SharedStringTablePart>();

   // worksheet.xml erzeugen:
   Worksheet ws = new Worksheet();
   SheetData sd = new SheetData();
   ws.AppendChild(sd);

   // Zeilenweise Zellen hinzufügen:
   Row r1 = new Row();
   r1.RowIndex = 1;
   r1.AppendChild( +++ );

   Row r3 = new Row();
   r3.RowIndex = 3;
   r3.AppendChild( +++ );

   sd.AppendChild(r1);
   sd.AppendChild(r3);
   ws.Save(partWS);

}
}

Excel verlangt nach einer Datei, in der die Formatvorlagen definiert sind, dem WorkbookStylesPart. Ich gehe davon, dass keiner diesen Part von Anfang an erzeugt, sondern Excel als Templating Tool verwendet. Man nehme einfach eine Excel-Arbeitsmappe, die die gewünschte Formatierung enthält (bzw. formatiert Teile der Tabelle wie gewünscht). Das kann auf zwei Arten in unser Programm integriert werden:

Möglichkeit 1:

Man öffnet diese Excel-Datei mit dem Open XML SDK 2.0 Productivity Tool und lässt vom Reflector den Code erzeugen.

Der Aufruf sieht dann folgendermaßen aus:

WorkbookStylesPart partStyles = partWB.AddNewPart<WorkbookStylesPart>();
partStyles.Stylesheet = GenerateStylesSheet();
partStyles.Stylesheet.Save(partStyles);

Möglichkeit 2:

Man gibt der Excel-Datei den Suffix .zip und öffnet den Container. Im Ordner \xl befindet sich die Datei styles.xml. Diese wird in die Ressourcen des eigenen Programms aufgenommen.

Der Aufruf sieht dann folgendermaßen aus:

WorkbookStylesPart partStyles = partWB.AddNewPart<WorkbookStylesPart>();
XmlDocument stylesXML = new XmlDocument();
stylesXML.LoadXml(Properties.Resources.styles);

using (StreamWriter streamStylesXML = 
   new StreamWriter(partStyles.GetStream(FileMode.Create, FileAccess.Write)))
{
   stylesXML.Save(streamStylesXML);
}

Die weitere Vorgehensweise ist schnell erklärt: Das Workbook.xml enthält Informationen über in der Arbeitsmappe enthaltene Tabellen (Worksheets). Gespeichert wird sie im Workbook Part. Danach muss mindestens eine Tabelle (Worksheet.xml) angelegt und im Worksheet Part gespeichert werden.

Wichtig in der worksheet.xml ist das sheetdata Element. An dieses werden die Zeilen angehängt, die wiederum die Zellen enthalten.

Die Shared Strings-Tabelle wird ebenfalls schon hier angelegt, wir benötigen sie erst später.

[ Fortsetzung folgt ]

VSTO Deployments for ALLUSERS

jensha — Fri, 10 Sep 2010 12:25:35 GMT

In dem Blogeintrag vom 15. März hatte ich schon darüber geschrieben, dass man nun mit Hilfe eines Patches für Office 2007 VSTO-Erweiterungen für alle angemeldeten Benutzer unter HKLM installieren kann. Der Hotfix mußte allerdings manuell installiert werden.

Nun versicherte mir der verantworliche Program Manager, dass der Hotfix in ein Package eingeflossen ist, welches wiederum über die automatischen Office Updates mit verteilt wurde. Wenn also die aktuellen Updates für Office 2007 installiert worden sind, sollte man davon ausgehen können, dass man auch ohne das manuelle Installieren des o.g. Hotfixes VSTO-Erweitereungen für alle Benutzer installieren kann.