C# 输入2个浮点，转换成二进制，将它们相加，并将结果作为浮点输出到c中#

我需要用C#编写一个代码来输入两个浮点，将它们转换为二进制，将两个二进制数相加，将总和转换回浮点，然后给出浮点输出。我已经成功地将浮动转换成二进制。如何进一步进行？这就是我到目前为止所做的

    static void Main(string[] args)
    {
        Console.Write("Enter first float: ");
        string FirstString = Console.ReadLine();

        Console.Write("Enter second float: ");
        string SecondString = Console.ReadLine();

        int[] FirstBinary = new int[32];
        int[] SecondBinary = new int[32];

        float FirstFloat = float.Parse(FirstString);
        float SecondFloat = float.Parse(SecondString);

        ToBinary (FirstFloat, ref FirstBinary);
        ToBinary (SecondFloat, ref SecondBinary);

        for (int i = 0; i < 32; i++)
        {
            Console.Write(FirstBinary[31 - i]);
        }
        Console.WriteLine();

        for (int i = 0; i < 32; i++)
        {
            Console.Write(SecondBinary[31 - i]);
        }

        Console.WriteLine();
        Console.ReadKey(true);
    }

    // Method to convert float to binary
    static void ToBinary(float a, ref int[] number)
    {
        byte[] bytes = BitConverter.GetBytes(a);

        for (int i = 0; i < 8; i++)
        {
            int b = 1;
            number[i] = bytes[0] & b;
            bytes[0] = (byte)(bytes[0] >> 1);
        }

        for (int i = 8; i < 16; i++)
        {
            int b = 1;
            number[i] = bytes[1] & b;
            bytes[1] = (byte)(bytes[1] >> 1);
        }

        for (int i = 16; i < 24; i++)
        {
            int b = 1;
            number[i] = bytes[2] & b;
            bytes[2] = (byte)(bytes[2] >> 1);
        }

        for (int i = 24; i < 32; i++)
        {
            int b = 1;
            number[i] = bytes[3] & b;
            bytes[3] = (byte)(bytes[3] >> 1);
        }

        return;
    }

static void Main（字符串[]args）
{
控制台。写入（“输入第一个浮点：”；
string FirstString=Console.ReadLine（）；
编写（“输入第二个浮点：”）；
string SecondString=Console.ReadLine（）；
int[]FirstBinary=新的int[32]；
int[]SecondBinary=新的int[32]；
float FirstFloat=float.Parse（FirstString）；
float SecondFloat=float.Parse（SecondString）；
ToBinary（FirstFloat，ref FirstBinary）；
ToBinary（第二个浮点，参考第二个二进制）；
对于（int i=0；i<32；i++）
{
Write（FirstBinary[31-i]）；
}
Console.WriteLine（）；
对于（int i=0；i<32；i++）
{
Write（SecondBinary[31-i]）；
}
Console.WriteLine（）；
Console.ReadKey（true）；
}
//方法将浮点转换为二进制
静态无效ToBinary（浮动a，参考整数[]编号）
{
字节[]字节=位转换器.GetBytes（a）；
对于（int i=0；i<8；i++）
{
int b=1；
数字[i]=字节[0]&b；
字节[0]=（字节）（字节[0]>>1）；
}
对于（int i=8；i<16；i++）
{
int b=1；
数字[i]=字节[1]&b；
字节[1]=（字节）（字节[1]>>1）；
}
对于（int i=16；i<24；i++）
{
int b=1；
数字[i]=字节[2]&b；
字节[2]=（字节）（字节[2]>>1）；
}
对于（int i=24；i<32；i++）
{
int b=1；
数字[i]=字节[3]&b；
字节[3]=（字节）（字节[3]>>1）；
}
回来
}

