bool = 2byte

Zeus

Trotzdem ist das Bool 2 Byte groß in VB und in C# halt 1 Byte.

Nein Nullable muss man extra angeben wie Bool? oder Nullable<Bool>.

hustbaer

Zeus schrieb:

Trotzdem ist das Bool 2 Byte groß in VB und in C# halt 1 Byte.

Das hiesse dass Bool in C# und VB .NET auf unterschiedliche CLR/CLI Typen abgebildet würden. Halte ich erstmal bis auf weiteres für ein Gerücht (hab hier kein Visual Studio installiert, sonst würd ich es ausprobieren statt hier nur blöd mein Unglauben zu melden )

Zeus

hustbaer schrieb:

Zeus schrieb:

Trotzdem ist das Bool 2 Byte groß in VB und in C# halt 1 Byte.

Das hiesse dass Bool in C# und VB .NET auf unterschiedliche CLR/CLI Typen abgebildet würden. Halte ich erstmal bis auf weiteres für ein Gerücht (hab hier kein Visual Studio installiert, sonst würd ich es ausprobieren statt hier nur blöd mein Unglauben zu melden )

http://img84.imageshack.us/i/25494137.png/

Nö.

hustbaer

Schonmal auf die Idee gekommen dass Len() in VB nicht das gleiche ist wie sizeof() in C#?

Zeus

hustbaer schrieb:

Schonmal auf die Idee gekommen dass Len() in VB nicht das gleiche ist wie sizeof() in C#?

Hast du ne andere Funktion im Sinn?

Mit andere Ganzahl-Datentypen stimmt die norminale Größe mit den von sizeof() in c# überein.

Außerdem darfst du mich gerne belehren weiter belehren:

Returns an integer containing either the number of characters in a string or the nominal number of bytes required to store a variable.

The sizeof operator is used to obtain the size in bytes for a value type.

Bei Mono kommt für bool auch 2 raus (Zeile 10), aber das bedeutet ja nicht, dass der Typ tatsächlich 2 Bytes groß ist, oder?

http://anonsvn.mono-project.com/viewvc/trunk/mono-basic/vbruntime/Microsoft.VisualBasic/Microsoft.VisualBasic/Strings.vb

Public Shared Function Len(ByVal Expression As Boolean) As Integer
    Return GetSize(Expression)
End Function

Private Shared Function GetSize(ByVal Expression As Object) As Integer
    If Expression Is Nothing Then
        Return 0
    End If

    Dim Tcode As TypeCode = Type.GetTypeCode(Expression.GetType())

    Select Case Tcode
        Case TypeCode.Boolean
            Return 2
        Case TypeCode.Byte
            Return 1
        Case TypeCode.Char
            Return 2
        Case TypeCode.DateTime
            Return 8
        Case TypeCode.DBNull
            Throw New InvalidCastException
        Case TypeCode.Decimal
            Return 8
        Case TypeCode.Double
            Return 8
        Case TypeCode.Empty
            Return 0
        Case TypeCode.Int16
            Return 2
        Case TypeCode.Int32
            Return 4
        Case TypeCode.Int64
            Return 8
        Case TypeCode.Object
            Throw New InvalidCastException
        Case TypeCode.SByte
            Return 1
        Case TypeCode.Single
            Return 4
        Case TypeCode.String
            Return Conversions.ToString(Expression).Length
        Case TypeCode.UInt16
            Return 2
        Case TypeCode.UInt32
            Return 4
        Case TypeCode.UInt64
            Return 8
    End Select

End Function

freaky

Ist doch egal was bei VB rauskommt, Zeus hat gezeigt das bei C# Boolean = 1 Byte groß ist.

hustbaer

@Zeus:
Wenn du die Doku zu "Len()" genau liest, wirst du feststellen, dass da irgendwas von schreiben in irgendwelche Files steht. Also Serialisierung. Das hat wenig damit zu tun wie gross der Typ im Speicher ist.

Auf jeden Fall muss ein Bool in C# und VB gleich gross sein, denn es ist schliesslich der gleiche CLR/CLI Typ.
Interop zwischen VB und C# wäre sonst nicht wirklich möglich.

GPC

