Codefieber.de

XML String escape ist notwendig, wenn XML-Text in einem XML-Dokument gespeichert werden soll. Wenn die Sonderzeichen nicht escaped werden, wird ein Teil des ursprünglichen XML-DOM und nicht ein Wert von einem Knoten angezeigt.

XML-Escaping bedeutet im Grunde, dass die unten genannten 5 Chars mit neuen Werten ersetzt werden.

Die Ersetzungen sehen wie folgt aus:

< -> &lt;
> -> &gt;
" -> "
' -> '
& -> &amp;

Hier zeige ich nun vier Wege um ein XML in C# zu encoden:

1. string.Replace() 5 mal hintereinader

Das ist nicht schön, aber es funktioniert. Zu beachten ist, dass Replace(“&”, “&”) zuerst kommen sollte, da die Funktion auch schon escapete &-Zeichen nochmal escapen kann!

WebUtility.HtmlDecode(string);

string xml = "<node>it's my \"node\" & i like it<node>";
encodedXml = xml.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;").Replace("\"", "&quot;").Replace("'", "&apos;");

// RESULT: &lt;node&gt;it&apos;s my &quot;node&quot; &amp; i like it&lt;node&gt;

Weiterlesen →

In dem vorherigen Eintrag habe ich über die XmlWriter-Klasse berichtet, mit deren Hilfe wir eine XML erstellen können. Doch für manche Situationen, vor allem, wenn dabei Aktualisierungen an einer bestehenden XML vollbracht werden sollen, hat sich die XmlDocument-Klasse als nützlich erwiesen. Negativer Punkt wäre hier allerdings der höhere Speicherverbrauch, vor allem bei großen XML-Dokumenten.

Hier ist ein Codebeispiel:

using System;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace WritingXml
{
    class Program
    {
        static void Main(string[] args)
        {
            XmlDocument xmlDoc = new XmlDocument();
            XmlNode rootNode = xmlDoc.CreateElement("users");
            xmlDoc.AppendChild(rootNode);

            XmlNode userNode = xmlDoc.CreateElement("user");
            XmlAttribute attribute = xmlDoc.CreateAttribute("age");
            attribute.Value = "42";
            userNode.Attributes.Append(attribute);
            userNode.InnerText = "John Doe";
            rootNode.AppendChild(userNode);

            userNode = xmlDoc.CreateElement("user");
            attribute = xmlDoc.CreateAttribute("age");
            attribute.Value = "39";
            userNode.Attributes.Append(attribute);
            userNode.InnerText = "Jane Doe";
            rootNode.AppendChild(userNode);

            xmlDoc.Save("test-doc.xml");
        }
    }
}

Hier die herauskommende XML:
Weiterlesen →

Da XML einfacher Text ist, könnte man einfach XML-Tags in eine Datei schreiben und dieser eine XML-Erweiterung geben, allerdings ist es einfacher und sicherer eine XML von dem .NET-Framework erstellen zu lassen. Genau wie mit dem Lesen von XML, gibt es mindestens zwei verschiedene Möglichkeiten: Der XmlWriter-Ansatz und der XmlDocument-Ansatz. Dieser Artikel wird sich auf den ersten Ansatz konzentrieren.

Der Unterschied zwischen den beiden Methoden ist wieder einmal vor allem auf den Speicherbedarf bezogen – XmlWriter benötigt weniger Speicher als XmlDocument. XmlDocument ist nur ein Thema wenn man sehr große Dateien schreiben möchte. Ein weiterer wichtiger Unterschied ist, dass bei der Verwendung von XmlDocument, dass man eine vorhandene Datei lesen, manipulieren und die Änderungen schreiben kann. Mit der XmlWriter-Klasse, muss das gesamte Dokument jedes Mal neu geschrieben werden. Dies ist nicht unbedingt ein Problem, es kommt halt darauf an, was man wirklich in der jeweiligen Situation benötigt.

Hier ist ein Beispiel um eine XML zu schreiben, welche die XmlWriter Klasse nutzt:
Weiterlesen →

Um einen Stream in ein byte-Array zu schreiben kann man nachfolgenden Snippet nutzen. Hier wird einer Methode (private static byte[] ReadFully(Stream input, int startPosition, int endPosition)) die Paramter Stream input, int startPosition und int endPosition übergeben.

In der Methode selber wird ein byte-Array buffer instanziiert, welcher die Länge des Input-Streams hat.
Mit input.Position = 0 wird die Position auf 0 gesetzt und mit input.Seek(startPosition, SeekOrigin.Current); wird der Zeiger auf die übergebene Startposition gesetzt.

