System.BitConverter F# snippets (dotnet#7530)

* System.BitConverter F# snippets * Edit bitstodbl.fs

Author: albert-du

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.Class/FS/bitconv.fs

@@ -0,0 +1,48 @@
+module bitconv
+
+//<Snippet1>
+open System
+
+let print: obj -> obj -> unit = printfn "%25O%30O"
+
+let aDoubl = 0.1111111111111111111
+let aSingl = 0.1111111111111111111f
+let aLong = 1111111111111111111L
+let anInt = 1111111111
+let aShort = 11111s
+let aChar = '*'
+let aBool = true
+
+printfn "This example of methods of the BitConverter class\ngenerates the following output.\n"
+print "argument" "byte array"
+print "--------" "----------"
+
+// Convert values to Byte arrays and display them.
+print aDoubl (BitConverter.ToString(BitConverter.GetBytes aDoubl))
+
+print aSingl (BitConverter.ToString(BitConverter.GetBytes aSingl))
+
+print aLong (BitConverter.ToString(BitConverter.GetBytes aLong))
+
+print anInt (BitConverter.ToString(BitConverter.GetBytes anInt))
+
+print aShort (BitConverter.ToString(BitConverter.GetBytes aShort))
+
+print aChar (BitConverter.ToString(BitConverter.GetBytes aChar))
+
+print aBool (BitConverter.ToString(BitConverter.GetBytes aBool))
+
+
+// This example of methods of the BitConverter class
+// generates the following output.
+//
+// argument byte array
+// -------- ----------
+// 0.111111111111111 1C-C7-71-1C-C7-71-BC-3F
+// 0.1111111 39-8E-E3-3D
+// 1111111111111111111 C7-71-C4-2B-AB-75-6B-0F
+// 1111111111 C7-35-3A-42
+// 11111 67-2B
+// * 2A-00
+// True 01
+//</Snippet1>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.Class/FS/example1.fs

@@ -0,0 +1,21 @@
+module example1
+
+// <Snippet3>
+open System
+
+let value = -16
+let bytes = BitConverter.GetBytes value
+
+// Convert bytes back to int.
+let intValue = BitConverter.ToInt32(bytes, 0)
+printfn $"""{value} = {intValue}: {if value.Equals intValue then "Round-trips" else "Does not round-trip"}"""
+
+// Convert bytes to UInt32.
+let uintValue = BitConverter.ToUInt32(bytes, 0)
+printfn $"""{value} = {uintValue}: {if value.Equals uintValue then "Round-trips" else "Does not round-trip"}"""
+
+
+// The example displays the following output:
+// -16 = -16: Round-trips
+// -16 = 4294967280: Does not round-trip
+// </Snippet3>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.Class/FS/fs.fsproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>net6.0</TargetFramework>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="example1.fs" />
+ <Compile Include="networkorder1.fs" />
+ <Compile Include="bitconv.fs" />
+ <Compile Include="littleend.fs" />
+ </ItemGroup>
+</Project>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.Class/FS/littleend.fs

@@ -0,0 +1,11 @@
+//<Snippet2>
+open System
+
+printfn $"This example of the BitConverter.IsLittleEndian field generates \nthe following output when run on x86-class computers.\n"
+printfn $"IsLittleEndian: {BitConverter.IsLittleEndian}"
+
+// This example of the BitConverter.IsLittleEndian field generates
+// the following output when run on x86-class computers.
+// 
+// IsLittleEndian: True
+//</Snippet2>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.Class/FS/networkorder1.fs

@@ -0,0 +1,34 @@
+module networkorder1
+
+// <Snippet4>
+open System
+
+let value = 12345678
+let bytes = BitConverter.GetBytes value
+printfn $"{BitConverter.ToString bytes}"
+
+if BitConverter.IsLittleEndian then
+ Array.Reverse bytes
+
+printfn $"{BitConverter.ToString bytes}"
+// Call method to send byte stream across machine boundaries.
+
+// Receive byte stream from beyond machine boundaries.
+printfn $"{BitConverter.ToString bytes}"
+if BitConverter.IsLittleEndian then
+ Array.Reverse bytes
+
+printfn $"{BitConverter.ToString bytes}"
+let result = BitConverter.ToInt32(bytes, 0)
+
+printfn $"Original value: {value}"
+printfn $"Returned value: {result}"
+
+// The example displays the following output on a little-endian system:
+// 4E-61-BC-00
+// 00-BC-61-4E
+// 00-BC-61-4E
+// 4E-61-BC-00
+// Original value: 12345678
+// Returned value: 12345678
+// </Snippet4>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.DoubleInt64/FS/bitstodbl.fs

