Related posts:

1. Windows API Code Pack for Microsoft .NET Framework
2. VS2010下DirectShow环境
3. API:微软

　　实例代码下载：/Files/virusswb/ConsoleApplication1.rar

　　 代码

<summary>
    /// 

　　但是在Silverlight，你会发现如果想用MD5加密，可是不能用WinForm下面的MD5Provider，Silverlight项目就不能添加System.Security命名空间，只好自定义MD5加密了，不用愁，老外已经给我们写好了一个。

Silverlight MD5

<summary>
    /// Summary description for MD5.
    /// </summary>
    public class MD5 : IDisposable
    {
        static public MD5 Create(string hashName)
        {
            if (hashName == ”MD5″)
                return new MD5();
            else
                throw new NotSupportedException();
        }

        static public String GetMd5String(String source)
        {
            MD5 md = MD5CryptoServiceProvider.Create();
            byte[] hash;

            //Create a new instance of ASCIIEncoding to 
            //convert the string into an array of Unicode bytes.
            UTF8Encoding enc = new UTF8Encoding();
            //            ASCIIEncoding enc = new ASCIIEncoding();

            //Convert the string into an array of bytes.
            byte[] buffer = enc.GetBytes(source);

            //Create the hash value from the array of bytes.
            hash = md.ComputeHash(buffer);

            StringBuilder sb = new StringBuilder();
            foreach (byte b in hash)
                sb.Append(b.ToString(“x2″));
            return sb.ToString();
        }

        static public MD5 Create()
        {
            return new MD5();
        }

        #region base implementation of the MD5
        #region constants
        private const byte S11 = 7;
        private const byte S12 = 12;
        private const byte S13 = 17;
        private const byte S14 = 22;
        private const byte S21 = 5;
        private const byte S22 = 9;
        private const byte S23 = 14;
        private const byte S24 = 20;
        private const byte S31 = 4;
        private const byte S32 = 11;
        private const byte S33 = 16;
        private const byte S34 = 23;
        private const byte S41 = 6;
        private const byte S42 = 10;
        private const byte S43 = 15;
        private const byte S44 = 21;
        static private byte[] PADDING = new byte[] {
              0×80, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              0, 0, 0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
             };
        #endregion

        #region F, G, H and I are basic MD5 functions.
        static private uint F(uint x, uint y, uint z)
        {
            return (((x) & (y)) | ((~x) & (z)));
        }
        static private uint G(uint x, uint y, uint z)
        {
            return (((x) & (z)) | ((y) & (~z)));
        }
        static private uint H(uint x, uint y, uint z)
        {
            return ((x) ^ (y) ^ (z));
        }
        static private uint I(uint x, uint y, uint z)
        {
            return ((y) ^ ((x) | (~z)));
        }
        #endregion

        #region rotates x left n bits.
        /// <summary>
        /// rotates x left n bits.
        /// </summary>
        /// <param name=”x”></param>
        /// <param name=”n”></param>
        /// <returns></returns>
        static private uint ROTATE_LEFT(uint x, byte n)
        {
            return (((x) << (n)) | ((x) >> (32 - (n))));
        }
        #endregion

        #region FF, GG, HH, and II transformations
        /// FF, GG, HH, and II transformations 
        /// for rounds 1, 2, 3, and 4.
        /// Rotation is separate from addition to prevent recomputation.
        static private void FF(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) += F((b), (c), (d)) + (x) + (uint)(ac);
            (a) = ROTATE_LEFT((a), (s));
            (a) += (b);
        }
        static private void GG(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) += G((b), (c), (d)) + (x) + (uint)(ac);
            (a) = ROTATE_LEFT((a), (s));
            (a) += (b);
        }
        static private void HH(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) += H((b), (c), (d)) + (x) + (uint)(ac);
            (a) = ROTATE_LEFT((a), (s));
            (a) += (b);
        }
        static private void II(ref uint a, uint b, uint c, uint d, uint x, byte s, uint ac)
        {
            (a) += I((b), (c), (d)) + (x) + (uint)(ac);
            (a) = ROTATE_LEFT((a), (s));
            (a) += (b);
        }
        #endregion

        #region context info
        /// <summary>
        /// state (ABCD)
        /// </summary>
        uint[] state = new uint[4];

        /// <summary>
        /// number of bits, modulo 2^64 (lsb first)
        /// </summary>
        uint[] count = new uint[2];

        /// <summary>
        /// input buffer
        /// </summary>
        byte[] buffer = new byte[64];
        #endregion

        internal MD5()
        {
            Initialize();
        }

        /// <summary>
        /// MD5 initialization. Begins an MD5 operation, writing a new context.
        /// </summary>
        /// <remarks>
        /// The RFC named it ”MD5Init”
        /// </remarks>
        public virtual void Initialize()
        {
            count[0] = count[1] = 0;

            // Load magic initialization constants.
            state[0] = 0×67452301;
            state[1] = 0xefcdab89;
            state[2] = 0x98badcfe;
            state[3] = 0×10325476;
        }

        /// <summary>
        /// MD5 block update operation. Continues an MD5 message-digest
        /// operation, processing another message block, and updating the
        /// context.
        /// </summary>
        /// <param name=”input”></param>
        /// <param name=”offset”></param>
        /// <param name=”count”></param>
        /// <remarks>The RFC Named it MD5Update</remarks>
        protected virtual void HashCore(byte[] input, int offset, int count)
        {
            int i;
            int index;
            int partLen;

            // Compute number of bytes mod 64
            index = (int)((this.count[0] >> 3) & 0x3F);

            // Update number of bits
            if ((this.count[0] += (uint)((uint)count << 3)) < ((uint)count << 3))
                this.count[1]++;
            this.count[1] += ((uint)count >> 29);

            partLen = 64 - index;

            // Transform as many times as possible.
            if (count >= partLen)
            {
                Buffer.BlockCopy(input, offset, this.buffer, index, partLen);
                Transform(this.buffer, 0);

                for (i = partLen; i + 63 < count; i += 64)
                    Transform(input, offset + i);

                index = 0;
            }
            else
                i = 0;

            // Buffer remaining input 
            Buffer.BlockCopy(input, offset + i, this.buffer, index, count - i);
        }

        /// <summary>
        /// MD5 finalization. Ends an MD5 message-digest operation, writing the
        /// the message digest and zeroizing the context.
        /// </summary>
        /// <returns>message digest</returns>
        /// <remarks>The RFC named it MD5Final</remarks>
        protected virtual byte[] HashFinal()
        {
            byte[] digest = new byte[16];
            byte[] bits = new byte[8];
            int index, padLen;

            // Save number of bits
            Encode(bits, 0, this.count, 0, 8);

            // Pad out to 56 mod 64.
            index = (int)((uint)(this.count[0] >> 3) & 0x3f);
            padLen = (index < 56) ? (56 - index) : (120 - index);
            HashCore(PADDING, 0, padLen);

            // Append length (before padding)
            HashCore(bits, 0, 8);

            // Store state in digest 
            Encode(digest, 0, state, 0, 16);

            // Zeroize sensitive information.
            count[0] = count[1] = 0;
            state[0] = 0;
            state[1] = 0;
            state[2] = 0;
            state[3] = 0;

            // initialize again, to be ready to use
            Initialize();

            return digest;
        }

        /// <summary>
        /// MD5 basic transformation. Transforms state based on 64 bytes block.
        /// </summary>
        /// <param name=”block”></param>
        /// <param name=”offset”></param>
        private void Transform(byte[] block, int offset)
        {
            uint a = state[0], b = state[1], c = state[2], d = state[3];
            uint[] x = new uint[16];
            Decode(x, 0, block, offset, 64);

            // Round 1
            FF(ref a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
            FF(ref d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
            FF(ref c, d, a, b, x[2], S13, 0x242070db); /* 3 */
            FF(ref b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
            FF(ref a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
            FF(ref d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
            FF(ref c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
            FF(ref b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
            FF(ref a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
            FF(ref d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
            FF(ref c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
            FF(ref b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
            FF(ref a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
            FF(ref d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
            FF(ref c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
            FF(ref b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

            // Round 2
            GG(ref a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
            GG(ref d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
            GG(ref c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
            GG(ref b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
            GG(ref a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
            GG(ref d, a, b, c, x[10], S22, 0×2441453); /* 22 */
            GG(ref c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
            GG(ref b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
            GG(ref a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
            GG(ref d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
            GG(ref c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
            GG(ref b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
            GG(ref a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
            GG(ref d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
            GG(ref c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
            GG(ref b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

            // Round 3
            HH(ref a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
            HH(ref d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
            HH(ref c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
            HH(ref b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
            HH(ref a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
            HH(ref d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
            HH(ref c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
            HH(ref b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
            HH(ref a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
            HH(ref d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
            HH(ref c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
            HH(ref b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
            HH(ref a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
            HH(ref d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
            HH(ref c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
            HH(ref b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */

            // Round 4
            II(ref a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
            II(ref d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
            II(ref c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
            II(ref b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
            II(ref a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
            II(ref d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
            II(ref c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
            II(ref b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
            II(ref a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
            II(ref d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
            II(ref c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
            II(ref b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
            II(ref a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
            II(ref d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
            II(ref c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
            II(ref b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */

            state[0] += a;
            state[1] += b;
            state[2] += c;
            state[3] += d;

            // Zeroize sensitive information.
            for (int i = 0; i < x.Length; i++)
                x[i] = 0;
        }

        /// <summary>
        /// Encodes input (uint) into output (byte). Assumes len is
        ///  multiple of 4.
        /// </summary>
        /// <param name=”output”></param>
        /// <param name=”outputOffset”></param>
        /// <param name=”input”></param>
        /// <param name=”inputOffset”></param>
        /// <param name=”count”></param>
        private static void Encode(byte[] output, int outputOffset, uint[] input, int inputOffset, int count)
        {
            int i, j;
            int end = outputOffset + count;
            for (i = inputOffset, j = outputOffset; j < end; i++, j += 4)
            {
                output[j] = (byte)(input[i] & 0xff);
                output[j + 1] = (byte)((input[i] >> 8) & 0xff);
                output[j + 2] = (byte)((input[i] >> 16) & 0xff);
                output[j + 3] = (byte)((input[i] >> 24) & 0xff);
            }
        }

        /// <summary>
        /// Decodes input (byte) into output (uint). Assumes len is
        /// a multiple of 4.
        /// </summary>
        /// <param name=”output”></param>
        /// <param name=”outputOffset”></param>
        /// <param name=”input”></param>
        /// <param name=”inputOffset”></param>
        /// <param name=”count”></param>
        static private void Decode(uint[] output, int outputOffset, byte[] input, int inputOffset, int count)
        {
            int i, j;
            int end = inputOffset + count;
            for (i = outputOffset, j = inputOffset; j < end; i++, j += 4)
                output[i] = ((uint)input[j]) | (((uint)input[j + 1]) << 8) | (((uint)input[j + 2]) << 16) | (((uint)input[j + 3]) <<
24);
        }
        #endregion

        #region expose the same interface as the regular MD5 object

        protected byte[] HashValue;
        protected int State;
        public virtual bool CanReuseTransform
        {
            get
            {
                return true;
            }
        }

        public virtual bool CanTransformMultipleBlocks
        {
            get
            {
                return true;
            }
        }
        public virtual byte[] Hash
        {
            get
            {
                if (this.State != 0)
                    throw new InvalidOperationException();
                return (byte[])HashValue.Clone();
            }
        }
        public virtual int HashSize
        {
            get
            {
                return HashSizeValue;
            }
        }
        protected int HashSizeValue = 128;

        public virtual int InputBlockSize
        {
            get
            {
                return 1;
            }
        }
        public virtual int OutputBlockSize
        {
            get
            {
                return 1;
            }
        }

        public void Clear()
        {
            Dispose(true);
        }

        public byte[] ComputeHash(byte[] buffer)
        {
            return ComputeHash(buffer, 0, buffer.Length);
        }
        public byte[] ComputeHash(byte[] buffer, int offset, int count)
        {
            Initialize();
            HashCore(buffer, offset, count);
            HashValue = HashFinal();
            return (byte[])HashValue.Clone();
        }

        public byte[] ComputeHash(Stream inputStream)
        {
            Initialize();
            int count = 0;
            byte[] buffer = new byte[4096];
            while (0 < (count = inputStream.Read(buffer, 0, 4096)))
            {
                HashCore(buffer, 0, count);
            }
            HashValue = HashFinal();
            return (byte[])HashValue.Clone();
        }

        public int TransformBlock(
            byte[] inputBuffer,
            int inputOffset,
            int inputCount,
            byte[] outputBuffer,
            int outputOffset
            )
        {
            if (inputBuffer == null)
            {
                throw new ArgumentNullException(“inputBuffer”);
            }
            if (inputOffset < 0)
            {
                throw new ArgumentOutOfRangeException(“inputOffset”);
            }
            if ((inputCount < 0) || (inputCount > inputBuffer.Length))
            {
                throw new ArgumentException(“inputCount”);
            }
            if ((inputBuffer.Length - inputCount) < inputOffset)
            {
                throw new ArgumentOutOfRangeException(“inputOffset”);
            }
            if (this.State == 0)
            {
                Initialize();
                this.State = 1;
            }

            HashCore(inputBuffer, inputOffset, inputCount);
            if ((inputBuffer != outputBuffer) || (inputOffset != outputOffset))
            {
                Buffer.BlockCopy(inputBuffer, inputOffset, outputBuffer, outputOffset, inputCount);
            }
            return inputCount;
        }
        public byte[] TransformFinalBlock(
            byte[] inputBuffer,
            int inputOffset,
            int inputCount
            )
        {
            if (inputBuffer == null)
            {
                throw new ArgumentNullException(“inputBuffer”);
            }
            if (inputOffset < 0)
            {
                throw new ArgumentOutOfRangeException(“inputOffset”);
            }
            if ((inputCount < 0) || (inputCount > inputBuffer.Length))
            {
                throw new ArgumentException(“inputCount”);
            }
            if ((inputBuffer.Length - inputCount) < inputOffset)
            {
                throw new ArgumentOutOfRangeException(“inputOffset”);
            }
            if (this.State == 0)
            {
                Initialize();
            }
            HashCore(inputBuffer, inputOffset, inputCount);
            HashValue = HashFinal();
            byte[] buffer = new byte[inputCount];
            Buffer.BlockCopy(inputBuffer, inputOffset, buffer, 0, inputCount);
            this.State = 0;
            return buffer;
        }
        #endregion

        protected virtual void Dispose(bool disposing)
        {
            if (!disposing)
                Initialize();
        }
        public void Dispose()
        {
            Dispose(true);
        }
    }

　　在Silverlight中使用MD5的示例代码

代码

 Program
    {
        static void Main(string[] args)
        {
            string str=“123″;
            Console.WriteLine(string.Format (“123 encrypt result: {0}”,WebMD5Provider.WebFormMD5Encrypt (str )));
            Console.WriteLine(“———————”);
            MD5CryptoServiceProvider md5Provider = new MD5CryptoServiceProvider();
            byte[] encryptedBytes = md5Provider.ComputeHash(Encoding.UTF8 .GetBytes(str ));
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < encryptedBytes.Length; i++)
            {
                sb.AppendFormat(“{0:x2}”, encryptedBytes[i]);
            }
         
            Console.WriteLine(string.Format(“123 encrypt result: {0}”,sb.ToString ()));

            Console.ReadLine();
        }
    }

　　 byte[] encryptedBytes = md5Provider.ComputeHash(Encoding.UTF8 .GetBytes(str ));中必须使用UTF8，如果使用Unicode就会和System.Security下面提供的方法产生的哈希结果不一致，这里需要注意。

C#的加密解密算法，包括Silverlight的MD5算法,encrypt,silveright

Related posts:

1. app.config-c#读写类
2. ASP.NET加密Cookies
3. Silverlight中RSA算法的实现

在银光中国网有篇“轻松建立Silverlight开发环境”，该文详细介绍了Silverlight工具集下载，以及安装步骤。我简要列出，另外做一些补充：

工具一： Visual Studio 2008 SP1 或者 Visual Studio 2010 或者 Visual Web Developer Express 2008 With SP1；

Visual Studio是Silverlight的开发必需工具，其中VS2008 SP1和Visual Web Developer Express With SP1仅支持Silverlight 3的开发，而VS2010支持Silverlight 3和Silverlight 4项目开发。在安装Visual Studio的同时，.Net Framework 3.5 SP1也将同时安装，如果没有安装，需要独立下载安装。 Silverlight 4项目开发，必须有.Net Framework 4.0支持。

工具二： Silverlight开发工具包

Silverlight开发工具包中包含各种Silverlight开发模板，安装完成后，可以在Visual Studio中创建Silverlight项目。对应下载地址 Silverlight 2 Tools for Visual Studio 2008 SP1 和 Silverlight 3 Tools for Visual Studio 2008 SP1， Silverlight 4 Tools for Visual Studio 2010 Beta 2。

工具三： Silverlight SDK
 

作为专业开发人员，自然离不开Software Development Kit（SDK）支持，Silverlight同样也推出了对应的SDK包，其中包含在线开发文档，在线Silverlight例程，开发类库等。Silverlight 3 SDK 和 Silvelright 4 SDK。

工具四： Expression Blend 3 + SketchFlow  - Silverlight设计工具

 

自Silverlight 3发布后，Visual Studio 2008 SP1已经不再支持Silverlight开发视图界面, 该功能被Expression Blend 3替代，众所周知，Microsoft Expression是微软2009年主打的一套设计软件，其中包括视频处理，网页设计，WPF/Silverlight UI以及动画设计等工具集合，Blend是其中一员，主要从事WPF/Silverlight UI设计，动画制作，以及软件原型设计等。

在Visual Studio 2010的试用中，我们可以发现，VS2010已经恢复了对Silverlight开发的视图界面功能，这对开发人员来说，无疑是一个好消息。

工具五： Silverlight Toolkit – Silverlight控件开发包

Silverlight控件开发包提供数十种Silverlight常用控件，在Silverlight项目开发过程中，可以很方便的进行调用。该项目开发包属于开源项目，开发人员可以到项目网站进行下载最新源代码，并且可以根据项目需求自行修改。

工具六： Silverlight客户端

以上Silverlight开发工具安装完成后，需要确认安装Silverlight客户端，当前微软推出了两款Silverlight客户端，分别运行在Windows系统和Mac系统。 相对来说，该工具包安装是最简单的，进行官方网站选择相关版本下载安装即可。

【备注】微软官方推荐使用 Web Platform Installer 安装Silverlight开发环境，该平台包括以上所有的安装包。

 

Silverlight辅助开发工具包：

工具一：Deep Zoom Composer – 放大镜功能包

在Silverlight发布的初期，Deep Zoom Composer是一大亮点，该功能允许用户在Silverlight应用中查看高分辨率图片，其中平滑的扩大以及缩小的动画效果，吸引了不少用户。

工具二：.Net RIA Services

随着RIA技术的发展，微软也推出了对应的解决方案，.Net RIA Service，该工具扩展了Silverlight功能，沿用了传统的n-Tier应用模型概念，允许开发人员创建n层Silverlight应用。虽然该项目也属于Silverlight开发中重点之一，但是由于该项目一直属于测试版，作为商业项目不推荐使用，所以，我没有把该工具放入必须安装的列表中。

工具三：.Net Reflector

相信大家都很熟悉这个工具了，该工具主要是.Net代码的反编译，在反编译Silverlight项目中有着很大的作用。这里就不再赘述。

工具四：Silverlight SPY

 

Silverlight SPY是一款Silverlight项目侦测工具，该工具探测XAP包，查看应用风格，分解查看应用界面，和Reflector配合可以查看项目资源，以及项目源代码，是一款很不错的工具,详细中文介绍请看这里。

工具五：Fiddler / FireBug

 

 

作为Web开发人员，对这两款工具并不陌生，该工具主要用于监测HTTP网络信息，手工Debug应用。在Silverlight + WCF项目开发中，这是必不可少的辅助调试工具。

工具六：KaXaml

KaXaml是一款开源的轻量级XAML编辑器，该项目支持视窗编辑，支持高亮语法支持。该项目是开源项目，详细中文介绍请看这里。

工具七：XAML Power Toys

 

该工具是一款Visual Studio插件辅助工具，用于编辑XAML文档，包含多种代码模板，简化开发人员输入代码过程，是一款很不错的辅助工具。该工具同时支持WPF/Silverlight开发。

工具八：Rooler

 

Rooler是一款图形侦测工具，在Web项目开发中经常用到，用于侦测Web图片尺寸，可以用来辅助设计Silverlight UI。

工具九：Silverlight Profiler

 

该工具是Silverlight应用优化工具，提高项目运行效率，试用过几次，感觉对于大型项目，效果还是比较明显的。

Related posts:

1. Microsoft.VisualStudio.Xaml 加载错误
2. 轻松建立Silverlight开发环境
3. wpf(2)

在2003中这个进度条的样子就会变得非常难看。

在wpf中您可以自己制作任意样式的进度条。如下图：

UserControl.xaml

用户控件

    <Grid x:Name="LayoutRoot" Background="Transparent"
              HorizontalAlignment="Center" VerticalAlignment="Center">

        <Grid.RenderTransform>

            <ScaleTransform x:Name="SpinnerScale"
                                ScaleX="1.0" ScaleY="1.0" />

        </Grid.RenderTransform>

        <Canvas RenderTransformOrigin="0.5,0.5"
                    HorizontalAlignment="Center"
                    VerticalAlignment="Center"
                    Width="120" Height="120" >

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="20.1696"
                         Canvas.Top="9.76358"
                         Stretch="Fill" Fill="Orange"
                         Opacity="1.0"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="2.86816"
                         Canvas.Top="29.9581" Stretch="Fill"
                         Fill="Black" Opacity="0.9"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="5.03758e-006"
                         Canvas.Top="57.9341" Stretch="Fill"
                         Fill="Black" Opacity="0.8"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="12.1203"
                         Canvas.Top="83.3163" Stretch="Fill"
                         Fill="Black" Opacity="0.7"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="36.5459"
                         Canvas.Top="98.138" Stretch="Fill"
                         Fill="Black" Opacity="0.6"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="64.6723"
                         Canvas.Top="96.8411" Stretch="Fill"
                         Fill="Black" Opacity="0.5"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="87.6176"
                         Canvas.Top="81.2783" Stretch="Fill"
                         Fill="Black" Opacity="0.4"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="98.165"
                         Canvas.Top="54.414" Stretch="Fill"
                         Fill="Black" Opacity="0.3"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="92.9838"
                         Canvas.Top="26.9938" Stretch="Fill"
                         Fill="Black" Opacity="0.2"/>

            <Ellipse Width="21.835" Height="21.862"
                         Canvas.Left="47.2783"
                         Canvas.Top="0.5" Stretch="Fill"
                         Fill="Black" Opacity="0.1"/>

            <Canvas.RenderTransform>

                <RotateTransform x:Name="SpinnerRotate"
                                     Angle="0" />

            </Canvas.RenderTransform>

            <Canvas.Triggers>

                <EventTrigger RoutedEvent="ContentControl.Loaded">

                    <BeginStoryboard>

                        <Storyboard>

                            <DoubleAnimation
                                    Storyboard.TargetName
                                        ="SpinnerRotate"
                                     Storyboard.TargetProperty
                                        ="(RotateTransform.Angle)"
                                     From="0" To="360"
                                     Duration="0:0:01"
                                     RepeatBehavior="Forever" />

                        </Storyboard>

                    </BeginStoryboard>

                </EventTrigger>

            </Canvas.Triggers>

        </Canvas>

    </Grid>

UserControl.xaml.cs

后台代码

        public UserControl1()
        {
            InitializeComponent();

            Timeline.DesiredFrameRateProperty.OverrideMetadata(
                       typeof(Timeline),
                           new FrameworkPropertyMetadata { DefaultValue = 20 });
        }

程序中添加对此用户控件的命名空间

    <Grid>
        <local:UserControl1></local:UserControl1>
    </Grid>

Related posts:

1. wpf初体验
2. 跟老外学Silverlight游戏 之一 新建项目
3. 什么是WPF

  到目前Silverlight4 Beta发布为止，Silverlight中仍然没有提供非对称加密及数字签名相关的算法。而.NET Framework中提供的RSA等算法，都是通过操作系统提供的相关API实现的，没法移植到Silverlight中使用。因此很难实现一个健壮点的Silverlight纯客户端的注册验证算法。这几天抽空写了个Silverlight下可用的RSA算法，使用非对称加密和数字签名使Silverlight纯客户端的注册验证算法健壮了不少。关于这个Silverlight下可用的RSA算法的具体实现，记录在下面，欢迎大家拍砖。

RSA算法实现主要分为三部分：包括公钥和私钥的产生，非对称加密和解密，数字签名和验证，下面将逐个介绍RSA算法的工作原理及我的实现方法。

  1，公钥和私钥的产生

    随意选择两个大素数p、q，p不等于q，计算n = p * q。
    随机选择一个整数e，满足e和( p – 1 ) * ( q – 1 )互质。(注：e很容易选择，如3, 17, 65537等都可以。.NET Framework中e默认选择的就是65537)
利用Euclid算法计算解密密钥d,满足
      e * d ≡ 1 ( mod ( p – 1 ) * ( q – 1 ) )
    其中n和d也要互质。

    其中e和n就是公钥，d和n就是私钥。P、q销毁。

在.NET Framework的RSA算法中，e对应RSAParameters.Exponent；d对应RSAParameters.D；n对应RSAParameters.ModulusExponent。.NET Framework中的RSA算法默认使用1024位长的密钥。公钥和私钥是利用.NET Framework的RSACryptoServiceProvider生成公钥xml文件和私钥xml文件来实现的。生成公钥和私钥xml文件的程序本身不是Silverlight程序。

RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();//生成公钥XML字符串
    string publicKeyXmlString = rsa.ToXmlString(false);//生成私钥XML字符串
    string privateKeyXmlString = rsa.ToXmlString(true);

公钥和私钥将从生成的公钥xml文件和私钥xml文件中导入。

public class RSAPublicKey
    {
        public byte[] Modulus;
        public byte[] Exponent;public static RSAPublicKey FromXmlString(string xmlString)
        {
            if (string.IsNullOrEmpty(xmlString))
            {
                return null;
            }try
            {
                using (XmlReader reader = XmlReader.Create(new StringReader(xmlString)))
                {
                    if (!reader.ReadToFollowing(“RSAKeyValue“))
                    {
                        return null;
                    }if (reader.LocalName != “Modulus“ && !reader.ReadToFollowing(“Modulus“))
                    {
                        return null;
                    }
                    string modulus = reader.ReadElementContentAsString();if (reader.LocalName != “Exponent“ && !reader.ReadToFollowing(“Exponent“))
                    {
                        return null;
                    }
                    string exponent = reader.ReadElementContentAsString();= new RSAPublicKey();
                    publicKey.Modulus = Convert.FromBase64String(modulus);
                    publicKey.Exponent = Convert.FromBase64String(exponent);return publicKey;
                }
            }
            catch
            {
                return null;
            }
        }        
    }

                    RSAPublicKey publicKey 

public class RSAPrivateKey
    {
        public byte[] Modulus;
        public byte[] D;public static RSAPrivateKey FromXmlString(string xmlString)
        {
            if (string.IsNullOrEmpty(xmlString))
            {
                return null;
            }try
            {
                using (XmlReader reader = XmlReader.Create(new StringReader(xmlString)))
                {
                    if (!reader.ReadToFollowing(“RSAKeyValue“))
                    {
                        return null;
                    }if (reader.LocalName != “Modulus“ && !reader.ReadToFollowing(“Modulus“))
                    {
                        return null;
                    }
                    string modulus = reader.ReadElementContentAsString();if (reader.LocalName != “D“ && !reader.ReadToFollowing(“D“))
                    {
                        return null;
                    }
                    string d = reader.ReadElementContentAsString();= new RSAPrivateKey();
                    privateKey.Modulus = Convert.FromBase64String(modulus);
                    privateKey.D = Convert.FromBase64String(d);return privateKey;
                }
            }
            catch
            {
                return null;
            }
        }        
    }

                    RSAPrivateKey privateKey 

2，非对称加密和解密
    私钥加密m（二进制表示）时，首先把m分成长s的数据块 m1, m2 … mi，其中 2^s <= n, s 尽可能的大。执行如下计算：
        ci = mi ^ d (mod n)
    公钥解密c（二进制表示）时，也需要将c分成长s的数据块c1, c2 … ci，执行如下计算：
        mi = ci ^ e (mod n)

    在某些情况下，也会使用公钥加密->私钥解密。原理和私钥加密->公钥解密一样。下面是私钥计算和公钥计算的算法。其中利用到了Chew Keong TAN的BigInteger类。.NET Framework 4中提供的BigInteger.ModPow方法好像有问题。 

private static byte[] Compute(byte[] data, RSAPublicKey publicKey, int blockSize)
        {
            //
            // 公钥加密/解密公式为：ci = mi^e ( mod n )            
            // 
            // 先将 m（二进制表示）分成数据块 m1, m2, …, mi ，然后进行运算。
            //
            BigInteger e = new BigInteger(publicKey.Exponent);
            BigInteger n = new BigInteger(publicKey.Modulus);int blockOffset = 0;
            using (MemoryStream stream = new MemoryStream())
            {
                while (blockOffset < data.Length)
                {
                    int blockLen = Math.Min(blockSize, data.Length - blockOffset);
                    byte[] blockData = new byte[blockLen];
                    Buffer.BlockCopy(data, blockOffset, blockData, 0, blockLen);= new BigInteger(blockData);
                    BigInteger ci = mi.modPow(e, n);//ci = mi^e ( mod n )

                    byte[] block = ci.getBytes();
                    stream.Write(block, 0, block.Length);
                    blockOffset += blockLen;
                }return stream.ToArray();
            }
        }private static byte[] Compute(byte[] data, RSAPrivateKey privateKey, int blockSize)
        {
            //
            // 私钥加密/解密公式为：mi = ci^d ( mod n )
            // 
            // 先将 c（二进制表示）分成数据块 c1, c2, …, ci ，然后进行运算。            
            //
            BigInteger d = new BigInteger(privateKey.D);
            BigInteger n = new BigInteger(privateKey.Modulus);int blockOffset = 0;using (MemoryStream stream = new MemoryStream())
            {
                while (blockOffset < data.Length)
                {
                    int blockLen = Math.Min(blockSize, data.Length - blockOffset);
                    byte[] blockData = new byte[blockLen];
                    Buffer.BlockCopy(data, blockOffset, blockData, 0, blockLen);= new BigInteger(blockData);
                    BigInteger mi = ci.modPow(d, n);//mi = ci^d ( mod n )

                    byte[] block = mi.getBytes();
                    stream.Write(block, 0, block.Length);
                    blockOffset += blockLen;
                }return stream.ToArray();
            }
        }

                    BigInteger mi 

                    BigInteger ci 

下面是私钥加密->公钥解密的实现。

public static byte[] Encrypt(byte[] data, RSAPublicKey publicKey)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (publicKey == null)
            {
                throw new ArgumentNullException(“publicKey“);
            }int blockSize = publicKey.Modulus.Length - 1;
            return Compute(data, publicKey, blockSize);
        }public static byte[] Decrypt(byte[] data, RSAPrivateKey privateKey)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (privateKey == null)
            {
                throw new ArgumentNullException(“privateKey“);
            }int blockSize = privateKey.Modulus.Length;
            return Compute(data, privateKey, blockSize);
        }

下面是公钥加密->私钥解密的实现。

public static byte[] Encrypt(byte[] data, RSAPrivateKey privateKey)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (privateKey == null)
            {
                throw new ArgumentNullException(“privateKey“);
            }int blockSize = privateKey.Modulus.Length - 1;
            return Compute(data, privateKey, blockSize);
        }public static byte[] Decrypt(byte[] data, RSAPublicKey publicKey)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (publicKey == null)
            {
                throw new ArgumentNullException(“publicKey“);
            }int blockSize = publicKey.Modulus.Length;
            return Compute(data, publicKey, blockSize);
        }

    3，数字签名和验证
    私钥签名数据m时，先对m进行hash计算，得到计算结果h。然后将h使用私钥加密，得到加密后的密文s即为签名。
    公钥验证签名s时，先将m进行hash计算，得到计算结果h。然后使用公钥解密s得到结果h’。如果h==h’即验证成功，否则验证失败。

    在某些情况下，也会使用公钥签名->私钥验证。原理和私钥签名->公钥验证一样。

    下面是私钥签名->公钥验证的实现。 

public static byte[] Sign(byte[] data, RSAPublicKey publicKey, HashAlgorithm hash)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (publicKey == null)
            {
                throw new ArgumentNullException(“publicKey“);
            }if (hash == null)
            {
                throw new ArgumentNullException(“hash“);
            }byte[] hashData = hash.ComputeHash(data);
            byte[] signature = Encrypt(hashData, publicKey);
            return signature;
        }public static bool Verify(byte[] data, RSAPrivateKey privateKey, HashAlgorithm hash, byte[] signature)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (privateKey == null)
            {
                throw new ArgumentNullException(“privateKey“);
            }if (hash == null)
            {
                throw new ArgumentNullException(“hash“);
            }if (signature == null)
            {
                throw new ArgumentNullException(“signature“);
            }byte[] hashData = hash.ComputeHash(data);
            byte[] signatureHashData = Decrypt(signature, privateKey);if (signatureHashData != null && signatureHashData.Length == hashData.Length)
            {
                for (int i = 0; i < signatureHashData.Length; i++)
                {
                    if (signatureHashData[i] != hashData[i])
                    {
                        return false;
                    }
                }
                return true;
            }return false;
        }

下面是公钥签名->私钥验证的实现。

public static byte[] Sign(byte[] data, RSAPrivateKey privateKey, HashAlgorithm hash)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (privateKey == null)
            {
                throw new ArgumentNullException(“privateKey“);
            }if (hash == null)
            {
                throw new ArgumentNullException(“hash“);
            }byte[] hashData = hash.ComputeHash(data);
            byte[] signature = Encrypt(hashData, privateKey);
            return signature;
        }public static bool Verify(byte[] data, RSAPublicKey publicKey, HashAlgorithm hash, byte[] signature)
        {
            if (data == null)
            {
                throw new ArgumentNullException(“data“);
            }if (publicKey == null)
            {
                throw new ArgumentNullException(“publicKey“);
            }if (hash == null)
            {
                throw new ArgumentNullException(“hash“);
            }if (signature == null)
            {
                throw new ArgumentNullException(“signature“);
            }byte[] hashData = hash.ComputeHash(data);byte[] signatureHashData = Decrypt(signature, publicKey);if (signatureHashData != null && signatureHashData.Length == hashData.Length)
            {
                for (int i = 0; i < signatureHashData.Length; i++)
                {
                    if (signatureHashData[i] != hashData[i])
                    {
                        return false;
                    }
                }
                return true;
            }return false;
        }

本文基于署名 2.5 中国大陆许可协议发布，欢迎转载，演绎或用于商业目的，但是必须保留本文的署名KevinShan（包含链接）。如您有任何疑问或者授权方面的协商，请给我留言。

源代码下载：

 RSAManaged.zip

Related posts:

1. C# java php的RSA
2. C#的加密解密算法，包括Silverlight的MD5算法
3. DES加密解密函数 收藏 c#

       前几篇一直在Blend中工作没体现出开发者的作用，本篇将为订书器（Stapler）添加自定义粒子效果，当订书器被点击时产生更好的视觉效果。其中将使用到nerdplusart 的Silverlight Particle Generator 粒子特效工具。

在结束本章内容后，点击Stapler 和Candies 将达到以下效果：

1. 在Projects面板中新增Interactivity 文件夹，再为Interactivity 新增ParticlesBehavior 子文件夹：

2. 右键ParticlesBehavior文件夹->Add New Item->Behavior，添加ParticlesBehavior：

3. 下载Silverlight Particle Generator 源代码，将代码中的ParticleControl.xaml 和ParticleControl.xaml.cs 文件加入（Add Existing Item）到ParticlesBehavior 文件夹：

4. 右键项目点击“Edit in Visual Studio”，对PaticlesBehavior.cs进行编辑来跟踪鼠标移动位置。将ParticlesBehavior 类声明改为Behavior<Canvas>，通过修改后AssociatedObject 类型将成为Canvas。在OnAttached 和OnDetaching 方法中分别添加和删除MouseMove 事件，当鼠标移动时便可记录下当前鼠标位置：

public class ParticlesBehavior : Behavior<Canvas>
{
   private Point currentMousePosition;

   public ParticlesBehavior()
   {
      this.ShowParticles = new ActionCommand(this.OnShowParticles);
   }

   protected override void OnAttached()
   {
      base.OnAttached();
      AssociatedObject.MouseMove += new MouseEventHandler(AssociatedObject_MouseMove);
   }

   protected override void OnDetaching()
   {
      base.OnDetaching();
      AssociatedObject.MouseMove -= new MouseEventHandler(AssociatedObject_MouseMove);
   }

   void AssociatedObject_MouseMove(object sender, MouseEventArgs e)
   {
      currentMousePosition = e.GetPosition(null);
   }

   public ICommand ShowParticles
   {
      get;
      private set;
   }

   private void OnShowParticles()
   {
      ParticleControl p = new ParticleControl();
      p.OffsetX = currentMousePosition.X;
      p.OffsetY = currentMousePosition.Y;
      AssociatedObject.Children.Add(p);
   }
}

5. VS里编译后回到Blend，在Assets->Behavior 中将会看到ParticlesBehavior 选项，将ParticlesBehavior 加入LayoutRoot中：

点击Triggers右侧的“+”按钮添加新EventTrigger；点击EventTrigger将SourceName设为staplerPath，EventName设为MouseLeftButtonDown；再次点击“+”为可为其他物品添加ParticlesBehavior特效。另，在ParticlesBehavior.cs中增加一些代码，便可出现下图中Particles Properties设置窗口（详情可下载源代码）：

6. 在Blend中F5，点击图片中的订书器（Stapler）便会出现粒子效果（但其不会自动消失），再点击Candies也会出现粒子效果，问题是所有的粒子效果仍然不能消失。打开ParticleControl.xaml.cs 进行编辑： 
    a. 在ParticleControl 类中定义int 型totalParticlesCreated
    b. 将this.particles.Count 替换为totalParticlesCreated 
    c. 在SpawnParticle方法最后添加totalParticlesCreated++
至此粒子效果就会自动消失了。

7. 最后为staplerPath添加RemoveElementAction，目的是为了每个物品只能点击一次：

将SourceName 和TargetName 都设置为staplerPath，EventName依然为MouseLeftButtonDown：

源代码下载：http://cid-c75f4e27adfe5bbc.skydrive.live.com/self.aspx/GnieTech/FindObject4.zip

 作者: Gnie
 出处: {GnieTech} (http://www.cnblogs.com/gnielee/)
 版权声明: 本文的版权归作者与博客园共有。转载时须注明本文的详细链接，否则作者将保留追究其法律责任。

Related posts:

1. SLIVERLIGHT播放器控件
2. 跟老外学Silverlight游戏 之三 消除名单
3. 跟老外学Silverlight游戏 之一 新建项目

       本篇将通过钢笔（Pen）工具为Office图片中的物品添加热点，当玩家找到图中物品时，通过ChangePropertyAction调整题板上的物品名称的不透明度（Opacity）。下文以订书器（Stapler）为例进行讲解。

先上个最终效果演示，点击图片中的“订书器”：

1. 滚动鼠标中键放大Office图片，用钢笔工具   在订书器（Stapler）上勾勒出一个区域，为了方便调整区域尺寸可调低Path的不透明度，区域尺寸完成后将Opacity改为0%（即该Path为不可见）：

2. 将Path->Name设为staplerPath，在TreeView中单击刚创建的staplerPath，在Assets中选择Behaviors为staplerPath添加ChangePropertyAction属性：

3. 进入ChangePropertyAction属性设置菜单，在TargetName处选择staplerText，将PropertyName设置为Opacity，Value设为40%：

4. 如果感觉设置不透明度效果仍然不够好，那么还可以为staplerPath添加PlaySoundAction属性（需要将magic_wand.mp3加入项目的Audio文件夹中）：

源代码下载（最好使用Blend 3）：http://cid-c75f4e27adfe5bbc.skydrive.live.com/self.aspx/GnieTech/FindObject3.zip

 作者: Gnie
 出处: {GnieTech} (http://www.cnblogs.com/gnielee/)
 版权声明: 本文的版权归作者与博客园共有。转载时须注明本文的详细链接，否则作者将保留追究其法律责任。

Related posts:

1. 跟老外学Silverlight游戏 之四 粒子特效
2. 跟老外学Silverlight游戏 之一 新建项目
3. 跟老外学Silverlight游戏 之二 创建题板

 作者: Gnie
 出处: {GnieTech} (http://www.cnblogs.com/gnielee/)
 版权声明: 本文的版权归作者与博客园共有。转载时须注明本文的详细链接，否则作者将保留追究其法律责任。

Related posts:

1. 跟老外学Silverlight游戏 之三 消除名单
2. 跟老外学Silverlight游戏 之二 创建题板
3. 跟老外学Silverlight游戏 之四 粒子特效

Silverlight版QQ初体验 2010年的第一天，腾讯发布了研发已久的 Silverlight QQ，超炫的界面让人喜欢，希望腾讯能一直以技术为路线，以用户体验为中心做好所有的产品。下面我带着大家一起来看看Silverlight QQ。 首先需要安装微软的Silverlight ，因为这个是基于Silverlight 的。安装好以后就出现Silverlight QQ的登陆界面

 是不是很好看啊。由于目前还在测试阶段，所以同时只能5000人在线登陆，如果你在体验的时候登陆不上，多登陆几次可能就成功了。 下面的是登陆界面：

个人感觉背景再多一些东西就好看多了。 登陆后有2种模式选择，我就选择的推荐模式了。另外一个模式没测。 这个界面是不是很好看啊。 图标也挺不错的！ 聊天窗口偶就不贴图了，不然QQ号都漏出去了！ 这个东西确实不错，哈哈，大家也去体验吧！

体验地址：http://slqq.qq.com/

Related posts:

1. 轻松建立Silverlight开发环境