Startseite .Net C# Archive nach Kategorien "Filesystem" (Seite 2)

Kategorie: Filesystem

Unterverzeichnisse und Dateien eines Verzeichnisses auslesen 

using System.IO;

// Unterverzeichnisse und Dateien von "c:\" lesen
DirectoryInfo diCurrentDir = new DirectoryInfo(@"c:\");
DirectoryInfo[] diaSubDirs = diCurrentDir.GetDirectories("*.*");
FileInfo[] fiaFiles = diCurrentDir.GetFiles("*.*");

// Unterverzeichnisse
foreach (DirectoryInfo diDir in diaSubDirs)
{
    string sDirName = diDir.Name;
    string sDirAttr = diDir.Attributes.ToString();
}

// Dateien
foreach (FileInfo fiFile in fiaFiles)
{
    string sFileName = fiFile.Name;
    string sFileLength = fiFile.Length.ToString("N0");
    string sFileAttr = fiFile.Attributes.ToString();
}

Serialisierung – XML (allgemein)

Allgemein

  • im Beispiel wird ein Objekt mit seinen Unterobjekten als XML serialisiert und als Datei ObjektListe.xml gespeichert
  • Wichtig ist immer die Angabe der Standardkonstruktoren in allen Klassen, sonst werden Exceptions geworfen!
  • alle zu speichernden Elemente müssen public sein
  • Falls Objektreferenzen als public-Variablen verwendet werden, dann sollte man darauf achten, dass keine zirkulären Bezüge auftreten! Ggf. sollte man diese Variablen mit [XmlIgnore] überspringen.
  • ArrayList, List<T> (generische Listen) und ReadOnly-Properties werden nicht serialisiert!
  • Wichtig ist außerdem, dass nicht alle Elemente, z.B. Referenz-Variablen vom Typ “object”, als [XmlAttribute(“Name”)] definiert werden können. Die XMLTags müssen dann häufig in [XmlElement(“Name”)] umgeändert werden.

Beispielcode

using System.IO;
using System.Xml;
using System.Xml.Serialization;

// ein Enumerator, zur Demonstration
public enum ObjektTyp
{
    Viereck, // wird später als "Viereck" gespeichert
    [XmlEnum("D")]
    Dreieck, // wird später als "D" gespeichert
    [XmlEnum("Q")]
    Quadrat // wird später als "Q" gespeichert
}

// Basisobjekt zur Demonstration der Speicherung
// der Basis-Eigenschaften, importiert das abgeleitete
// Objekt "Objekt"
[XmlInclude(typeof(Objekt))]
public class BasisObjekt
{
    // Unterelement string
    [XmlElement("Name")]
    public string sName = "n/a";

    // Standardkonstruktor
    public BasisObjekt()
    {
    }
}

// Listenobjekt was innerhalb von ObjektListe verwaltet wird
// ist von BasisObjekt abgeleitet
public class Objekt : BasisObjekt
{
    // ein Beispiel-Attribut von Objekt
    [XmlAttribute("id")]
    public int iId;

    // private -> wird nicht gespeichert
    private float _a;

    // float-Property, wird erst nach allen lokalen public-Variablen gespeichert,
    // obwohl es von der Reihenfolge her vor _b kommen müsste
    [XmlElement]
    public float a
    {
        get
        {
            return _a;
        }

        set
        {
            _a = value;
        }
    }

    // float-Unterelement
    [XmlElement("b")]
    public float _b;

    // Enumerator-Unterelement
    [XmlElement("Typ")]
    public ObjektTyp otTyp;

    // ein ParameterArray mit 3 int-Parametern definieren
    [XmlArray("ParameterListe")]
    [XmlArrayItem("Parameter")]
    public int[] Params = new int[3];

    // Standardkonstruktor mit Aufruf des Konstruktors der Basisklasse
    public Objekt()
        : base()
    {
    }

    public Objekt(float fa, float fb, int iObjektId, ObjektTyp Typ)
    {
        _a = fa;
        _b = fb;
        iId = iObjektId;
        otTyp = Typ;
    }

    // kleine Ausgabefunktion zur Kontrolle der Objektvariablen nach dem Lesen
    public void Print()
    {
        Console.WriteLine(sName + "[" + otTyp.ToString() + "]");
        Console.WriteLine("ID: {0}", iId);
        for (int i = 0; i < 3; i++)
        {
            Console.WriteLine("Parameter {0}: {1}", i, Params[i]);
        }
        Console.WriteLine("{0} x {1} = {2}", _a, _b, _a * _b);
    }
}

// Rootobjekt [XmlRoot], das geladen und gespeichert werden soll  
[XmlRoot("Objektliste")]
public class ObjektListe
{
    // ein String
    [XmlElement("Name")]
    public string _sListenName;

    // dieses Element wird bei der Serialisierung ignoriert
    [XmlIgnore]
    public int _iID;

    // ein dynamisches List-Array mit Objekten definieren
    [XmlArray("Objekte")]
    [XmlArrayItem("Objekt")]
    public List<Objekt> Objekte = new List<Objekt>();

    // Standardkonstruktor
    public ObjektListe()
    {
    }

    public ObjektListe(string sListenName, int iID)
    {
        _sListenName = sListenName;
        _iID = iID;
    }
}

// Objekt serialisiert speichern 
private void btnSave_Click(object sender, EventArgs e)
{
    // Root-Objekt erstellen
    ObjektListe ol = new ObjektListe("Flächen", 1);

    // drei Listenelemente hinzufügen
    ol.Objekte.Add(new Objekt(1.2f, 3.4f, 1, ObjektTyp.Dreieck));
    ol.Objekte.Add(new Objekt(2.5f, 5.6f, 2, ObjektTyp.Viereck));
    ol.Objekte.Add(new Objekt(4.7f, 8.1f, 3, ObjektTyp.Quadrat));

    // Namen und Parameter des Listenelemente definieren
    ol.Objekte[0].sName = "Fläche 1";
    ol.Objekte[0].Params[0] = 1;
    ol.Objekte[0].Params[1] = 2;
    ol.Objekte[0].Params[2] = 3;

    ol.Objekte[1].sName = "Fläche 2";
    ol.Objekte[1].Params[0] = 4;
    ol.Objekte[1].Params[1] = 5;
    ol.Objekte[1].Params[2] = 6;

    ol.Objekte[2].sName = "Fläche 3";
    ol.Objekte[2].Params[0] = 7;
    ol.Objekte[2].Params[1] = 8;
    ol.Objekte[2].Params[2] = 9;

    // Stream öffnen
    FileStream fs = new FileStream("c:\\ObjektListe.xml", FileMode.Create);

    // Objekte als XML serialisieren
    XmlSerializer xs = new XmlSerializer(typeof(ObjektListe));
    xs.Serialize(fs, ol);

    // Stream schließen
    fs.Flush();
    fs.Close();
}

// Objekt laden und deserialisieren
private void btnLoad_Click(object sender, EventArgs e)
{
    // Stream öffnen 
    FileStream fs = new FileStream("c:\\ObjektListe.xml", FileMode.Open);

    // Objekt deserialisieren
    XmlSerializer xs = new XmlSerializer(typeof(ObjektListe));
    Object o = xs.Deserialize(fs);
    ObjektListe ol = o as ObjektListe;

    // wenn die Deserialisierung funktioniert hat  
    // Testdaten ausgeben (Print())
    if (ol != null)
    {
        for (int i = 0; i < ol.Objekte.Count; i++)
        {
            Objekt obj = ol.Objekte[i];

            if (obj != null)
            {
                obj.Print();
            }
        }
    }

    // Stream schließen
    fs.Close();
}
  • die gespeicherte Ausgabedatei ObjektListe.xml sieht wie folgt aus:
<?xml version="1.0"?>
<Objektliste xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Flächen</Name>
  <Objekte>
    <Objekt id="1">
      <Name>Fläche 1</Name>
      <b>3.4</b>
      <Typ>D</Typ>
      <ParameterListe>
        <Parameter>1</Parameter>
        <Parameter>2</Parameter>
        <Parameter>3</Parameter>
      </ParameterListe>
      <a>1.2</a>
    </Objekt>
    <Objekt id="2">
      <Name>Fläche 2</Name>
      <b>5.6</b>
      <Typ>Viereck</Typ>
      <ParameterListe>
        <Parameter>4</Parameter>
        <Parameter>5</Parameter>
        <Parameter>6</Parameter>
      </ParameterListe>
      <a>2.5</a>
    </Objekt>
    <Objekt id="3">
      <Name>Fläche 3</Name>
      <b>8.1</b>
      <Typ>Q</Typ>
      <ParameterListe>
        <Parameter>7</Parameter>
        <Parameter>8</Parameter>
        <Parameter>9</Parameter>
      </ParameterListe>
      <a>4.7</a>
    </Objekt>
  </Objekte>
</Objektliste>
  • nach dem Zurücklesen sollte Folgendes auf der Konsole ausgegeben werden:
Fläche 1[Dreieck]
ID: 1
Parameter 0: 1
Parameter 1: 2
Parameter 2: 3
1,2 x 3,4 = 4,08
Fläche 2[Viereck]
ID: 2
Parameter 0: 4
Parameter 1: 5
Parameter 2: 6
2,5 x 5,6 = 14
Fläche 3[Quadrat]
ID: 3
Parameter 0: 7
Parameter 1: 8
Parameter 2: 9
4,7 x 8,1 = 38,07
  • weiterführender Link: Link

Serialisierung – binär 

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

// Beispielobjekt, was geladen und gespeichert werden soll
// wichtig ist hier die Angabe von [Serializable]
[Serializable]
class Viereck
{
    private int _a;
    private int _b;
    private string _Name;

    public Viereck(int a, int b, string Name)
    {
        _a = a;
        _b = b;
        _Name = Name;
    }

    public void Print()
    {
        int A = _a * _b;

        Console.WriteLine("{3}: {0} x {1} = {2}", _a, _b, A, _Name);
    }
}

// Objekt serialisiert speichern
private void btnSave_Click(object sender, EventArgs e)
{
    // Objekt anlegen
    Viereck V = new Viereck(2, 4, "kleines Viereck");

    // Stream öffnen
    FileStream fsW = new FileStream("c:\\viereck.dat", FileMode.Create);

    // Objekt binär serialisieren
    BinaryFormatter bf = new BinaryFormatter();
    bf.Serialize(fsW, V);

    // Stream schließen
    fsW.Flush();
    fsW.Close();
}

// Objekt laden und deserialisieren
private void btnLoad_Click(object sender, EventArgs e)
{
    // Stream öffnen
    FileStream fsR = new FileStream("c:\\viereck.dat", FileMode.Open);

    // Objekt deserialisieren
    BinaryFormatter bf = new BinaryFormatter();
    Object o = bf.Deserialize(fsR);
    Viereck V_neu = o as Viereck;

    // wenn die Deserialisierung funktioniert hat
    // Testdaten ausgeben (Print())
    if (V_neu != null)
    {
        V_neu.Print();
    }

    // Stream schließen
    fsR.Close();
}

Dateiinfos auslesen 

using System.IO;

FileInfo fiFile = new FileInfo("c:\\Test1.jpg");

string sExt = fiFile.Extension;            // .jpg
string sFileName = fiFile.FullName;        // c:\\Test1.jpg
string sg = fiFile.DirectoryName;          // c:\\
long iSize = fiFile.Length;
DateTime dtCreation = fiFile.CreationTime; // Zeit

Zip-Archiv erstellen

  • alternative Verfahrensweise: Link
using System.IO;
using ICSharpCode.SharpZipLib.Zip; // http://www.icsharpcode.net/OpenSource/SharpZipLib/

static void ZipCompress(string sDir, string sZipFileName, string sComment)
{
    string[] sFiles = Directory.GetFiles(sDir);

    ZipOutputStream zipStream = new ZipOutputStream(File.Create(sZipFileName));

    // höchste Komprimierungsstufe
    zipStream.SetLevel(9);

    // Kommentar setzen
    zipStream.SetComment(sComment);

    for (int i = 0; i < sFiles.Length; i++)
    {
        FileStream fs = new FileStream(sFiles[i], FileMode.Open, FileAccess.Read);

        byte[] buffer = new byte[fs.Length];
        fs.Read(buffer, 0, buffer.Length);

        zipStream.PutNextEntry(new ZipEntry(sFiles[i]));
        zipStream.Write(buffer, 0, buffer.Length);
        
        fs.Close();
    }

    zipStream.Finish();
    zipStream.Close();
}

Verzeichnisse auflisten 

// Unterverzeichnisse von "c:\" auflisten
string[] saDirList = Directory.GetDirectories(@"c:\");

oder

// das selbe in einer anderen Schreibweise
string[] saDirList = Directory.GetDirectories(@"c:\", "*", SearchOption.TopDirectoryOnly);

oder

// alle Verzeichnisse von c:\ rekursiv -> kann sehr lange dauern :)
string[] saDirList = Directory.GetDirectories(@"c:\", "*", SearchOption.AllDirectories);

// Ausgabe
foreach (string sDir in saDirList)
{
    Console.WriteLine("{0}", sDir);
}