@@ -0,0 +1,62 @@
+module bitstodbl
+
+//<Snippet1>
+open System
+
+let print obj1 obj2 = 
+ printfn $"{obj1,20}{obj2,27:E16}"
+
+// Reinterpret the long argument as a double.
+let longBitsToDouble argument =
+ let doubleValue = BitConverter.Int64BitsToDouble argument
+
+ // Display the argument in hexadecimal.
+ print (String.Format("0x{0:X16}", argument)) doubleValue
+
+printfn "This example of the BitConverter.Int64BitsToDouble(Int64) \nmethod generates the following output.\n"
+print "long argument" "double value"
+print "-------------" "------------"
+
+// Convert long values and display the results.
+longBitsToDouble 0
+longBitsToDouble 0x3FF0000000000000L
+longBitsToDouble 0x402E000000000000L
+longBitsToDouble 0x406FE00000000000L
+longBitsToDouble 0x41EFFFFFFFE00000L
+longBitsToDouble 0x3F70000000000000L
+longBitsToDouble 0x3DF0000000000000L
+longBitsToDouble 0x0000000000000001L
+longBitsToDouble 0x000000000000FFFFL
+longBitsToDouble 0x0000FFFFFFFFFFFFL
+longBitsToDouble 0xFFFFFFFFFFFFFFFFL
+longBitsToDouble 0xFFF0000000000000L
+longBitsToDouble 0x7FF0000000000000L
+longBitsToDouble 0xFFEFFFFFFFFFFFFFL
+longBitsToDouble 0x7FEFFFFFFFFFFFFFL
+longBitsToDouble Int64.MinValue
+longBitsToDouble Int64.MaxValue
+
+
+// This example of the BitConverter.Int64BitsToDouble( long )
+// method generates the following output.
+
+// long argument double value
+// ------------- ------------
+// 0x0000000000000000 0.0000000000000000E+000
+// 0x3FF0000000000000 1.0000000000000000E+000
+// 0x402E000000000000 1.5000000000000000E+001
+// 0x406FE00000000000 2.5500000000000000E+002
+// 0x41EFFFFFFFE00000 4.2949672950000000E+009
+// 0x3F70000000000000 3.9062500000000000E-003
+// 0x3DF0000000000000 2.3283064365386963E-010
+// 0x0000000000000001 4.9406564584124654E-324
+// 0x000000000000FFFF 3.2378592100206092E-319
+// 0x0000FFFFFFFFFFFF 1.3906711615669959E-309
+// 0xFFFFFFFFFFFFFFFF NaN
+// 0xFFF0000000000000 -∞
+// 0x7FF0000000000000 ∞
+// 0xFFEFFFFFFFFFFFFF -1.7976931348623157E+308
+// 0x7FEFFFFFFFFFFFFF 1.7976931348623157E+308
+// 0x8000000000000000 0.0000000000000000E+000
+// 0x7FFFFFFFFFFFFFFF NaN
+//</Snippet1>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.DoubleInt64/FS/dbltobits.fs