hustbaer schrieb:

@Zeus:
Wenn du die Doku zu "Len()" genau liest, wirst du feststellen, dass da irgendwas von schreiben in irgendwelche Files steht. Also Serialisierung. Das hat wenig damit zu tun wie gross der Typ im Speicher ist.

Auf jeden Fall muss ein Bool in C# und VB gleich gross sein, denn es ist schliesslich der gleiche CLR/CLI Typ.
Interop zwischen VB und C# wäre sonst nicht wirklich möglich.

So ist es. Und wenn man die richtigen Methoden zur Größenbestimmung benutzt, dann zeigt sich das auch

Anmerkung: Marshal.SizeOf liefert die unmanaged Größe in Bytes.

C#-Code:

Console.WriteLine(System.Runtime.InteropServices.Marshal.SizeOf(typeof(bool)));

Ergebnis: 4

VB-Code:

Sub Main
	Dim b as boolean
	Console.WriteLine(System.Runtime.InteropServices.Marshal.SizeOf(b))
End Sub

Ergebnis: 4

4 bytes für etwas, dass man auch in 1 bit ablegen kann? Der Grund dafür liegt am memory alignment und darin, dass der GC leichter 4 bytes durch die Gegend schieben kann als 1 bit.
Wenn man relativ viele bools hat, kann man die in einem BitVector32 ablegen.

Als managed type hat bool in C# aber tatsächlich nur 1 byte (zeigt sich auch an sizeof(bool)). Beim Marshalling wird ein bool dann auf 4 byte erweitert.

Zeus

So ein Unsinn

GPC

Zeus schrieb:

So ein Unsinn

Du darfst deine Argumentation natürlich gerne auch untermauern
Z.B. wieso denn die bool-typen von C# und VB.NET intern nicht auf den gleichen CLR-Datentyp mappen sollten

Zeus

GPC schrieb:

Zeus schrieb:

So ein Unsinn

Du darfst deine Argumentation natürlich gerne auch untermauern
Z.B. wieso denn die bool-typen von C# und VB.NET intern nicht auf den gleichen CLR-Datentyp mappen sollten

Damit hab ich die Microsoft Entwickler gewürdigt

GPC

Zeus schrieb:

GPC schrieb:

Zeus schrieb:

So ein Unsinn

Du darfst deine Argumentation natürlich gerne auch untermauern
Z.B. wieso denn die bool-typen von C# und VB.NET intern nicht auf den gleichen CLR-Datentyp mappen sollten

Damit hab ich die Microsoft Entwickler gewürdigt

War mir nicht ersichtlich

GPC schrieb:

4 bytes für etwas, dass man auch in 1 bit ablegen kann? Der Grund dafür liegt am memory alignment und darin, dass der GC leichter 4 bytes durch die Gegend schieben kann als 1 bit.
Wenn man relativ viele bools hat, kann man die in einem BitVector32 ablegen.

Als managed type hat bool in C# aber tatsächlich nur 1 byte (zeigt sich auch an sizeof(bool)). Beim Marshalling wird ein bool dann auf 4 byte erweitert.

Bedeutet das jetzt, dass CLR-intern generell immer 4 byte ver(sch)wendet werden, oder nur sobald ein interop im Spiel ist?

hustbaer

GPC schrieb:

hustbaer schrieb:

@Zeus:
Wenn du die Doku zu "Len()" genau liest, wirst du feststellen, dass da irgendwas von schreiben in irgendwelche Files steht. Also Serialisierung. Das hat wenig damit zu tun wie gross der Typ im Speicher ist.

Auf jeden Fall muss ein Bool in C# und VB gleich gross sein, denn es ist schliesslich der gleiche CLR/CLI Typ.
Interop zwischen VB und C# wäre sonst nicht wirklich möglich.

So ist es. Und wenn man die richtigen Methoden zur Größenbestimmung benutzt, dann zeigt sich das auch

Anmerkung: Marshal.SizeOf liefert die unmanaged Größe in Bytes.

C#-Code:
Console.WriteLine(System.Runtime.InteropServices.Marshal.SizeOf(typeof(bool)));
Ergebnis: 4

