C#超大数字运算

这里记两个计算大数字运算的类（其实是从别人那里扒的，是dll，不过之前用了.net4.0的一些特性，用.net3.5导入unity报错，就反编译改了下，贴在这里以后能用着也好找）。当我们要运算的数值超过了double,long的时候，我们就不得不用string来表示一个数了，例如：111111111111111111111111111111111111*122222123123122222222221222221
这么一个等式。

第一个类整数型

using System;

namespace Sqrt
{
   
  internal class ComputeStringInt
  {
   
    public string Body = "0";

    public static readonly ComputeStringInt Zero  = new ComputeStringInt("0");

    public int Length
    {
   
      get
      {
   
        if ((int) this.Body[0] == 43 || (int) this.Body[0] == 45)
          return this.Body.Length - 1;
        return this.Body.Length;
      }
    }

    public int this[int index]
    {
   
      get
      {
   
        if ((int) this.Body[0] == 43 || (int) this.Body[0] == 45)
          return (int) this.Body[index + 1] - 48;
        return (int) this.Body[index] - 48;
      }
    }

    public bool IsPositive
    {
   
      get
      {
   
        return (int) this.Body[0] != 45 || !(new ComputeStringInt(this.Body.Substring(1)) != (ComputeStringInt) 0L);
      }
    }

    public ComputeStringInt()
    {
   
    }

    public ComputeStringInt(string numStr)
    {
   
      if (string.IsNullOrEmpty(numStr))
        this.Body = "0";
      else
        this.Body = this.Trim(numStr);
    }

    public static implicit operator string(ComputeStringInt source)
    {
   
      return source.Body;
    }

    public static implicit operator ComputeStringInt(long real)
    {
   
      return new ComputeStringInt(real.ToString());
    }

    public static implicit operator ComputeStringInt(string real)
    {
   
      return new ComputeStringInt(real);
    }

    public static bool operator >(ComputeStringInt left, ComputeStringInt right)
    {
   
      if (left.IsPositive && !right.IsPositive && left.Absolute().Body != "0" && right.Absolute().Body != "0")
        return true;
      if (left.IsPositive && right.IsPositive)
      {
   
        if (left.Length > right.Length)
          return true;
        if (left.Length != right.Length)
          return false;
        for (int index = 0; index < left.Length; ++index)
        {
   
          if (left[index] > right[index])
            return true;
          if (left[index] < right[index])
            return false;
        }
      }
      else if (!left.IsPositive && !right.IsPositive)
      {
   
        if (left.Length < right.Length)
          return true;
        if (left.Length != right.Length)
          return false;
        for (int index = 0; index < left.Length; ++index)
        {
   
          if (left[index] < right[index])
            return true;
          if (left[index] > right[index])
            return false;
        }
      }
      else if (left.IsPositive && !right.IsPositive && (left.Absolute().Body == "0" && right.Absolute().Body != "0" || left.Absolute().Body != "0" && right.Absolute().Body == "0"))
        return true;
      return false;
    }

    public static bool operator <(ComputeStringInt left, ComputeStringInt right)
    {
   
      return right > left;
    }

    public static bool operator >=(ComputeStringInt left, ComputeStringInt right)
    {
   
      return left > right || left == right;
    }

    public static bool operator <=(ComputeStringInt left, ComputeStringInt right)
    {
   
      return left < right || left == right;
    }

    public static bool operator ==(ComputeStringInt left, ComputeStringInt right)
    {
   
      return !(left > right) && !(left < right);
    }

    public static bool operator !=(ComputeStringInt left, ComputeStringInt right)
    {
   
      return left > right || left < right;
    }

    public static bool operator >(ComputeStringInt left, object right)
    {
   
      return left > new ComputeStringInt(right.ToString());
    }

    public static bool operator >(object left, ComputeStringInt right)
    {
   
      return new ComputeStringInt(left.ToString()) > right;
    }

    public static bool operator <(ComputeStringInt left, object right)
    {
   
      return left < new ComputeStringInt(right.ToString());
    }

    public static bool operator <(object left, ComputeStringInt right)
    {
   
      return new ComputeStringInt(left.ToString()) < right;
    }

    public static bool operator >=(ComputeStringInt left, object right)
    {
   
      return left >= new ComputeStringInt(right.ToString());
    }

    public static bool operator >=(object left, ComputeStringInt right)
    {
   
      return new ComputeStringInt(left.ToString()) >= right;
    }

    public static bool operator <=(ComputeStringInt left, object right)
    {
   
      return left <= new ComputeStringInt(right.ToString());
    }

    public static bool operator <=(object left, ComputeStringInt right)
    {
   
      return new ComputeStringInt(left.ToString()) <= right;
    }

    public static bool operator ==(ComputeStringInt left, object right)
    {
   
      return left == new ComputeStringInt(right.ToString());
    }

    public static bool operator ==(object left, ComputeStringInt right)
    {
   
      return new ComputeStringInt(left.ToString()) == right;
    }

    public static bool operator !=(ComputeStringInt left, object right)
    {
   
      return left != new ComputeStringInt(right.ToString());
    }

    public static bool operator !=(object left, ComputeStringInt right)
    {
   
      return new ComputeStringInt(left.ToString()) != right;
    }

    public static ComputeStringInt operator +(ComputeStringInt left, ComputeStringInt right)
    {
   
      ComputeStringInt computeStringInt1 = new ComputeStringInt();
      if (left.IsPositive && right.IsPositive)
      {
   
        int length = right.Length;
        if (left.Length > right.Length)
          length = left.Length;
        int num1 = 0;
        for (int index = 0; index < length; ++index)
        {
   
          int num2 = index >= left.Length || index >= right.Length ? (index < left.Length ? (index < right.Length ? 0 : left[left.Length - 1 - index] + num1) : right[right.Length - 1 - index] + num1) : left[left.Length - 1 - index] + right[right.Length - 1 - index] + num1;
          num1 = num2 / 10;
          int num3;
          if (index == 0)
          {
   
            ComputeStringInt computeStringInt2 = computeStringInt1;
            num3 = num2 % 10;
            string str = num3.ToString();
            computeStringInt2.Body = str;
          }
          else
          {
   
            ComputeStringInt computeStringInt2 = computeStringInt1;
            string str1 = computeStringInt1.Body;
            int startIndex = 0;
            num3 = num2 % 10;
            string str2 = num3.ToString();
            string str3 = str1.Insert(startIndex, str2);
            computeStringInt2.Body = str3;
          }
        }
        computeStringInt1.Body = computeStringInt1.Body.Insert(0, num1.ToString());
      }
      else if (left.IsPositive && !right.IsPosi