不限位数的十进制正整数类，可进行加和乘操作

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

namespace  TestFactorial
{
     /**/ ///   <summary>
     ///  10机制正整数类
     ///   </summary>
     public   class  DecimalNumber
     {
        List < byte >  _Data;

         public  List < byte >  Data
         {
             get
             {
                 return  _Data;
            }
        }

         public   int  Length
         {
             get
             {
                 return  _Data.Count;
            }
        }

         public  DecimalNumber()
         {
            _Data  =   new  List < byte > ();
        }

         public  DecimalNumber( byte [] data)
         {
             foreach  ( byte  b  in  data)
             {
                System.Diagnostics.Debug.Assert(b  >=   0   &&  b  <=   9 );
            }

            _Data  =   new  List < byte > (data);
        }

         public  DecimalNumber(List < byte >  data)
         {
             foreach  ( byte  b  in  data)
             {
                System.Diagnostics.Debug.Assert(b  >=   0   &&  b  <=   9 );
            }

            _Data  =  data;
        }

         /**/ ///   <summary>
         ///  1位10机制数和10进制序列相乘
         ///  
         ///   </summary>
         ///   <param name="s"> 10进制序列 </param>
         ///   <param name="d"> 1位10机制数 </param>
         ///   <param name="power"> 10的幂数 </param>
         ///   <returns></returns>
         private   static  List < byte >  Multiply(List < byte >  s,  byte  d,  int  power)
         {
            System.Diagnostics.Debug.Assert(power  >=   0 );
            System.Diagnostics.Debug.Assert(d  >=   0   &&  d  <=   9 );

            List < byte >  result  =   new  List < byte > ();

             for  ( int  i  =   0 ; i  <  power; i ++ )
             {
                result.Add( 0 );
            }

             byte  carry  =   0 ;  // 进位

             foreach  ( byte  si  in  s)
             {
                System.Diagnostics.Debug.Assert(si  >=   0   &&  si  <=   9 );

                 byte  r  =  ( byte )(si *  d  +  carry);
                 byte  m  =  ( byte )(r  %   10 );
                carry  =  ( byte )(r  /   10 );
                result.Add(m);
            }

             if  (carry  >   0 )
             {
                result.Add(carry);
            }


             return  result;
        }

         /**/ ///   <summary>
         ///  两个10进制序列相加
         ///   </summary>
         ///   <param name="s1"> 序列1 </param>
         ///   <param name="s2"> 序列2 </param>
         ///   <returns> 相加后的序列 </returns>
         private   static  List < byte >  Plus(List < byte >  s1, List < byte >  s2)
         {
            List < byte >  result  =   new  List < byte > ();

             int  c1  =  s1.Count;
             int  c2  =  s2.Count;

             if  (c1  >  c2)
             {
                 for  ( int  i  =   0 ; i  <  c1  -  c2; i ++ )
                 {
                    s2.Add( 0 );
                }
            }
             else   if  (c1  <  c2)
             {
                 for  ( int  i  =   0 ; i  <  c2  -  c1; i ++ )
                 {
                    s1.Add( 0 );
                }
            }

             byte  carry  =   0 ;  // 进位

             for  ( int  i  =   0 ; i  <  s1.Count; i ++ )
             {
                System.Diagnostics.Debug.Assert(s1[i]  >=   0   &&  s1[i]  <=   9 );
                System.Diagnostics.Debug.Assert(s2[i]  >=   0   &&  s2[i]  <=   9 );

                 byte  r  =  ( byte )(s1[i]  +  s2[i]  +  carry);
                 byte  m  =  ( byte )(r  %   10 );
                carry  =  ( byte )(r  /   10 );
                result.Add(m);
            }

             if  (carry  >   0 )
             {
                result.Add(carry);
            }

             return  result;
        }

         public   static   implicit   operator  DecimalNumber( string  value)
         {
            List < byte >  data  =   new  List < byte > ();

             for  ( int  i  =  value.Length  -   1 ; i  >=   0 ; i -- )
             {
                data.Add( byte .Parse(value[i].ToString()));
            }

             return   new  DecimalNumber(data);
        }

         public   static   implicit   operator  DecimalNumber( int  value)
         {
            System.Diagnostics.Debug.Assert(value  >=   0 );
             return  value.ToString();
        }

         public   static  DecimalNumber  operator   ++ (DecimalNumber d)
         {
             return  d  +   new  DecimalNumber( new   byte []  { 1 } );
        }

         public   static  DecimalNumber  operator   + (DecimalNumber d1,  int  d2)
         {
            System.Diagnostics.Debug.Assert(d2  >=   0 );

             return  d1  +  d2.ToString();
        }

         public   static  DecimalNumber  operator + (DecimalNumber d1, DecimalNumber d2)
         {
             return   new  DecimalNumber(Plus(d1.Data, d2.Data));
        }

         public   static  DecimalNumber  operator * (DecimalNumber d1, DecimalNumber d2)
         {
            List < List < byte >>  multiplicationSerial  =   new  List < List < byte >> ();

             for  ( int  i  =   0 ; i  <  d1.Data.Count; i ++ )
             {
                multiplicationSerial.Add(Multiply(d2.Data, d1.Data[i], i));
            }

            List < byte >  result  =   new  List < byte > ();

             foreach (List < byte >  s  in  multiplicationSerial)
             {
                result  =  Plus(s, result);
            }
            
             return   new  DecimalNumber(result);
        }

         public   override   string  ToString()
         {
            StringBuilder str  =   new  StringBuilder();

             for  ( int  i  =  _Data.Count  -   1 ; i  >=   0  ; i -- )
             {
                str.Append(_Data[i].ToString());
            }

             return  str.ToString();
        }
    }

     class  Program
     {
         static   void  Main( string [] args)
         {
             int  d  =   1 ;
            DecimalNumber factorial  =   1 ;

             while  (factorial.Length  <   3 )
             {
                d ++ ;
                factorial  =  factorial  *  d;
                 // Console.WriteLine(factorial);
                 // Console.WriteLine(d);
            }

            Console.WriteLine(d);
        }
    }
}