@@ -0,0 +1,66 @@
+module dbltobits
+
+//<Snippet2>
+open System
+
+let print obj1 obj2 = 
+ printfn $"{obj1,25:E16}{obj2,23:X16}"
+
+// Reinterpret the double argument as a long.
+let doubleToLongBits argument =
+ let longValue = BitConverter.DoubleToInt64Bits argument
+
+ // Display the resulting long in hexadecimal.
+ print argument longValue
+
+printfn "This example of the BitConverter.DoubleToInt64Bits(Double) \nmethod generates the following output.\n"
+print "double argument" "hexadecimal value"
+print "---------------" "-----------------"
+
+// Convert double values and display the results.
+doubleToLongBits 1.0
+doubleToLongBits 15.0
+doubleToLongBits 255.0
+doubleToLongBits 4294967295.0
+doubleToLongBits 0.00390625
+doubleToLongBits 0.00000000023283064365386962890625
+doubleToLongBits 1.234567890123E-300
+doubleToLongBits 1.23456789012345E-150
+doubleToLongBits 1.2345678901234565
+doubleToLongBits 1.2345678901234567
+doubleToLongBits 1.2345678901234569
+doubleToLongBits 1.23456789012345678E+150
+doubleToLongBits 1.234567890123456789E+300
+doubleToLongBits Double.MinValue
+doubleToLongBits Double.MaxValue
+doubleToLongBits Double.Epsilon
+doubleToLongBits Double.NaN
+doubleToLongBits Double.NegativeInfinity
+doubleToLongBits Double.PositiveInfinity
+
+
+// This example of the BitConverter.DoubleToInt64Bits( double )
+// method generates the following output.
+
+// double argument hexadecimal value
+// --------------- -----------------
+// 1.0000000000000000E+000 3FF0000000000000
+// 1.5000000000000000E+001 402E000000000000
+// 2.5500000000000000E+002 406FE00000000000
+// 4.2949672950000000E+009 41EFFFFFFFE00000
+// 3.9062500000000000E-003 3F70000000000000
+// 2.3283064365386963E-010 3DF0000000000000
+// 1.2345678901230000E-300 01AA74FE1C1E7E45
+// 1.2345678901234500E-150 20D02A36586DB4BB
+// 1.2345678901234565E+000 3FF3C0CA428C59FA
+// 1.2345678901234567E+000 3FF3C0CA428C59FB
+// 1.2345678901234569E+000 3FF3C0CA428C59FC
+// 1.2345678901234569E+150 5F182344CD3CDF9F
+// 1.2345678901234569E+300 7E3D7EE8BCBBD352
+// -1.7976931348623157E+308 FFEFFFFFFFFFFFFF
+// 1.7976931348623157E+308 7FEFFFFFFFFFFFFF
+// 4.9406564584124654E-324 0000000000000001
+// NaN FFF8000000000000
+// -∞ FFF0000000000000
+// ∞ 7FF0000000000000
+//</Snippet2>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.DoubleInt64/FS/fs.fsproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>net6.0</TargetFramework>
+ </PropertyGroup>
+ <ItemGroup>
+ <Compile Include="dbltobits.fs" />
+ <Compile Include="bitstodbl.fs" />
+ </ItemGroup>
+</Project>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.GetBytes.Others/FS/bytesbool.fs

@@ -0,0 +1,24 @@
+module bytesbool
+
+//<Snippet1>
+open System
+
+// Define Boolean true and false values.
+let values = [ true; false ]
+
+// Display the value and its corresponding byte array.
+printfn "%10s%16s\n" "Boolean" "Bytes"
+
+for value in values do
+ let bytes = BitConverter.GetBytes value
+ 
+ BitConverter.ToString bytes
+ |> printfn "%10b%16s" value
+
+
+// The example displays the following output:
+// Boolean Bytes
+//
+// true 01
+// false 00
+//</Snippet1>

samples/snippets/fsharp/VS_Snippets_CLR_System/system.BitConverter.GetBytes.Others/FS/byteschar.fs

@@ -0,0 +1,44 @@
+module byteschar
+
+//<Snippet2>
+open System
+
+let print obj1 obj2 =
+ printfn $"{obj1,10}{obj2,16}"
+
+// Convert a char argument to a byte array and display it.
+let getBytesChar (argument: char) =
+ let byteArray = BitConverter.GetBytes argument
+ 
+ BitConverter.ToString byteArray
+ |> print argument
+
+printfn "This example of the BitConverter.GetBytes(char) \nmethod generates the following output.\r\n"
+print "char" "byte array"
+print "----" "----------"
+
+// Convert char values and display the results.
+getBytesChar '\000'
+getBytesChar ' '
+getBytesChar '*'
+getBytesChar '3'
+getBytesChar 'A'
+getBytesChar '['
+getBytesChar 'a'
+getBytesChar '{'
+
+
+// This example of the BitConverter.GetBytes(char)
+// method generates the following output.
+//
+// char byte array
+// ---- ----------
+// 00-00
+// 20-00
+// * 2A-00
+// 3 33-00
+// A 41-00
+// [ 5B-00
+// a 61-00
+// { 7B-00
+//</Snippet2>