PS XmlClassCreator [updated: 31.10.2010]

Hallo ihr lieben,

wieder einmal etwas kleines von mir.

Da ich oftmals Xml-Dateien vorgesetzt bekomme, die mir sagen sollen, wie eine Klasse auszusehen hat, habe ich ein kleines Tool entwickelt, dass eine Xml-Datei einliest und aus diesem eine Klasse erstellt.

Die Xml-Dateien müssen einer festen Struktur folgen. So müssen bestimmte Attribute angegeben werden.

Eine Beispiel Xml-Datei:

<?xml version="1.0" encoding="utf-8" ?> 
<Person modifier="public" >
   <NameSpace>PS.Windows.Forms.XmlClassCreator</NameSpace>
   <Name type="Property" valueType="String" />
   <Money type="Property" valueType="Double" />
   <DateOfBirth type="Property" valueType="DateTime" />    
   <AddMoney type="Method" returnValue="void" modifier="public" />
   <GetMoney type="Method" returnValue="Double" modifier="public" />
   <HairColor type="Field" valueType="String" />
</Person>

Der Klassenname wird dem RootElement entnommen, in diesem Fall wäre es "Person". Im Root Element wird als Attribut außerdem angegeben, welcher Zugriffsmodifier erstellt werden soll. - In diesem Fall wäre es eine public class.

Wo im Xml Knoten der NameSpace verankert wird ist eigentlich unrelevant. Ich habe ihn im Beispiel Direkt als ersten Child-Knoten niedergeschrieben. Dies ist auch der einzige Knoten, bei dem nur der Inhalt und keine weiteren Attribute notwendig sind. Ihr solltet allerdings darauf achten, diesen nur einmal hinzuzufügen. Eine Klasse kann ja schließlich auch nicht in 5 Namespaces gleichzeitig liegen. 8)

Kommen wir nun zum eigentlich interessanten, die weiteren Xml-Knoten.
Egal ob es sich um Felder, Properties oder Methoden handelt, der Name des jeweiligen Sprachkonstrukts wird direkt vom Xml-Tag Namen genommen. - So entsteht Beispielsweise die Property Name.

Der Typ einer Property bzw. eines Feldes wird mittels des Attributs "valueType" angegeben. Wäre um Beim Namen zu bleiben nun also eine Property vom Typ String mit der Bezeichnung Name.

Methoden unterscheiden sich in den Attributen von Feldern und Properties. Diese erhalten keinen valueType sondern ein Attribut "returnValue". Dieser gibt an, was die Methode zurück gibt. Außerdem erhalten Methoden wie auch die Klasse ein modifier-Attribut.

Die Angabe von Parametern für Methoden ist geplant aber noch nicht implementiert. - Aber um euch das Projekt nicht vozuenthalten, gibt es nun schon die Version 1.0 für euch. Vielleicht könnt ihr es ja gebrauchen.

Anbei nun noch die entstandene Klasse:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PS.Windows.Forms.XmlClassCreator
{
	public class Person
	{
		#region Fields

		private String _HairColor;
		#endregion
		#region Properties

		private String _Name;
		public String Name
		{
			get { return _Name; }
			set { _Name = value; }
		}

		private Double _Money;
		public Double Money
		{
			get { return _Money; }
			set { _Money = value; }
		}

		private DateTime _DateOfBirth;
		public DateTime DateOfBirth
		{
			get { return _DateOfBirth; }
			set { _DateOfBirth = value; }
		}
		#endregion
		#region Methods

		public void AddMoney()
		{

		}

		public Double GetMoney()
		{

		}
		#endregion
	}
}

Syntaxhighlighting ist ebenfalls noch nicht implementiert. Kommt aber in Version 1.1 ganz sicher. 🙂

Um euch nun aber nicht mit zu viel Worten von euren sonstigen Tätigkeiten abzuhalten gibt es nun den Download. Einen Screenshot werde ich im nächsten Beitrag anhängen.

Hier nun noch der versprochene Screenshot:

Hallo,

ich hab mal mitm Reflector reingeschaut und gesehen das du die einzelnen Teile manuell aus dem XMl aufbaust. Das halte ich für ziemlich umständlich. Mit nem passendel XSLT kriegst du so ein XML locker in C# Code transformiert. Ich würde eher diesen Ansatz versuchen.

Wo im Xml Knoten der NameSpace verankert wird ist eigentlich unrelevant. Sowas entspricht eigentlich nicht dem XML Gedanken. Sie sollten ein festes Schema haben, nur so kann man sie zufriedenstellend parsen.

Das war darauf bezogen, ob der NameSpace nun als erster ChildKnoten unter (in Bezug auf obiges Beispiel) Person ist, oder was weis ich der 3., nicht, dass wir den Xml-Gedanken über Bord werfen.

Bzgl. dem zusammenbau der Klasse, ja das ist noch etwas unsauber. - Und auch nicht ganz dass was ich mir vorgestellt hatte, aber eben ersteinmal eine funktionierende Variante.

Da ich das System am Ende sowieso noch dynamischer halten möchte, muss ich das zwangsläufig noch ändern. - So sollen Beispielsweise alle Namespaces die genutzt werden sollen im Xml-File mit angegeben werden können und vieles weitere.

Später soll es auch möglich sein mehrere Xml-Dateien einzulesen und daraus auch die entsprechenden Klassen zu generieren.

Deinen Tipp werd ich mir zu Herzen nehmen und schaun, dass ich auf der Basis den Creator umstelle.

Um nun allen anderen noch einen Überblick zu verschaffen was in Version 1.1 dazu kommen wird, werd ich es hier aufschlüsseln:
1.Syntax Highlighting für Xml und C# 1.Erweitertes Umwandlungssystem (auf Basis diesen und des Posts von Talla) 1.Angabe von Parametern für die Methoden 1.laden mehrerer Xml-Files und Generieren der Klassen daraus

