✔ abgeleitete Klasse serialisieren

[Speedkill]

Hallo Leute,
ich hoffe ihr könnt mir helfen.

Ich habe eine von Hashtable abgeleitete Klasse ArpTable welche ich gerne serialisieren möchte. ArpTable überschreibt nur die Add-Methode und hat sonst keine zusätzlichen Attribute. Wenn ich das Ding aber serialisieren möchte bekomme ich folgenden Fehler:

Der für die Deserialisierung eines Objekts mit dem Typ TopoCrawler.ArpTable erforderliche Konstruktor wurde nicht gefunden.

Ich hoffe Ihr könnt mir auf die Sprünge helfen.

Grüße
Speedy

[Serializable]
    public class ArpTable : Hashtable {

        public ArpTable() : base() {
        }

        /// <summary>
        /// Eine Liste aller eingetragener IPs.
        /// </summary>
        public ArrayList Ips {
            get { return new ArrayList(this.Keys); }
        }

        /// <summary>
        /// Eine Liste aller eingetragener MACs.
        /// </summary>
        public ArrayList Macs {
            get { 
                ArrayList tmpList = new ArrayList();
                foreach (string mac in this.Values) {
                    tmpList.Add(mac);
                }
                return tmpList;
            }
        }

        public string getKey(string wert) {
            if (this.ContainsValue(wert)) {
                foreach (string key in this.Keys) {
                    if ((string) this[key] == wert) return key;
                }
            }
            return string.Empty;
        }

        /// <summary>
        /// Fügt der Auflistung den Wert 'value' unter dem Schlüssel 'key' hinzu
        /// </summary>
        /// <param name="key">Der Schlüssel</param>
        /// <param name="value">Der Wert</param>
        public override void Add(object key, object wert) {
            this.Add (key, wert, false);
        }

        /// <summary>
        /// Fügt der Auflistung den Wert 'value' unter dem Schlüssel 'key' hinzu
        /// </summary>
        /// <param name="key">Der Schlüssel</param>
        /// <param name="value">Der Wert</param>
        /// <param name="overide">Gibt an ob ein vorhandener Wert überschrieben werden soll oder nicht.</param>
        public void Add(object key, object wert, bool overide) {
            if (overide) {
                if (this.ContainsKey(key)) {
                    // wenn Schlüssel und Wert schon vorhanden
                    if (this.ContainsValue(wert)) {
                        this.Remove(key);
                        this.Remove(getKey((string)wert));
                        base.Add(key, wert);
                    } else if (this[key] != null){
                        this.Remove(key);
                        base.Add(key, wert);
                    } else {
                        this[key] = wert;
                    }
                } else if(this.ContainsValue(wert)) {
                    this.Remove(getKey((string)wert));
                    base.Add(key, wert);
                } else {
                    base.Add(key, wert);
                }
            } else {
                if (!this.ContainsKey(key)) {
                    // wenn Schlüssel und Wert nicht vorhanden
                    if (!this.ContainsValue(wert)) {
                        base.Add(key, wert);
                    }
                }
            }
        }

    }

 

[Speedkill]

Natürlich tritt der Fehler beim deserialisieren auf und nicht beim serialisieren *g*

 

[Speedkill]

OK ...

hat sich erledigt, ich habe jetzt einfach die Klasse umgeschrieben so daß sie nicht mehr von Hashtable erbt sondern nur noch ein Hashtable Attribut hat.

Zum Glück brauche ich das nur einmal und musste nicht so viel Code ändern, aber in einem größeren Projekt hätte das echt schief gehen können.

Falls jemand doch noch ne Idee hat warum das nicht ging bitte melden, ich verzweifle bald da mir das einfach nicht in den Kopf will.

Danke und Grüße
Speedkill

using System;
using System.Collections;

namespace TopoCrawler
{
    /// <summary>
    /// Zusammenfassung für ArpTable.
    /// </summary>
    [Serializable]
    public class ArpTable {

        Hashtable arpTable = new Hashtable();

        public Hashtable ArpTbl {
            get { return arpTable; }
        }

        /// <summary>
        /// Eine Liste aller eingetragener IPs.
        /// </summary>
        public ArrayList Ips {
            get { return new ArrayList(arpTable.Keys); }
        }

        /// <summary>
        /// Eine Liste aller eingetragener MACs.
        /// </summary>
        public ArrayList Macs {
            get { 
                ArrayList tmpList = new ArrayList();
                foreach (string mac in arpTable.Values) {
                    tmpList.Add(mac);
                }
                return tmpList;
            }
        }

        public string getKey(string wert) {
            if (arpTable.ContainsValue(wert)) {
                foreach (string key in arpTable.Keys) {
                    if ((string) arpTable[key] == wert) return key;
                }
            }
            return string.Empty;
        }

        /// <summary>
        /// Fügt der Auflistung den Wert 'value' unter dem Schlüssel 'key' hinzu
        /// </summary>
        /// <param name="key">Der Schlüssel</param>
        /// <param name="value">Der Wert</param>
        public void Add(object key, object wert) {
            this.Add (key, wert, false);
        }

        /// <summary>
        /// Fügt der Auflistung den Wert 'value' unter dem Schlüssel 'key' hinzu
        /// </summary>
        /// <param name="key">Der Schlüssel</param>
        /// <param name="value">Der Wert</param>
        /// <param name="overide">Gibt an ob ein vorhandener Wert überschrieben werden soll oder nicht.</param>
        public void Add(object key, object wert, bool overide) {
            if (overide) {
                if (arpTable.ContainsKey(key)) {
                    // wenn Schlüssel und Wert schon vorhanden
                    if (arpTable.ContainsValue(wert)) {
                        arpTable.Remove(key);
                        arpTable.Remove(getKey((string)wert));
                        arpTable.Add(key, wert);
                    } else if (arpTable[key] != null){
                        arpTable.Remove(key);
                        arpTable.Add(key, wert);
                    } else {
                        arpTable[key] = wert;
                    }
                } else if(arpTable.ContainsValue(wert)) {
                    arpTable.Remove(getKey((string)wert));
                    arpTable.Add(key, wert);
                } else {
                    arpTable.Add(key, wert);
                }
            } else {
                if (!arpTable.ContainsKey(key)) {
                    // wenn Schlüssel und Wert nicht vorhanden
                    if (!arpTable.ContainsValue(wert)) {
                        arpTable.Add(key, wert);
                    }
                }
            }
        }
    }
}