system.convert.tobase64string (in F#) - string

Question

https://msdn.microsoft.com/fr-fr/library/system.convert.tobase64string.aspx
I don't really understand what this function does.
> System.Convert.ToBase64String [|7uy;243uy|];;
val it : string = "B/M="
> System.Convert.ToBase64String [|243uy;7uy|];;
val it : string = "8wc="
> System.Convert.ToBase64String [|243uy|];;
val it : string = "8w=="
> System.Convert.ToBase64String [|243uy;7uy;3uy|];;
val it : string = "8wcD"
> System.Convert.ToBase64String [|243uy;7uy;3uy;5uy|];;
val it : string = "8wcDBQ=="
I would have expected that function to be "commutative", that if we assume the first answer then System.Convert.ToBase64String [|243uy;7uy|];; would yield
val it : string = "M=B/"
also im surprised that with an array with 1,2 and 3 elements the size is a string of length 4, then we move to 8 from an array of size 4...
I didn't find any explanations...
I thought System.Text.Encoding.UTF8.GetString would do what i want to do (produce manually a string hash) but embarassingly
> System.Text.Encoding.UTF8.GetString [|243uy;7uy|];;
val it : string = "�"
> System.Text.Encoding.UTF8.GetString [|7uy;243uy|];;
val it : string = "�"
look the same
with individually
> System.Text.Encoding.UTF8.GetChars [|7uy;243uy|];;
val it : char [] = [|'\007'; '�'|]
> System.Text.Encoding.UTF8.GetChars [|243uy;7uy|];;
val it : char [] = [|'�'; '\007'|]
thanks

Answer 1

Not knowing your background, forgive me for quickly covering the basics:
Number bases: First, you'll want to understand how bases work in general, and binary (Base 2) in specific. If you don't understand what I mean when I say that 243 = 0b11110011 or 0b00000111 = 7, you'll want to check out the following link: http://betterexplained.com/articles/numbers-and-bases/ -- he explains it better than I could. :) We need to know this because in order to understand Base64 encoding, you need to be able to convert a number between decimal and binary, and vice versa.
Base64: To understand Base64 encoding, we need to go down to the level of the bits. See https://en.wikipedia.org/wiki/Base64 for a pretty clear picture. Base64's purpose historically is to help prepare binary data to be sent between computer systems via methods which don't reliably handle non-text data, such as email before it supported attachments. It does this by combining the bytes' data and re-slicing their boundaries so that each unit has 6 bits instead of 8. 6 bits can hold 2^6 = 64 different values, and an entire printable character is used to represent this base64 unit. Usually, A-Z represents values 0-25, a-z = 26-51, 0-9 = 52-61, and two final characters, + for value 62, and / for value 63. This representation of the data takes more memory -- it takes 4 bytes of printable characters to represent 3 bytes of binary data, but the benefit is that the data is now representable as text (and will thus be more likely to be the same binary data across different systems and character sets). When the data is received, the process is reversed, and you get your binary data back.
There is one extra piece. Binary data is consumed in chunks of 3 bytes -- this is so 24 incoming bits can easily be resliced into 4 base64 chars of 6 bits each. If the end of the data doesn't completely fill the last chunk, the encoding will be padded so that on the other end the decoding will leave off the correct number of bytes. A single = will show that the last chunk is padded one byte, and double equals (==) will show that the last chunk is padded two bytes. The decoding process will then know the final chunk of created bytes will be 1 or 2 bytes short.
Understanding some of your examples
Let's take a look at your first example -- you're sending the bytes 7 and 243 into the function:
System.Convert.ToBase64String[|7uy;243uy|]
// byte 1 byte 2 no 3rd
// dec 7 dec 243 byte!
// 00000111 11110011 00000000
// reslice 3*8 into 4*6
// 000001 111111 001100 000000
// dec 1 dec 63 dec 12 padding <-- refer to wikipedia base64 table
// char B char / char M char =
"B/M="
For your next example you're sending the bytes 243 and 7 into the function:
System.Convert.ToBase64String[|243uy;7uy|]
// byte 1 byte 2 no 3rd
// dec 243 dec 7 byte!
// 11110011 00000111 00000000
// reslice 3*8 into 4*6
// 111100 110000 011100 000000
// dec 60 dec 48 dec 28 padding <-- refer to wikipedia base64 table
// char 8 char w char c char =
"8wc="
Not 'commutative' You thought that the encoding should be "commutative". Just to be clear, this is a property that means the order that you perform an operation is irrelevant, such as adding or multiplying -- 1 + 2 + 3 can be added in any sequence, and the answer is still 6. I'm not sure that this property makes sense for this kind of operation -- the data itself isn't changing, you're merely giving it a different representation. Said differently, if you resequenced the input data but had the same output, either the data would no longer be the same, or the bytes you swapped were identical. :) Perhaps you meant that you expected swapping bytes would mean the base64 characters would swap? After having gone through a couple of examples, you can see that in each chunk, a portion of each input byte goes into determining what the next character is -- you're not swapping on clean boundary breaks. However, if you swapped a chunk of three bytes with another chunk of three bytes, then the resulting 8 output characters would cleanly swap. For example:
> let bytes = System.Text.Encoding.UTF8.GetBytes( "foobar" );;
val bytes : byte [] = [|102uy; 111uy; 111uy; 98uy; 97uy; 114uy|]
> System.Convert.ToBase64String bytes;;
val it : string = "Zm9vYmFy"
> let bytes = System.Text.Encoding.UTF8.GetBytes( "barfoo" );;
val bytes : byte [] = [|98uy; 97uy; 114uy; 102uy; 111uy; 111uy|]
> System.Convert.ToBase64String bytes;;
val it : string = "YmFyZm9v"
You can see that swapping a 3 byte chunk resulted in a clean swap of the 4 character output chunks.
Unexpected output size You mention that you were surprised to see a 4 character output for input byte arrays of length 1, 2, and 3. By now you probably recognized that the Base64 encoding algorithm processes in chunks of 3 bytes, producing 4 character output for each 3 byte chunk. The ending equals signs are the padding signifying that the input bytes didn't fill the last chunk. To be clear:
1 byte in = 4 chars out, last two are padding
2 bytes in = 4 chars out, last one is padding
3 bytes in = 4 chars out, no padding
4 bytes in = 8 chars out, last two are padding
etc.
Decoding Although you don't mention it, Base64 is an encoding, which means there is a decoding. Once you have your chars, you can easily get your bytes back again:
> System.Convert.FromBase64String "B/M=";;
val it : byte [] = [|7uy; 243uy|]
// or a more realistic string example:
> let bytes = System.Text.Encoding.UTF8.GetBytes( "foobar" );;
val bytes : byte [] = [|102uy; 111uy; 111uy; 98uy; 97uy; 114uy|]
> System.Convert.ToBase64String bytes;;
val it : string = "Zm9vYmFy"
> let bytes = System.Convert.FromBase64String "Zm9vYmFy";;
val bytes : byte [] = [|102uy; 111uy; 111uy; 98uy; 97uy; 114uy|]
> System.Text.Encoding.UTF8.GetString( bytes );;
val it : string = "foobar"
Producing a string hash The last unanswered idea is your saying you want to make a string hash. I'm not sure if you meant to encode a string as Base64 (which would probably be unnecessary since strings are usually already made of printable chars), except it kind of looks like it's been encrypted-ish (my guess is someone would think to Base64 decode it pretty quickly). However, just in case you wanted to get a hash on the string, remember all objects already have this functionality. Perhaps the following is what you're looking for?
> "Hash this please!".GetHashCode();;
val it : int = -1297461057
Regardless, hope this helped make things more clear. Good luck!