Deserialize aus Memorystream wirft Fehler wegen nicht erreichtem Datenstromende

Hey,

ich habe ein Problem bei meinem Code.

Ich habe ein DataSet über TCP von der Server Anwendung Serialisiert und dann zum Client übertragen. Nun bekomme ich den folgenden Fehler, wenn ich es Deserialisieren möchte.

Fehlermeldung:
Fehler: "Das Datenstromende wurde erreicht, bevor die Verarbeitung abgeschlossen wurde."
"SerializationException wurde nicht behandelt"

Code:

static public object DeserializeData(string value)
        {
            MemoryStream ms = new MemoryStream(Convert.FromBase64String(value));
            BinaryFormatter bf1 = new BinaryFormatter();
            ms.Position = 0;
            
            
            return (DataSet)bf1.Deserialize(ms);  // <--- Zeile in dem der Fehler auftritt
        }

while ((k = stream.Read(data, 0, data.Length)) > 0)
            {
                string wert = System.Text.Encoding.ASCII.GetString(data, 0, k);
                DataSet ds = (DataSet)DeserializeData(wert);//<--- Aufruf der Methode

Wo liegt da ein Fehler vor?

Vielen Dank für eure Hilfe!

Zeig mal den Code der Gegenseite. Kommt mir bisschen spanisch vor, was du da machst 😃

LaTino

Das passiert wenn du das Gesamt-Paket in Teilen geliefert bekommst.

Folglich musst du erst das Gesamt-Paket empfangen und dann mit der Deserialisierung beginnen.

 public string SerializeData(Object o)
        {
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf1 = new BinaryFormatter();
            bf1.Serialize(ms, o);
            return Convert.ToBase64String(ms.ToArray());
        }

Spanisch kann ich eigentlich nicht 😃

Debuggen kannst du?

Dann schau dir an wieviele Bytes du verschickst und wieviele Bytes du zum Deserialisieren bekommst.

Folgender Code funktioniert:

    class Program {
        static void Main(string[] args) {
            MyClass obj = new MyClass {
                MyProperty = 1,
                MyProperty2 = "zwei",
                MyProperty3 = Math.PI
            };

            string data = SerializeData(obj);

            MyClass obj2 = DeserializeData<MyClass>(data);

            DataSet dataSet = new DataSet("DataSet1");
            DataTable table = new DataTable("Table1");
            DataColumn col1 = new DataColumn(nameof(obj.MyProperty), obj.MyProperty.GetType());
            DataColumn col2 = new DataColumn(nameof(obj.MyProperty2), obj.MyProperty2.GetType());
            DataColumn col3 = new DataColumn(nameof(obj.MyProperty3), obj.MyProperty3.GetType());

            table.Columns.Add(col1);
            table.Columns.Add(col2);
            table.Columns.Add(col3);

            DataRow row = table.NewRow();
            row[nameof(obj.MyProperty)] = obj.MyProperty;
            row[nameof(obj.MyProperty2)] = obj.MyProperty2;
            row[nameof(obj.MyProperty3)] = obj.MyProperty3;

            table.Rows.Add(row);
            dataSet.Tables.Add(table);

            string data2 = SerializeData(dataSet);

            DataSet dataSet2 = DeserializeData<DataSet>(data2);
        }

        public static string SerializeData(Object o) {
            MemoryStream ms = new MemoryStream();
            BinaryFormatter bf1 = new BinaryFormatter();
            bf1.Serialize(ms, o);
            return Convert.ToBase64String(ms.ToArray());
        }

        public static T DeserializeData<T>(string value) {
            MemoryStream ms = new MemoryStream(Convert.FromBase64String(value));
            BinaryFormatter bf1 = new BinaryFormatter();
            ms.Position = 0;
            return (T)bf1.Deserialize(ms);
        }
    }

    [Serializable]
    class MyClass {
        public int MyProperty { get; set; }

        public string MyProperty2 { get; set; }

        public double MyProperty3 { get; set; }
    }

An dem Teil sollte es also schon mal nicht liegen, denke ich.
Bei einem Fehler hätte ich eher auf die Stelle mit Convert.FromBase64String(value) getippt, da dann noch nicht genug Daten aus dem Stream gelesen worden wären.

Bei einem Fehler hätte ich eher auf die Stelle mit Convert.FromBase64String(value) getippt, da dann noch nicht genug Daten aus dem Stream gelesen worden wären.

Genau die Stelle, die mir seltsam vorkam. Das[EDIT]Base64-Codierung[/EDIT] sollte zum Versenden eigentlich nicht nötig sein.

LaTino

Convert.FromBase64String(value)
Das sollte zum Versenden eigentlich nicht nötig sein.

Wird zum Versenden auch gar nicht genommen 😉

Danke für alle Antworten.

Habe das Problem jetzt gelöst.

Ich habe das Paket in ganzem Übertragen lassen und schwupp hat es funktioniert.

Dankeschön 😃