1. Long.parseLong(new String(tmp), 36)

using System; 
using SandBoxConsole.Base36; 
 
namespace SandBoxConsole 
{ 
    class Program 
    { 
        static void Main(string[] args) 
        { 
            string s = "1a"; 
            Console.WriteLine(s); 
            Number n = (Number)s; 
            Console.WriteLine((long)n); 
            Console.WriteLine((string)n); 
            long l = (long)n; 
            Console.WriteLine(l); 
            Console.WriteLine((string)((Number)l)); 
            Console.ReadKey(true); 
        } 
    } 
 
    namespace Base36 
    { 
        class Digit 
        { 
            public const string EnumDigits = "0123456789abcdefghijklmnopqrstuvwxyz"; 
            private char digit; 
 
            public Digit(int d) 
            { 
                char tmp; 
                if (char.TryParse(char.ConvertFromUtf32(d).ToLower(), out tmp)) 
                { 
                    if (tmp >= '0' && tmp <= '9' || tmp >= 'a' && tmp <= 'z') 
                    { 
                        digit = tmp; 
                        return; 
                    } 
                } 
                throw new OverflowException(string.Format("Le code UTF32 '{0}' n'est pas un caractère reconnu en base 36.", d));  
            } 
 
            public Digit(char d) 
            { 
                d = char.ToLower(d); 
                if (d >= '0' && d <= '9' || d >= 'a' && d <= 'z') 
                { 
                    digit = d; 
                    return; 
                } 
                throw new OverflowException(string.Format("Le caractère '{0}' n'est pas un caractère reconnu en base 36.", d));  
            } 
 
            public char ToChar() 
            { 
                return digit; 
            } 
 
            public long ToLong() 
            { 
                return EnumDigits.IndexOf(digit); 
            } 
 
            public static explicit operator char(Digit value) 
            { 
                return value.ToChar(); 
            } 
 
            public static explicit operator long(Digit value) 
            { 
                return value.ToLong(); 
            } 
 
            public static explicit operator Digit(char value) 
            { 
                return new Digit(value); 
            } 
 
            public static explicit operator Digit(int value) 
            { 
                return new Digit(value); 
            } 
        } 
 
        class Number 
        { 
            private Digit[] digits; 
 
            public Number(long n) 
            { 
                 
                digits = new Digit[(int)Math.Ceiling(Math.Log(n, 36))]; 
                int i = 0; 
                while (n > 0) 
                { 
                    digits[i++] = (Digit)Digit.EnumDigits[(int)(n % 36)]; 
                    n /= 36; 
                } 
            } 
 
            public Number(string s) 
            { 
                digits = new Digit[s.Length]; 
                for (int i = 0, cpt = s.Length - 1; i <= cpt; i++) 
                { 
                    digits[i] = new Digit(s[cpt - i]); 
                } 
            } 
 
            public long ToLong() 
            { 
                long n = 0; 
                long mul = 1; 
                for (int i = 0, cpt = digits.Length; i < cpt; i++) 
                { 
                    n += (long)digits[i] * mul; 
                    mul *= 36; 
                } 
                return n; 
            } 
 
            public override string ToString() 
            { 
                string s = string.Empty; 
                for (int i = digits.Length - 1; i >= 0; i--) 
                { 
                    s += (char)digits[i]; 
                } 
                return s; 
            } 
 
            public static explicit operator Number(long value) 
            { 
                return new Number(value); 
            } 
 
            public static explicit operator Number(string value) 
            { 
                return new Number(value); 
            } 
 
            public static explicit operator long(Number value) 
            { 
                return value.ToLong(); 
            } 
 
            public static explicit operator string(Number value) 
            { 
                return value.ToString(); 
            } 
        } 
    } 
}

1. public long parseBase(char[] str)
2.         {
3.             Dictionary<char,int> tabCorrespondance = new Dictionary<char,int>();
4.             tabCorrespondance.Add('0', 0);
5.             tabCorrespondance.Add('1', 1);
6.             tabCorrespondance.Add('2', 2);
7.             tabCorrespondance.Add('3', 3);
8.             tabCorrespondance.Add('4', 4);
9.             tabCorrespondance.Add('5', 5);
10.             tabCorrespondance.Add('6', 6);
11.             tabCorrespondance.Add('7', 7);
12.             tabCorrespondance.Add('8', 8);
13.             tabCorrespondance.Add('9', 9);
14.             tabCorrespondance.Add('a', 10);
15.             tabCorrespondance.Add('b', 11);
16.             tabCorrespondance.Add('c', 12);
17.             tabCorrespondance.Add('d', 13);
18.             tabCorrespondance.Add('e', 14);
19.             tabCorrespondance.Add('f', 15);
20.             tabCorrespondance.Add('g', 16);
21.             tabCorrespondance.Add('h', 17);
22.             tabCorrespondance.Add('i', 18);
23.             tabCorrespondance.Add('j', 19);
24.             tabCorrespondance.Add('k', 20);
25.             tabCorrespondance.Add('l', 21);
26.             tabCorrespondance.Add('m', 22);
27.             tabCorrespondance.Add('n', 23);
28.             tabCorrespondance.Add('o', 24);
29.             tabCorrespondance.Add('p', 25);
30.             tabCorrespondance.Add('q', 26);
31.             tabCorrespondance.Add('r', 27);
32.             tabCorrespondance.Add('s', 28);
33.             tabCorrespondance.Add('t', 29);
34.             tabCorrespondance.Add('u', 30);
35.             tabCorrespondance.Add('v', 31);
36.             tabCorrespondance.Add('w', 32);
37.             tabCorrespondance.Add('x', 33);
38.             tabCorrespondance.Add('y', 34);
39.             tabCorrespondance.Add('z', 35);
41.             Array.Reverse(str);
43.             long nb = 0;
44.             double scale = 0;
46.             foreach (char var in str)
47.             {
48.                 if (scale == 0)
49.                 {
50.                     nb += tabCorrespondance[var];
51.                 }
52.                 else
53.                 {
54.                     nb += long.Parse(Math.Pow(double.Parse("36" ), scale).ToString()) * tabCorrespondance[var];
55.                 }
56.                 scale++;
57.             }
59.             return nb;
60. }

public const string EnumDigits = "0123456789abcdefghijklmnopqrstuvwxyz";

char ChiffreBase36 = EnumDigits[ValeurEntiere];
int ValeurEntiere = EnumDigits.indexOf(ChiffreBase36);

long MonLong = (long)MonInt;
long MonLong = (long)MonDouble;
 
double MonDouble = (double)MonLong / (double)Monentier;

long MonLong = MonInt;
int MonEntier = MonLong;

nb += long.Parse(Math.Pow(double.Parse("36" ), scale).ToString()) * tabCorrespondance[var];

nb += (long)Math.Pow(36, scale) * tabCorrespondance[var];

string const Digits = "0123456789abcdefghijklmnopqrstuvwxyz";
 
public long parseBase(char[] str)
{
  long nb = 0;
  double scale = 0;
 
  for (int i = str.Length - 1; i >= 0; i--)
  {
    nb += (long)Math.Pow(scale++, 36) * Digits.IndexOf(str[i]);
  }
  return nb;
}