using System;

public class Program

{

    public static void Main()

    {

        //Bool Data Type

        bool boolVal = false;

        Console.WriteLine("Boolean Value Before Conversion: " + boolVal);

        byte[] boolVal_AsByteArray = BitConverter.GetBytes(boolVal);//Convert To Byte Array From Bool

        Console.WriteLine("Bool Value As Byte: [{0}]", string.Join(", ", boolVal_AsByteArray));

        boolVal = BitConverter.ToBoolean(boolVal_AsByteArray, 0);//Convert From Byte Array To Bool

        Console.WriteLine("Boolean Value After Conversion:  " + boolVal);

        Console.WriteLine("");

        //Char Data Type

        char charVal = 'A';

        Console.WriteLine("Char Value Before Conversion: " + charVal);

        byte[] charVal_AsByteArray = BitConverter.GetBytes(charVal);//Convert To Byte Array From Char

        Console.WriteLine("Char Value As Byte Array: [{0}]", string.Join(", ", charVal_AsByteArray));

        charVal = BitConverter.ToChar(charVal_AsByteArray, 0);//Convert From Byte Array To Char

        Console.WriteLine("Char Value After Conversion:  " + charVal);

        Console.WriteLine("");

        //Decimal Data Type

        decimal decimalVal = Decimal.MaxValue;

        Console.WriteLine("Decimal Value Before Conversion: " + decimalVal);

        int[] decimalVal_AsIntArray = Decimal.GetBits(decimalVal);//Convert From Decimal To Int Array - 4 Elements In Size

        byte[] decimalVal_AsByteArray = new byte[decimalVal_AsIntArray.Length * sizeof(int)];//Array To Store Byte Value - 16 Elements In Size - An Int Value Is Equivalent To 4 Bytes; As Such The Array Is 16 Elements In Size.

        /*

            Populate The Byte Array Created Above From The Integer Array Created On The Previous Line. 

            Read And Copy The Data In The Integer Array One Byte At A Time (Each Integer Value Is Composed Of Four Byte Values).

            LINK: https://docs.microsoft.com/en-us/dotnet/api/system.buffer.blockcopy?view=netframework-4.7.2

        */

        Buffer.BlockCopy(decimalVal_AsIntArray, 0, decimalVal_AsByteArray, 0, decimalVal_AsByteArray.Length);

        Console.WriteLine("Decimal Value As Byte Array: [{0}]", string.Join(", ", decimalVal_AsByteArray));

        decimalVal_AsIntArray = new int[decimalVal_AsByteArray.Length / sizeof(int)];//Array To Store Int Values - 4 Elements In Size - Four Bytes Is Equivalent To One Int; As Such The Array Is 4 Elements In Size.

        /*

            As Above, Albeit Read And Copy The Data From The Byte Array Four Bytes At A Time (In Order To Create An Integer Value From Them).

        */

        Buffer.BlockCopy(decimalVal_AsByteArray, 0, decimalVal_AsIntArray, 0, decimalVal_AsByteArray.Length);

        decimalVal = new Decimal(decimalVal_AsIntArray);

        Console.WriteLine("Decimal Value After Conversion:  " + decimalVal);

        Console.WriteLine("");

        //Double Data Type

        double doubleVal = Double.MaxValue;

        Console.WriteLine("Double Value Before Conversion: " + doubleVal);

        byte[] doubleVal_AsByteArray = BitConverter.GetBytes(doubleVal);//Convert To Byte Array From Double

        Console.WriteLine("Double Value As Byte Array: [{0}]", string.Join(", ", doubleVal_AsByteArray));

        doubleVal = BitConverter.ToDouble(doubleVal_AsByteArray, 0);//Convert From Byte Array To Double

        Console.WriteLine("Double Value After Conversion:  " + doubleVal);

        Console.WriteLine("");

        //Float Data Type

        float floatVal = Single.MaxValue;

        Console.WriteLine("Float Value Before Conversion: " + floatVal);

        byte[] floatVal_AsByteArray = BitConverter.GetBytes(floatVal);//Convert To Byte Array From Float

        Console.WriteLine("Float Value As Byte Array: [{0}]", string.Join(", ", floatVal_AsByteArray));

        floatVal = BitConverter.ToSingle(floatVal_AsByteArray, 0);//Convert From Byte Array To Float (Single)

        Console.WriteLine("Float Value After Conversion:  " + floatVal);

        Console.WriteLine("");

        //Integer Data Type

        int intVal = 2147483647;

        Console.WriteLine("Integer Value Before Conversion: " + intVal);

        byte[] intVal_AsByteArray = BitConverter.GetBytes(intVal);//Convert To Byte Array From Int

        Console.WriteLine("Integer Value As Byte Array: [{0}]", string.Join(", ", intVal_AsByteArray));

        intVal = BitConverter.ToInt32(intVal_AsByteArray, 0);//Convert From Byte Array To Int (32-Bit Integer)

        Console.WriteLine("Integer Value After Conversion:  " + intVal);

        Console.WriteLine("");

        //Unsigned Integer Data Type

        uint uIntVal = 4294967295;

        Console.WriteLine("Unsigned Integer Value Before Conversion: " + uIntVal);

        byte[] uIntVal_AsByteArray = BitConverter.GetBytes(uIntVal);//Convert To Byte Array From Unsigned Int

        Console.WriteLine("Unsigned Integer Value As Byte Array: [{0}]", string.Join(", ", uIntVal_AsByteArray));

        uIntVal = BitConverter.ToUInt32(uIntVal_AsByteArray, 0);//Convert From Byte Array To UInt (Unsigned 32-Bit Integer)

        Console.WriteLine("Unsigned Integer Value After Conversion:  " + uIntVal);

        Console.WriteLine("");

        //Long Data Type

        long longVal = 9223372036854775807;

        Console.WriteLine("Long Value Before Conversion: " + longVal);

        byte[] longVal_AsByteArray = BitConverter.GetBytes(longVal);//Convert To Byte Array From Long

        Console.WriteLine("Long Value As Byte Array: [{0}]", string.Join(", ", longVal_AsByteArray));

        longVal = BitConverter.ToInt64(longVal_AsByteArray, 0);//Convert From Byte Array To Long (64-Bit Integer)

        Console.WriteLine("Long Value After Conversion:  " + longVal);

        Console.WriteLine("");

        //Unsigned Long Data Type

        ulong uLongVal = 8446744073709551615;

        Console.WriteLine("Unsigned Long Value Before Conversion: " + uLongVal);

        byte[] uLongVal_AsByteArray = BitConverter.GetBytes(uLongVal);//Convert To Byte Array From Unsigned Long

        Console.WriteLine("Unsigned Long Value As Byte Array: [{0}]", string.Join(", ", uLongVal_AsByteArray));

        uLongVal = BitConverter.ToUInt64(uLongVal_AsByteArray, 0);//Convert From Byte Array To ULong (Unsigned 64-Bit Integer)

        Console.WriteLine("Unsigned Long Value After Conversion:  " + uLongVal);

        Console.WriteLine("");

        //Short Data Type

        short shortVal = 32767;

        Console.WriteLine("Short Value Before Conversion: " + shortVal);

        byte[] shortVal_AsByteArray = BitConverter.GetBytes(shortVal);//Convert To Byte Array From Short

        Console.WriteLine("Short Value As Byte Array: [{0}]", string.Join(", ", shortVal_AsByteArray));

        shortVal = BitConverter.ToInt16(shortVal_AsByteArray, 0);//Convert From Byte Array To Short (16-Bit Integer)

        Console.WriteLine("Short Value After Conversion:  " + shortVal);

        Console.WriteLine("");

        //Unsigned Short Data Type

        ushort uShortVal = 65535;

        Console.WriteLine("Unsigned Short Value Before Conversion: " + uShortVal);

        byte[] uShortVal_AsByteArray = BitConverter.GetBytes(uShortVal);//Convert To Byte Array From Unsigned Short

        Console.WriteLine("Unsigned Short Value As Byte Array: [{0}]", string.Join(", ", uShortVal_AsByteArray));

        uShortVal = BitConverter.ToUInt16(uShortVal_AsByteArray, 0);//Convert From Byte Array To UShort (Unsigned 16-Bit Integer)

        Console.WriteLine("Unsigned Short Value After Conversion:  " + uShortVal);

        Console.WriteLine("");

    }

}