It is a new (to 2.0) class in System.Diagnostics. It is easy to use and is
useful when comparing the performance of different approaches to solving a
problem.

Jim,
As Jon Skeet pointed out, modifying the Framework System.Convert classes may
be the way to go here. A quick decompilation of the System.Convert Base64
methods reveals that :
1) they use unsafe code, which probably accounts for the speed factor.
2) There is a char[] Base64Table used.

So, you could decompile this, create your own (say,
Convert.ToBase64StringUrlSafe) method, and all you would need to do is change
the values in the Base64table char[] array.
Peter

If you insist in pursuing the idea, then there are some code
attached below which is the fastest code I can write without
unsafe code.

Arne

==================================================='

    public class Base64
    {
        private static char[] EncVals =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".ToCharArray();
        private static int[] DecVals;
        static Base64()
        {
            DecVals = new int[128];
            for(int i = 0; i < 64; i++)
            {
                DecVals[EncVals[i]] = i;
            }
        }
        public string Encode(byte[] b)
        {
            int len = (b.Length * 8 + 5) / 6;
            int extra = 3 - (len + 3) % 4;
            char[] res = new char[len + extra];
            int p = b.Length - b.Length % 3;
            int ix = 0;
            int tmp;
            for(int i = 0; i < p; i += 3)
               {
                tmp = (b[i] << 16) | (b[i + 1] << 8) | b[i + 2];
                res[ix + 3] = EncVals[tmp & 0x3F];
                res[ix + 2] = EncVals[(tmp >> 6) & 0x3F];
                res[ix + 1] = EncVals[(tmp >> 12) & 0x3F];
                res[ix] = EncVals[tmp >> 18];
                ix += 4;
            }
            if(extra == 1)
            {
                tmp = (b[p] << 16) | (b[p + 1] << 8);
                res[ix + 3] = '=';
                res[ix + 2] = EncVals[(tmp >> 6) & 0x3F];
                res[ix + 1] = EncVals[(tmp >> 12) & 0x3F];
                res[ix] = EncVals[tmp >> 18];
            }
            else if(extra == 2)
            {
                tmp = b[p] << 16;
                res[ix + 3] = '=';
                res[ix + 2] = '=';
                res[ix + 1] = EncVals[(tmp >> 12) & 0x3F];
                res[ix] = EncVals[tmp >> 18];
            }
               return new String(res);
        }
        public byte[] Decode(string s)
        {
            int len = s.Length;
            while(s[len - 1] == '=') len--;
            len = (len / 4 + 2) * 3;
            byte[] res = new byte[len];
            int ix = 0;
            int tmp;
            for(int i = 0; i < s.Length; i += 4)
            {
                tmp = (DecVals[s[i]] << 18) | (DecVals[s[i + 1]] << 12) |
                     (DecVals[s[i + 2]] << 6) | DecVals[s[i + 3]];
                res[ix] = (byte)(tmp >> 16);
                res[ix + 1] = (byte)((tmp >> 8) & 0xFF);
                res[ix + 2] = (byte)(tmp & 0xFF);
                ix += 3;
            }
            return res;
        }
    }

This isn't usually for communicating between two applications though -
it's to allow a stateless application to communicate effectively with
itself. In other words, you're in complete control of both "ends" of
the conversation, so can be compatible with yourself appropriately.
Base64 happens to be a pretty simple format for representing arbitrary
binary data, and it just needs a little tweak for the sake of URL
encoding.