In einer While-Schleife wird nun der Stream ab der angegebenen Position gelesen, solange int read größer als 0 ist.
In der Schleife werden die Daten aus aus dem Buffer in den MemoryStream geschrieben. Ist die Position größer oder gleich endPosition wird die While-Schleife beendet und es wird der MemoryStream als byte-Array zurückgegeben.

Weiterlesen →

Wer die Zeit messen möchte, die eine Funktion bzw. eine Prozedur zur Abarbeitung benötigt, kann folgendes Snippet benutzen:

 
// using System.Diagnostics;
Stopwatch watch = new Stopwatch();
watch.Start();

//Hier die Funktion einfügen deren Zeit gemessen werden soll

watch.Stop();
MessageBox.Show("Time spent: " + watch.Elapsed);

Ansich ist das Snippet selbserklärend, aber der Vollständigkeit halber: Für die Klasse Stopwatch wird das using System.Diagnostics; benötigt. Stopwatch wird instanziert und mit watch.Start(); gestartet. Dies sollte man vor einer Funktion / Prozedur machen. Am Ende der Funktion / Prozedur wird dann watch.Stop(); aufgerufen, welche die Zeitmessung wieder stoppt.

Auf die verstrichene Zeit kann mittels watch.Elapsed zugegriffen werden.

Ausgegeben wird die Information mit MessageBox.Show("Time spent: " + watch.Elapsed);

Wer keine Consolenanwendung o.ä. nutzt, kann wie hier beschrieben die Verarbeitungszeit im Output von Visual Studio ausgeben lassen.

Letztens habe ich eine sehr große XML-Datei verarbeitet, was eine sehr lange Verarbeitungszeit mit sich brachte. Deshalb wollte ich die Zeit messen wie lange der Prozess dauert. Da die Applikation allerdings keine Consolen-, oder WinForms- (o.ä.) Anwendung ist, konnte ich nicht einfach die Zeit auf der Console bzw. in einem Label ausgeben.
Aber hier ein kleiner Tipp wie man trotzdem die verstrichene Zeit (ohne unbedingt mittels Breakpoint debuggen zu müssen) ausgeben kann. Nämlich in dem Output Fenster von Visual Studio:

using System.Diagnostics;

Debug.WriteLine("Send to debug output.");

Dieser Befehl gibt einen übergebenen Text im Output Fenster aus, ähnlich wie bei Java und Eclipse system.out.println("") das macht.

Um eine Position in einem C# – Stream (z.B.: ein System.IO.Stream) zu finden, kann man dies mit einer byte-Sequenz erreichen.
Dazu wird der Stream und die zu findende byte-Sequenz an eine Methode übergeben, die zuerst die Länge der byte-Sequenz in ein byte-Array buffert.
Danach instanziiert man einen neuen BufferedStream mit dem zu übergebenen Stream und der byte-Sequenzlänge.

In einer While-Schleife wird nun überprüft ob der BufferStream gleich der byte-Sequenz ist. Ist dem so, wird die BufferStream-Position minus der byte-Sequenzlänge als Matched-Position zurückgegeben.
Ist der BufferStream und die byte-Sequenzlänger nicht gleich, wird die PadLeftSequence mit den Parametern buffer und byteSequence aufgerufen.

public static long FindPosition(Stream stream, byte[] byteSequence)
{
    if (byteSequence.Length < stream.Length)
        return -1;

    byte[] buffer = new byte[byteSequence.Length];

    using (BufferedStream bufStream = new BufferedStream(stream, byteSequence.Length))
    {
        int i;
        while ((i = bufStream.Read(buffer, 0, byteSequence.Length)) == byteSequence.Length)
        {
            if (byteSequence.SequenceEqual(buffer))
                return bufStream.Position - byteSequence.Length;
            else
                bufStream.Position -= byteSequence.Length - PadLeftSequence(buffer, byteSequence);
        }
    }
    return -1;
}

In dieser Methode (PadLeftSequence()) wird wie gesagt, der Buffer (bytes) und die byte-Sequenz (seqBytes) als Parameter übergeben. In einer While-Schleife werden die beiden byte-Arrays aux1 & aux2 kopiert und die Variable n dekrementiert. Ist nun aux1 gleich mit aux2, haben wir die Position gefunden und geben sie zurück.

private static int PadLeftSequence(byte[] bytes, byte[] seqBytes)
{
    int i = 1;
    while (i < bytes.Length)
    {
        int n = bytes.Length - i;
        byte[] aux1 = new byte[n];
        byte[] aux2 = new byte[n];
        Array.Copy(bytes, i, aux1, 0, n);
        Array.Copy(seqBytes, aux2, n);
        if (aux1.SequenceEqual(aux2))
            return i;
        i++;
    }
    return i;
}