2006/11/29

XML in .NET 2.0 (part II)

So nun will ich als Nachtrag noch eine weitere Lösung zu dem in http://alexkuechler.blogspot.com/xml_in_dotnetzweinull geschilderten Problem geben. Diese Lösung soll diesmal auf dem Document Object Model beruhen.
Folgende Lösung zu 1.)
// Create XMLDocument with xml file
XmlDocument document = new XmlDocument();
document.Load(@"myXmlFile.xml");

XmlNodeList nlType = document.GetElementsByTagName("type");
return nlType.Count;

Kurzum:
  1. Dokument laden
  2. Alle Knoten mit einem bestimmten namen ("type") in die Liste laden und
  3. Die Anzahl der Elemente in der Sammlung zählen
Folgende Lösung zu 2.)
// Select all nodes 'Type'
XmlNodeList nodeList = document.GetElementsByTagName("type");
foreach (XmlNode n in nodeList)
{
currentCounter = 0;
// Create NodeList with all nodes in Mebers whose text for the MemberType is Method
// In plain text: n.SelectNodes(".//MemberType[.='Method']")
XmlNodeList childNodeList = n.SelectNodes(".//" + "memberType" + "[.='" + "Method" + "']");
// Simply count the arraysize
currentCounter = childNodeList.Count;
// Read attribute Name of the Type with '@'
currentClassName = n.SelectSingleNode("./@name").Value.ToString();
// If currentCounter greater than highestCounter ...
if (currentCounter > highestCounter)
{
// ... set variables to save the classname and counter
highestCounter = currentCounter;
highestClassName = currentClassName;
}
}

Kurzum:
  1. Auf allen "type"-Elementen iterieren
  2. Die Elemente "memberTye" deren Text "Method" lautet auswählen
  3. Auf der Liste die Elemenete zählen
  4. Namen der übergeordneten Klasse ("type") aus dem Attribut "name" auswählen
  5. Werte auf neue Höchstzahl vergleichen und ggf. als neues Maximum speichern
Also insgesamt auch nicht schwer.
Wer Interesse an den Materialien meienr Vorlesung hat, kann gerne mal auf http://www.dcl.hpi.uni-potsdam.de/teaching/xml06/ nachsehen.

2006/11/21

XML in .NET 2.0

Heute mal wieder ein fachlicher Post ...
Eine Aufgabe für die Uni erforderte das Bearbeiten einer XML-Datei. Dabei geht es um das Zählen der Elemente mit einem bestimmten Namen.

Dabei ist die XML-Datei wie folgt aufgebaut:
//... XML-Markup
//<typecollection>
// <types library="ABC">
// <type name="nameABC1">
// <members>
// <membertype>Constructor</membertype>
// </members>
// <members>
// <membertype>Method</membertype>
// </members>
// </type>
// </types>
// <types library="CDE">
// <type name="nameCDE1">
// <members>
// <membertype>Constructor</membertype>
// </members>
// </type>
// </types>
//</typecollection>


So weit so gut.
Was soll damit nun gemacht werden?
1.) Zähle die Menge der Elemente "Type"
2.) Benenne das Elemente vom Type "Type" welches die meisten Kindelemente vom Type "MemberType" mit dem Wert "Method" hat.

Lösung:
Ich verwende dazu den im .NET 2.0 Framework beliebten XMLTextReader, der sequentiell ein XML-Dokument durchläuft und bei jedem Element stehenbleibt und somit eine Aktion ermöglicht.
Folgende Lösung zu 1.):
// Create XMLTextReader with xml file
XmlReader reader = new XmlTextReader("myXmlFile.xml");
//Moves the reader to the root element
reader.MoveToContent();


int currentCounter = 0;
while (reader.Read())
{
// If the element is "Type" and a start-element (without closing-tags would be counted too)
if (reader.Name.Equals(elementName) && reader.IsStartElement())
{
currentCounter++;
}
}


Kurzum:

  1. Erstelle einen XmlReader mit dem dazu zu bearbeitenden Dokument
  2. Setze den Reader auf den Beginn des Inhalts der XML-Datei
  3. Lese die komplette Datei über eine while-Schleife
  4. Wenn das jeweilige Element ein Starttag für das Element "Type" ist, zähle den Counter hoch
Ganz einfach also. Demnächst folgt noch eine alternative Lösung mittels XML-DOM (Document Object Model) ...

Folgende Lösung zu 2.):
// Create XMLTextReader with xml file
XmlReader reader = new XmlTextReader("myXmlFile.xml");
//Moves the reader to the root element
reader.MoveToContent();