Hallo inflames2k,

das Projekt bzw. die Idee finde ich nicht ganz so gut. Ich habe mir persönlich selber mal Gedanken über das Thema gemacht und denke so an Richtung T4. Mit dynamic in .NET 4 könnte man das auch ganz gut regeln. Aber ansonsten kann ich mich talla nur anschließen.

zero_x

Was die Idee betrifft sag ich nur XSD.exe 😃 Aber darum solls hier nicht gehen.

Klar geht das ganze ganz sicher auch mit der XSD.exe, aber man will ja dabei auch noch was lernen. 😃

Beispielsweise bin ich gerade an der Umsetzung via XSLT. - Mit XSL-Templates hab ich Beispielsweise noch nie etwas am Hut gehabt. - Daher kann ich hieraus wieder was lernen. - Irgendwann kann man das Wissen dann sicher auch gebrauchen.

Bis auf kleine Makel bin ich mit der Umsetzung auch schon fertig was die Creator Klasse um 90 % des Codes verkleinert hat.

Das schöne an dem neuen Ansatz ist auch, dass man das Programm nun sogar soweit ausbauen kann, dass man für so ziemlich jede Programmiersprache ein XSL-Template entwickeln kann und nur noch das gewünschte Template laden muss.

Alles was nicht ganz zum Projekt gehört bitte ausgegraut denken. 😛

// Mit fiel auf, aus der Idee lässt sich sogar noch weiteres machen. Ein Klassendesigner, wo die Projektdateien als XML abgelegt werden und daraus dann die Klassen generiert werden. - Ich lass mir das mal durch den Kopf gehen.

Da ich genug Zeit hatte nun das Update auf die Version 1.1. - Die Datei werde ich im ersten Post umgehend anhängen.

Alle angesprochenen Änderungen sind nun enthalten. - Aktuell wird wie eigentlich vorgehabt bisher nur in C# umgewandelt.

Das XSL-Template kann zwar auf eine andere Sprache angepasst werden, jedoch dürfte das Syntax Highlighting aktuell nicht funktionieren. - Mit der nächsten Version werd ich schauen ein Modulareres System zu erstellen, wo anhand von Modulen weitere Programmiersprachen eingebunden werden können.

1. Syntax Highlighting für Xml und C#
2. Erweitertes Umwandlungssystem (auf Basis diesen und des Posts von Talla)
3. Angabe von Parametern für die Methoden
4. laden mehrerer Xml-Files und Generieren der Klassen daraus

Alle 4 Punkte habe ich umgesetzt.

Eine XML Datei muss zum aktuellen Stand wie folgt aussehen:

<?xml version="1.0" encoding="utf-8" ?>
<ClassGenerator>
  <ImportNameSpaces>
    <ImportNameSpace>System</ImportNameSpace>
    <ImportNameSpace>System.Collections</ImportNameSpace>
    <ImportNameSpace>System.Collections.Generic</ImportNameSpace>
    <ImportNameSpace>System.Linq</ImportNameSpace>
  </ImportNameSpaces>
  <Class>
    <NameSpace>PS.Windows.Forms.XmlClassCreator</NameSpace>
    <Name>Person</Name>
    <Modifier>public</Modifier>
    <Fields>
      <Field>
       <Name>Testfield</Name>
       <Type>String</Type>
      </Field>             
    </Fields>
    <Properties>
      <Property>
        <Name>TestProperty</Name>
        <Type>String</Type>
      </Property>
    </Properties>
    <Methods>
      <Method>
        <Modifier>private</Modifier>
        <Name>TestMethod</Name>
        <ReturnType>void</ReturnType>
        <Parameters>
          <Parameter>            
            <Name>testParameter</Name>
            <Type>String</Type>
          </Parameter>
        </Parameters>
      </Method>
     </Methods>
  </Class>
</ClassGenerator>

Das XML-File sollte an sich selbst Erklärend sein, weshalb ich darauf jetzt nicht im Detail eingehe.

Wurden mehrere Dateien geöffnet, werden auch alle gleichzeitig in C#-Code umgewandelt. - Gespeichert werden muss jedoch jede Klasse einzeln. - Dies hab ich aus dem Grund so implementiert, dass nocheinmal alle Klassen vor dem Speichern durchgesehen werden.

// Xml Editiert - nach Hinweis von Talla.

Anbei ein neuer Screenshot:

Hallo,

so richtig schön ist das XML noch nicht. Die einzelnen Namespace Knoten solltest du auch in ein Namespaces Tag zusammenfassen, ähnlich wie du es ja später für die Methoden und Properties machst. Desweiteren fällt auf das du zwei verschiedene Namespace Tags hast, die den gleichen Namen haben aber untertschiedliche Kinder - einmal direkt als String den Namen und einmal in nem Name Unterknoten den Namen - sowas sollte nicht sein. Die solltest du vereinheitlichen vom Aufbau her (ich persönlich halte die Variante ohne Name Tag ausreichend). Wobei ich noch die beiden Typen von Namespaces die du ja eigentlich hast, deutlicher machen würde. Die Importe am Dateianfang vielleicht dann auch in ner Art ImportNamespaces Knoten um diese Namespaces deutlicher vom Namespace der Klasse zu unterscheiden.

Berechtigte Einwände. 😃

Werd ich noch ändern. - Ist ja nun nur noch eine Sache des XSL-Templates und der Xml-Datei.

Ich habe nun den Download geupdated. - Der Aufbau des Xml-Files ist dem Updatebeitrag zu entnehmen.