我一天的大部分时间都在努力记住如何做数学运算，并找到处理进货和进货的好方法。我将浮点拆分为一个KeyValuePair，其中键是指数（字节），值是尾数，我使用浮点的msb将尾数转换为有符号数。加法变得很简单，我只需移动尾数值以对齐小数点，将两个尾数值相加，然后处理进位/进位。最后将数字转换回浮点

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            List<KeyValuePair<string,string>> inputs = new List<KeyValuePair<string,string>>() {
                new KeyValuePair<string,string>("1.0", "1.0"),
                new KeyValuePair<string,string>("0.0", "0.0"),
                new KeyValuePair<string,string>("1.0", "-1.0"),
                new KeyValuePair<string,string>("1.0", "-0.5"),
                new KeyValuePair<string,string>("-1.00000", "-0.00001"),
                new KeyValuePair<string,string>("1.5", "-2.5"),
                new KeyValuePair<string,string>("1.5E10", "1.5E10"),
                new KeyValuePair<string,string>("-1.1234", "-1.1234"),
                new KeyValuePair<string,string>("-1.5E-10", "-1.5E-10"),
                new KeyValuePair<string,string>("-1.5", "-1.5"),
                new KeyValuePair<string,string>("-1.5", "-2.5")
            };

            foreach (KeyValuePair<string, string> input in inputs)
            {
                string FirstString = input.Key;
                string SecondString = input.Value;

                float FirstFloat = float.Parse(FirstString);
                float SecondFloat = float.Parse(SecondString);

                KeyValuePair<byte, int> FirstBinary = ToBinary(FirstFloat);
                KeyValuePair<byte, int> SecondBinary = ToBinary(SecondFloat);

                float total = Add(FirstBinary, SecondBinary);
                Console.WriteLine("'{0}' + '{1}' = '{2}'", FirstString, SecondString, total.ToString());
            }
            Console.ReadLine();

        }
        static KeyValuePair<byte, int> ToBinary(float a)
        {
            byte[] bytes = BitConverter.GetBytes(a);

            byte exponent = (byte)((bytes[3] << 1) | (bytes[2] >> 7));

            int mantisa = ((bytes[2] & 0x7F) << 16) | (bytes[1] << 8) | bytes[0];

            //add in implied 1 (bit 24) if value is not zero
            if (a != 0) mantisa = mantisa | 0x800000;

            if ((bytes[3] & 0x80) > 0) mantisa = -mantisa;

            return new KeyValuePair<byte, int>(exponent, mantisa);
        }
        static float Add(KeyValuePair<byte, int> FirstBinary, KeyValuePair<byte, int> SecondBinary)
        {
            byte FirstExponent = FirstBinary.Key;
            int FirstMantisa = FirstBinary.Value;

            byte SecondExponent = SecondBinary.Key;
            int SecondMantisa = SecondBinary.Value;

            int mantisa = 0;
            byte exponent = 0;

            //align mantisa using largest exponent and add
            if (FirstExponent >= SecondExponent)
            {
                exponent = FirstExponent;
                mantisa = FirstMantisa + (SecondMantisa >> (FirstExponent - SecondExponent));
            }
            else
            {
                exponent = SecondExponent;
                mantisa = SecondMantisa + (FirstMantisa >> (SecondExponent - FirstExponent));
            }

            byte[] results = new byte[4];


            if (mantisa >= 0)
            {
                if (mantisa != 0)
                {
                    byte carry = (byte)((mantisa >> 23) & 0xFF);
                    //adjust for carry bit 25
                    switch (carry)
                    {
                        case 0:
                            exponent -= 1;
                            mantisa <<= 1;
                            break;
                        case 2:
                            exponent += 1;
                            mantisa >>= 1;
                            break;
                        case 3:
                            exponent += 1;
                            mantisa >>= 1;
                            break;
                    }
                    results[3] = (byte)(exponent >> 1);
                }
            }
            else
            {
                mantisa = -mantisa;
                //adjust for carry bit 25
                byte carry = (byte)((mantisa >> 23) & 0xFF);
                switch (carry)
                {
                    case 0:
                        exponent -= 1;
                        mantisa <<= 1;
                        break;
                    case 2:
                        exponent += 1;
                        mantisa >>= 1;
                        break;
                    case 3:
                        exponent += 1;
                        mantisa >>= 1;
                        break;
                }
                results[3] = (byte)(0x80 | (exponent >> 1));
            }
            results[0] = (byte)(mantisa & 0xFF);
            results[1] = (byte)((mantisa >> 8) & 0xFF);
            results[2] = (byte)((byte)((exponent << 7) & 0x80) | ((byte)(mantisa >> 16) & 0x7F));

            float number = BitConverter.ToSingle(results,0);
            return number;
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
命名空间控制台应用程序1
{
班级计划
{
静态void Main（字符串[]参数）
{
列表输入=新列表（）{
新的KeyValuePair（“1.0”、“1.0”），
新的KeyValuePair（“0.0”、“0.0”），
新的KeyValuePair（“1.0”和“-1.0”），
新的KeyValuePair（“1.0”、“-0.5”），
新的KeyValuePair（“-1.00000”，“-0.00001”），
新的KeyValuePair（“1.5”、“-2.5”），
新的KeyValuePair（“1.5E10”、“1.5E10”），
新的KeyValuePair（“-1.1234”，“-1.1234”），
新的KeyValuePair（“-1.5E-10”，“-1.5E-10”），
新的KeyValuePair（“-1.5”和“-1.5”），
新的KeyValuePair（“-1.5”和“-2.5”）
};
foreach（输入中的KeyValuePair输入）
{
string FirstString=input.Key；
string SecondString=input.Value；
float FirstFloat=float.Parse（FirstString）；
float SecondFloat=float.Parse（SecondString）；
KeyValuePair FirstBinary=ToBinary（FirstFloat）；
KeyValuePair SecondBinary=ToBinary（SecondFloat）；
浮点总数=相加（第一个二进制，第二个二进制）；
Console.WriteLine（“{0}+'{1}'='{2}'，FirstString，SecondString，total.ToString（））；
}
Console.ReadLine（）；
}
静态KeyValuePair ToBinary（浮点a）
{
字节[]字节=位转换器.GetBytes（a）；
字节指数=（字节）（（字节[3]>7））；
int mantisa=（（字节[2]&0x7F）=第二指数）
{
指数=第一指数；
mantisa=第一mantisa+（第二mantisa>>（第一指数-第二指数））；
}
其他的
{
指数=第二指数；
mantisa=SecondMantisa+（FirstMantisa>>（SecondExponent-FirstExponent））；
}
字节[]结果=新字节[4]；
如果（mantisa>=0）
{
if（mantisa！=0）
{
字节进位=（字节）（（mantisa>>23）和0xFF）；
//调整进位25
开关（进位）
{
案例0：
指数-=1；
mantisa=1；
打破
案例3：
指数+=1；
mantisa>>=1；
打破
}
结果[3]=（字节）（指数>>1）；
}
}
其他的
{
mantisa=-mantisa；
//调整进位25
字节进位=（字节）（（mantisa>>23）和0xFF）；
开关（进位）
{
案例0：
指数-=1；
mantisa=1；
打破
案例3：
指数+=1；
mantisa>>=1；
打破
}
结果[3]=（字节）（0x80 |（指数>>1））；
}
结果[0]=（字节）（mantisa&0xFF）；
结果[1]=（字节）（（mantisa>>8）和0