int currentCounter = 0;
string currentClassName = "";
int highestCounter = 0;
string highestClassName = "";
while (reader.Read())
{
// If element = className and node is startelement
if (reader.Name.Equals(className) && reader.NodeType == XmlNodeType.Element)
{
// Read value of attribute 'Name' and set currentCounter = 0
currentClassName = reader.GetAttribute("Name");
currentCounter = 0;
}
// If element = memberType and element is startelement
if (reader.Name.Equals(memberTypeName) && reader.NodeType == XmlNodeType.Element)
{
// If element = memberTypeMethodType
if (reader.ReadElementString(memberTypeName).Equals(memberTypeMethodType))
{
// Increment currentCounter
currentCounter++;
}
}
// If element = className and node is endelement
if (reader.Name.Equals(className) && reader.NodeType == XmlNodeType.EndElement)
{
// Write output to console
Console.WriteLine("Die Klasse '{0}' hat {1} Methoden.", currentClassName, currentCounter.ToString());
// If currentCounter greater than highestCounter ...
if (currentCounter > highestCounter)
{
// ... set variables to save the classname and counter
highestCounter = currentCounter;
highestClassName = currentClassName;
}
}
}

Kurzum:

  1. Erstelle einen XmlReader mit dem dazu zu bearbeitenden Dokument
  2. Setze den Reader auf den Beginn des Inhalts der XML-Datei
  3. Lese die komplette Datei über eine while-Schleife
  4. Wenn das jeweilige Element ein Starttag für das Element "Type" ist, lies das Attribut Name um zu wissen bei welchem 'Type' man ist
  5. Wenn das aktuelle Element 'MemberType' und der Wert 'Method' ist (ausgelesen durch
    ReadElementString()), zähle den Counter um eins hoch
  6. Wenn das Element 'Type' als schließendes Element auftaucht, überprüfe ob der aktuelle Wert höher als der letzte höchste Wert war und merke ihn Dir ggf. als neuen höchsten Wert

Das war's. Die Schritte 4-6 kann man vielleicht auch eleganter über ein switch-Statement machen, aber der Einfachheit halber habe ich mich dafür entschieden :-)

P.S.: Sorry für die unvorteilhafte Einrückung des Quelltextes, aber ich denke es geht gerade noch so. Falls jemand Probleme dabei hat, einfach Kommentar posten ...

2006/11/16

As time goes by

Meine Herren, wie die Zeit vergeht ...

Eben war ich noch in Nürnberg zu einem 2 1/2-monatigem Praktikum und nun habe ich schon wieder 5 Wochen Uni rum. Ich habe interessante Vorlesungen oder viel mehr Seminare zu besuchen, bin an den Wochenenden viel in Deutschland unterwegs und versuche mich nebenbei noch auf meiner Masterarbeit organisatorisch vorzubereiten. Ach ja ... und arbeiten gehe ich ja auch wieder. Wie Freundin und Familie? Klar habe ich die! Und nein: mein Tag hat nicht mehr als nur 24 Stunden! Aber die können auch reichen :-)

Mit jetzt wieder langsam angewöhnender Zeitplanung kann man so einiges schaffen. Erstmal alle langfristigen Unitermine aufschreiben, dann sortieren (neben Zeit ggf. auch Priorität) und dann überlegen, wann und wo man sich womit beschäftigen kann. Außerdem die Zeit in der S-Bahn konsequent zum Lesen nutzen. Das ist mind. 1h pro Tag; optimal um Paper zu lesen. Und dann in das Schwierigste: in den fiesen Momenten, wo man denkt "jetzt pack ich mich erstmal vor die Glotze" darauf verzichten. Aufgaben für die Uni (zumeist am PC) machen, Lesen, Essen und Aufräumen haben sich dabei zu meinen bevorzugten Allein-zu-Haus-Aktivitäten entwickelt. Na ja, und zu zweit hat man ja noch ein paar zusätzliche Alternativen. Und die müssen auch nicht immer was mit "Arbeit" zu tun haben ... ;-)

2006/11/03

Restart bitte

So, nun bin ich also wieder als Werksstudent bei meinem alten Unternehmen beschäftigt. Und wie leider oftmals üblich habe auch ich den ersten Tag mit Warten auf Benutzerkennungen, Kennwörter und Zugangsberechtigungen verbracht. Ok, das Schicksal teilen viele, aber wer hat denn von der IT Hotline schon mal die Antwort bekommen, das die Profileinrichtung im "Normalfall" DREI Tage dauert? Und überhaupt: laut Vertrag ist heute bereits mein dritter Tag, also warum geht es nicht? Na ja, nun habe ich erstmal ein paar Updates gezogen, den IE 7 installiert und erfreue mich nun erstmalig am Tabbrowsing. Vom Hocker haut es mich immer noch nicht, aber vielleicht erkenne ich den Nutzen ja auch noch ...
Nun, einige Rechner-Neustarts später, nutze ich also die Zeit mich lesenderweise mit Codeoptimierungen zu beschäftigen und werde wohl den frühesten Feierabend ever genießen ....