size of a *bool*

[Daniel Jin]

I read somewhere that a bool is 1 byte unless if it's in a array, then it will be 2 bytes. is that true? if so, any explaination to why that is?

[Jon Skeet [C# MVP]]

Daniel Jin <an*******@disc ussions.microso ft.com> wrote:

I read somewhere that a bool is 1 byte unless if it's in a array,
then it will be 2 bytes. is that true? if so, any explaination to why
that is?

No, I don't believe that's true. I'm 99.9% sure that it's a byte either
way. If it's boxed it'll be a lot more, obviously.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Mattias Sjögren]

Daniel,

unless if it's in a array, then it will be 2 bytes. is that true?

No, bool is always 1 byte.

Mattias

--
Mattias Sjögren [MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Marcin Grzębski]

Hi Daniel,

I read somewhere that a bool is 1 byte unless if it's in a array, then it will be 2 bytes. is that true? if so, any explaination to why that is?

Bool size is 4 Bytes.

check this:
System.Runtime. InteropServices .Marshal.SizeOf (typeof(Boolean ))

Regards

Marcin

[Mattias Sjögren]

Marcin,

Bool size is 4 Bytes.

check this:
System.Runtime .InteropService s.Marshal.SizeO f(typeof(Boolea n))

No, what you're getting here is the size of a bool when marshaled to a
native Win32 BOOL, which is indeed four bytes.

Try this instead

unsafe { Console.WriteLi ne( sizeof(bool) ); }

Mattias

--
Mattias Sjögren [MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Marcin Grzębski]

Hi Mattias,

Marcin,

Bool size is 4 Bytes.

check this:
System.Runtim e.InteropServic es.Marshal.Size Of(typeof(Boole an))

No, what you're getting here is the size of a bool when marshaled to a
native Win32 BOOL, which is indeed four bytes.

Try this instead

unsafe { Console.WriteLi ne( sizeof(bool) ); }

Mattias

I think You're right...

I tried this:

unsafe { Console.WriteLi ne( sizeof(Char) ); }
Console.WriteLi ne(System.Runti me.InteropServi ces.Marshal.Siz eOf(typeof(Char ))
);

Regards

Marcin

[Andreas Håkansson]

"Marcin GrzÄTbski" <mg*******@taxu ssi.no.com.spam .pl> skrev i meddelandet
news:c5******** **@nemesis.news .tpi.pl...

Hi Mattias,

Marcin,

Bool size is 4 Bytes.

check this:
System.Runtim e.InteropServic es.Marshal.Size Of(typeof(Boole an))

No, what you're getting here is the size of a bool when marshaled to a
native Win32 BOOL, which is indeed four bytes.

Try this instead

unsafe { Console.WriteLi ne( sizeof(bool) ); }

Mattias

I think You're right...

I would go as far as to claim he is right. The managed and unmanaged
world is completly different and the Marshal.SizeOf lives in the unmanaged
realm.
I tried this:

unsafe { Console.WriteLi ne( sizeof(Char) ); }
Console.WriteLi ne(System.Runti me.InteropServi ces.Marshal.Siz eOf(typeof(Char )
) );

Regards

Marcin

[William Stacey [MVP]]

Yeh. However is it not true that because of alignment, the smallest thing
you can allocate is a 4 byte int. So I "think", internally, it is an int.
Not sure, but thought I came across this once. Please correct if in error
here. Cheers!

--
William Stacey, MVP

"Mattias Sjögren" <ma************ ********@mvps.o rg> wrote in message
news:#U******** *****@tk2msftng p13.phx.gbl...

Marcin,

Bool size is 4 Bytes.

check this:
System.Runtime .InteropService s.Marshal.SizeO f(typeof(Boolea n))

No, what you're getting here is the size of a bool when marshaled to a
native Win32 BOOL, which is indeed four bytes.

Try this instead

unsafe { Console.WriteLi ne( sizeof(bool) ); }

Mattias

--
Mattias Sjögren [MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Marcin Grzêbski]

Hi Andreas,

"Marcin GrzÄTbski" <mg*******@taxu ssi.no.com.spam .pl> skrev i meddelandet
news:c5******** **@nemesis.news .tpi.pl...

Hi Mattias,

Marcin,

Bool size is 4 Bytes.

check this:
System.Runt ime.InteropServ ices.Marshal.Si zeOf(typeof(Boo lean))
No, what you're getting here is the size of a bool when marshaled to a
native Win32 BOOL, which is indeed four bytes.

Try this instead

unsafe { Console.WriteLi ne( sizeof(bool) ); }

Mattias

I think You're right...

I would go as far as to claim he is right. The managed and unmanaged
world is completly different and the Marshal.SizeOf lives in the unmanaged
realm.

hmmm...
Could you tell me if there is any *sizeof* method that works with
managed value types (e.g. System.Drawing. Color) ?

Marcin

[Andreas Hakansson]

Marcin,

"Marcin Grzêbski" <mg*******@taxu ssi.no.com.spam .pl> skrev i meddelandet
news:c5******** **@atlantis.new s.tpi.pl...

Hi Andreas,

"Marcin GrzÄTbski" <mg*******@taxu ssi.no.com.spam .pl> skrev i meddelandet news:c5******** **@nemesis.news .tpi.pl...

Hi Mattias,
Marcin,

>Bool size is 4 Bytes.
>
>check this:
>System.Runt ime.InteropServ ices.Marshal.Si zeOf(typeof(Boo lean))
No, what you're getting here is the size of a bool when marshaled to a
native Win32 BOOL, which is indeed four bytes.

Try this instead

unsafe { Console.WriteLi ne( sizeof(bool) ); }

Mattias

I think You're right...

I would go as far as to claim he is right. The managed and unmanaged
world is completly different and the Marshal.SizeOf lives in the unmanaged realm.

hmmm...
Could you tell me if there is any *sizeof* method that works with
managed value types (e.g. System.Drawing. Color) ?

The sizeof operator is used to retrieve the size of a valuetype.

//Andreas
Marcin