C Sharp Structure to Byte Array

[Gateway_man]

Hallo,

ich versuche momentan eine Structure/Class zu einem Byte Array zu konvertieren.

Der hintergrund:

Ich wollte mir eine schnelle Lösung suchen um den Inhalt sowie die Struktur einer Klasse in ein File wegzuschreiben. Wenn ich die Daten mit der Struktur wieder benötige wollte ich dieses einfach wieder einlesen. Damit wollte ich mir schreibarbeit und eventuelle parserarbeiten sparen.

Das ganze sieht wie folgt aus (Testklasse):

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.InteropServices;


namespace pptdispatcher

{

    class TestCase

    {

        public List<string> names = new List<string>();

        public int count;

        public static byte[] StructureToByteArray(TestCase obj)

        {

            int Length = Marshal.SizeOf(obj);   //unten beschriebener Fehler wird hier geworfen.

            byte[] bytearray = new byte[Length];

            IntPtr ptr = Marshal.AllocHGlobal(Length);

            Marshal.StructureToPtr(obj, ptr, false);

            Marshal.Copy(ptr, bytearray, 0, Length);

            Marshal.FreeHGlobal(ptr);

            return bytearray;

        }


        public static void ByteArrayToStructure(byte[] bytearray, ref TestCase obj)

        {

            int Length = Marshal.SizeOf(obj);

            IntPtr ptr = Marshal.AllocHGlobal(Length);

            Marshal.Copy(bytearray, 0, ptr, Length);

            obj = (TestCase)Marshal.PtrToStructure(ptr, obj.GetType());

            Marshal.FreeHGlobal(ptr);

        }

    }

}

Beim Aufruf der wie folgt aussieht:

        TestCase case12 = new TestCase();

            case12.count = 10;

            case12.names.Add("test1");

            case12.names.Add("test2");

            case12.names.Add("test3");

            byte[] content = TestCase.StructureToByteArray(case12);

            System.IO.FileStream fs = new System.IO.FileStream("C:\test.dat", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite);

            fs.Write(content, 0, content.Length);

            fs.Flush();

            fs.Close();

Bekomme ich folgenden Fehler:

Es kann keine sinnvolle Größe oder sinnvoller Offset berechnet werden, da der Typ "pptdispatcher.TestCase" nicht als nicht verwaltete Struktur gemarshallt werden kann.

Wie kann ich also eine Klasse im .NET als unmanaged deklarieren?

Wenn jemand einen anderen Lösungsweg kennt, wäre ich natürlich auch nicht abgeneigt diesen zu nutzen.

lg

Gateway

[Guybrush Threepwood]

Üblicherweise nimmt man dazu den BinaryFormatter

[realgun]

Warum serialisierst Du Deine Objektstruktur? Zum Beispiel mit dem BinaryFormatter?

edit: da war der Pirat schneller

[Gateway_man]

Warum einfach wenns auch schwer geht :upps.

Vielen dank für die schnelle Antwort .

lg

gateway

[Gateway_man]

Hi leute,

ich hab jetzt doch noch ein Problem mit der Serialisierung bei folgender Klasse:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Drawing;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO;


namespace pptdispatcher.ppt

{

    [Serializable]

    class ObjectDefine

    {

        private Util.Size size = new pptdispatcher.Util.Size(0,0);

        private Point location = new Point(0,0);

        private Img image;

        private TextFrame textframe;

        private Table table;

        //private Diagram diagram;

        private Util.Margin margin = null ;

        internal Util.Size Size {

            get { return size; }

            set { size = value; }

        }

        internal Util.Margin Margin{

            get { return margin; }

            set { margin = value; }

        }

        internal Img Image {

            get { return image; }

            set { image = value; }

        }

        internal TextFrame TxTFrame {

            get { return textframe; }

            set { textframe = value; }

        }

        internal Table TableObject

        {

            get { return table; }

            set { table = value; }

        }

         internal System.Drawing.Point Location {

            get { return location; }

            set { location = value; }

        }

        [Serializable]

        public class Img {

            private string base64content;

            private Image image;

            private byte[] content = { };

            internal string Base64Content {

                get { return base64content; }

                set { base64content = value; }

            }

            internal Image Image {

                get { return image; }

                set { image = value; }

            }

            internal byte[] Content {

                get { return content; }

                set { content = value; }

            }

        }

        //[Serializable]

        //public class Diagram {


        //}

        [Serializable]

        public class Table

        {

            private TextFrame[,] content;

            [Serializable]

            public struct Column

            {

                public float index;

                public float width;

            };

            [Serializable]

            public struct Row

            {

                public float index;

                public float height;


            };

            public List<Column> Columns = new List<Column>();

            public List<Row> Rows = new List<Row>();

            public TextFrame[,] Content

            {

                get { return content; }

                set { content = value; }

            }

            public TextFrame GetCell(int Row, int Column)

            {

                return content[Row, Column];

            }

            public void ModifyCell(int Row, int Column, TextFrame value)

            {

                content[Row, Column] = value;

            }

            public Table(TextFrame[,] matrixcontent, List<Column> columns, List<Row> rows)

            {

                if (matrixcontent == null || matrixcontent.GetLength(0) != rows.Count || matrixcontent.GetLength(1) != columns.Count)

                {

                    throw new Exception("InvalidArgumentException");

                }

                else {

                    content = matrixcontent;

                    this.Columns = columns;

                    this.Rows = rows;

                } 

            }


        }

        [Serializable]

        public class TextFrame {

            [Serializable]

            public class Margin {

                public float left = 0;

                public float right = 0;

                public float top = 0;

                public float bottom = 0;

            }

            [Serializable]

            public class Font

            {

                public bool underlined = false;

                public bool italic = false;

                public bool bold = false;

                public bool embedded = false;

                public int size = 12;

                public string fontfamilie = "Arial";

                public bool shadow = false;

                public bool emboss = false;

            }

            public Margin margin = new Margin();

            public int Orientation;

            public string Value;

            public bool WordWrap;

            public int VerticalAnchor;

            public int HorizontalAnchor;

            public int IntendLevel = 0;

            public Font font = new Font();

        }


        public static byte[] Serialize(ObjectDefine obj)

        {

            if (obj == null)

                return null;

            byte[] result;

            MemoryStream ms = new MemoryStream();

            BinaryFormatter formatter = new BinaryFormatter();

                formatter.Serialize(ms, obj);

                result = ms.GetBuffer();

            ms.Flush();

            ms.Close();

            ms.Dispose();

            formatter = null;

            return result;

        }

        public static ObjectDefine Deserialize(byte[] Struct)

        {

            if (Struct == null)

                return null;

            BinaryFormatter formatter = new BinaryFormatter();

            MemoryStream ms = new MemoryStream(Struct, false);

            return (ObjectDefine)formatter.Deserialize(ms);

        }


    }

}

Kann es sein das es limits bei der serialisierung gibt? Sprich keine geschachtelten Klassen?

Es kommt zwar kein Laufzeitfehler, jedoch wenn ich ein objekt vom typ objectdefine definierte und diesem ein table objekt hinzufüge, dieses dann wiederum serialisiere und in die db wegschreibe und es zu einem späteren Zeitpunkt wieder auslese sag der Debugger das das Object Table null ist.

Ganz seltsam.

lg

Gateway

PS:

Hat sich erledigt hatte die initialisierung vergessen xD.

Bearbeitet 19. Mai 2011 von Gateway_man
obsolet