Object size

sizeof?

Marshal.SizeOf() måske ?

sizeof findes ikke på "obejct".

Jeg skal bruge det på alle objecter.

arne_v:

prøver lige..

sizeof kan kun bruges i unsafe kode i C#. Alternativt findes:
System.Runtime.InteropServices.Marshal.SizeOf

Marshal.SizeOf()  kaster denne exception:
"Type myObject can not be marshaled as an unmanaged structure; no meaningful size or offset can be computed."

myObject er Managed C# kode

Er klassen serializable ?

ja den er serializable

Mystisk.

Hvis en klasse er serializable burde Marshal.SizeOf også virke.

Kan du komme med et eksempel på en klasse som giver problemet ?

Arne v:

Fejlen kommer f.eks. på denne klasse:

using System;
using System.Runtime.InteropServices;

namespace TestCode
{
    [Serializable]
    public class Class1
    {
        private string str = "";
        public Class1()
        {
            //
            // TODO: Add constructor logic here
            //
        }
    }
}



------
Class1 cl = new Class1();
int i = System.Runtime.InteropServices.Marshal.SizeOf(cl);

denne fejler også:
int i = System.Runtime.InteropServices.Marshal.SizeOf(cl.GetType());



men denne virker:
int i = System.Runtime.InteropServices.Marshal.SizeOf(Type.GetType("System.Byte"));

Arne:

Dette virker, men jeg ved ikke om det er korrekt resultat.
"Length" er jo længden i bytes på streamen, og ikke på mit object.

Nogle ideer?

Stream myStream  = new MemoryStream();
            if (myStream != null)
            {
                IFormatter formatter = new BinaryFormatter();               
                formatter.Serialize(myStream, cl);
                Console.Write("size: " + myStream.Length);
                myStream.Close();               
            }

Jeg sidder og brygger på noget.

Det her compiler og kører, men er nok ret langt fra hvad du søger:

using System;
using System.Runtime.InteropServices;

class MainClass
{
    public static void Main(string[] args)
    {
        Foobar1 o1 = new Foobar1();
        o1.Num = 123;
        Console.WriteLine(Marshal.SizeOf(o1));
        Foobar2 o2 = new Foobar2();
        o2.Str = "ABC123";
        Console.WriteLine(Marshal.SizeOf(o2));
    }
}

[StructLayout( LayoutKind.Sequential )]
public class Foobar1
{
    private int num;
    public Foobar1()
    {
        num = 0;
    }
    public int Num
    {
        get
        {
            return num;
        }
        set
        {
            num = value;
        }
    }
}

[StructLayout( LayoutKind.Sequential, CharSet=CharSet.Ansi )]
public class Foobar2
{
    [MarshalAs( UnmanagedType.ByValTStr, SizeConst=32 )]
    private string str;
    public Foobar2()
    {
        str = "";
    }
    public string Str
    {
        get
        {
            return str;
        }
        set
        {
            str = value;
        }
    }
}

Din formatter ser umiddelbart mere tiltalende ud.

ja måske.

Men Stream'en fylder jo også noget.

    byte b = new byte();
            Console.WriteLine("Size: " +    System.Runtime.InteropServices.Marshal.SizeOf(b.GetType()));
           
           
            Stream myStream  = new MemoryStream();
            if (myStream != null)
            {
                IFormatter formatter = new BinaryFormatter();               
                formatter.Serialize(myStream, b);
                Console.WriteLine("size: " + myStream.Length);
                myStream.Close();               
            }


Result:

Size: 1
size: 50

Det er fordi de måler to forskellige ting.

binary formatter serializer skriver objektet i dets managed form
d.v.s. at beskrivelsen inkluderer klassens navn etc..

marshal sizeof beregner størrelsen i unmanaged form d.v.s.
størrelsen af de rå data.

kan jeg vide præcist hvor meget selve "Streamen" fylder?
Så jeg kan trække det fra..

Det er ikke selve streamen men overhead som forklarer at her har vi
en System.Byte af en bestemt version.

Jeg tror ikke at man kan estimere det overhead.

ok.

smid lige et svar

OK

takker.

og lukker.