VB-Code:
Sub Main
	Dim b as boolean
	Console.WriteLine(System.Runtime.InteropServices.Marshal.SizeOf(b))
End Sub
Ergebnis: 4

4 bytes für etwas, dass man auch in 1 bit ablegen kann? Der Grund dafür liegt am memory alignment und darin, dass der GC leichter 4 bytes durch die Gegend schieben kann als 1 bit.
Wenn man relativ viele bools hat, kann man die in einem BitVector32 ablegen.

Als managed type hat bool in C# aber tatsächlich nur 1 byte (zeigt sich auch an sizeof(bool)). Beim Marshalling wird ein bool dann auf 4 byte erweitert.

Marshal.SizeOf ist was das angeht auch relativ uninteressant, da es dabei ja um Interop managed/unmanaged geht. Dass für unmanaged Code 4 Byte verwendet werden wundert mich auch nicht sehr, da die ganze WinAPI mit 4 Byte grossen Bools arbeitet.

----

Wenn wir mal als gegeben annehmen dass ein Bool in C# 1 Byte gross ist, dann muss ein Bool in VB auch 1 Byte gross sein, da zwischen C# und VB kein Marshaling stattfindet.

Dravere

Wollen wir der Sache mal auf den Grund gehen.

Wieso gibt Marshal.SizeOf 4 zurück?
Hustbear hat das schon richtig erkannt. Es geht dabei um das Default-Marshaling Verhalten bei System.Boolean und dieses richtet sich nach der WinAPI. Man kann daher einem Parameter auch MarshalAs Attribute geben, damit zum Beispiel wirklich nur 1 Byte draus gemacht wird. Alles weitere hier nachzulesen:
http://msdn.microsoft.com/en-us/library/ac7ay120.aspx
http://msdn.microsoft.com/en-us/library/t2t3725f.aspx
Welche Grösse hat System.Boolean in C#?
Kann man in folgendem Link nachlesen. Da steht übrigens auch nochmals eine Antwort zu Marshal.SizeOf drin (unterhalb der Tabelle).
http://msdn.microsoft.com/en-us/library/eahchzkf.aspx
Wieso gibt Len in VB 2 zurück?
Len gibt die Länge zurück, welche beim Speichern verwendet wird, also zum Beispiel in ein File. Visual Basic .Net soll rückwärtskompatibel sein und früher wurde in VB für Bool ein 16 Bit Integer verwendet. Daher nehme ich an, speichert man aus Rückwärtskompatibilität immer noch 16 Bit Integers.
http://msdn.microsoft.com/en-us/library/dxsw58z6.aspx

Hier ein Hinweis, dass der Boolean Type in Visual Basic verschiedene Grössen haben kann, je nach Platform (wahrscheinlich wird da mit .Net oder ohne gemeint).
http://msdn.microsoft.com/en-us/library/47zceaw7.aspx

Hier noch ein Link aus alten Zeiten, welcher ein paar Interessante Informationen hat:
http://msdn.microsoft.com/en-us/library/wts33hb3(v=VS.71).aspx

In VB kommt es meiner Meinung nach also ganz darauf an, welcher Datentyp jetzt wirklich verwendet wird. Ist es System.Boolean aus .Net, dann ist die Grösse 1 Byte, wenn es den Boolean Type aus VB ist, dann sind es 2 Bytes.

Grüssli

GPC

Buccino schrieb:

GPC schrieb:

4 bytes für etwas, dass man auch in 1 bit ablegen kann? Der Grund dafür liegt am memory alignment und darin, dass der GC leichter 4 bytes durch die Gegend schieben kann als 1 bit.
Wenn man relativ viele bools hat, kann man die in einem BitVector32 ablegen.

Als managed type hat bool in C# aber tatsächlich nur 1 byte (zeigt sich auch an sizeof(bool)). Beim Marshalling wird ein bool dann auf 4 byte erweitert.

Bedeutet das jetzt, dass CLR-intern generell immer 4 byte ver(sch)wendet werden, oder nur sobald ein interop im Spiel ist?

Letzteres. CLR-intern ist es idR 1 byte, aber es können auch auch zwei bytes sein, z.B. wenn man Nullable<bool> nutzt.