构建一个.net的干货类库，以便于快速的开发 - 验证码

　　一个验证码对于一个网站的作用不言而喻，而随着技术的发展验证码的种类也开始多了起来，发展至今很多网站已经不再使用一种验证码，为满足需求程序猿就要写很多的方法来适应需求，今天我就来介绍我之前收集到的验证码的方法写成的一个帮助类，来解决我们日常开发当中的验证码需求问题。

　　帮助类中验证码是以byte[]的格式返回的，方便使用。

　　英文字符验证码

　　

  /// <summary>
         /// 英文字符验证码
         /// </summary>
         /// <param name="Code">传出验证码</param>
         /// <param name="CodeLength">验证码字符</param>
         /// <returns></returns>
         public static byte[] GraphCode(out string Code,int CodeLength)
         {
             int Width = ;//默认为100
             int Height = ;//默认为40
             int FontSize = ;//默认为20
             byte[] bytes = GraphCode(out Code, CodeLength, Width, Height, FontSize);
             return bytes;
         }
 
         /// <summary>
         /// 产生图形验证码。
         /// </summary>
         /// <param name="Code">传出验证码。</param>
         /// <param name="CodeLength">验证码字符。</param>
         /// <param name="Width"></param>
         /// <param name="Height"></param>
         /// <param name="FontSize"></param>
         /// <returns></returns>
         public static byte[] GraphCode(out string Code, int CodeLength, int Width, int Height, int FontSize)
         {
             string code = string.Empty;
             String sCode = String.Empty;
             //顏色列表，用于验证码、噪线、噪点
              Color[] oColors ={
              Color.Black,
              Color.Red,
              Color.Blue,
              Color.Green,
              Color.Orange,
              Color.Brown,
              Color.Brown,
              Color.DarkBlue
             };
             //字体列表，用于验证码
             string[] oFontNames = { "Times New Roman", "MS Mincho", "Book Antiqua", "Gungsuh", "PMingLiU", "Impact" };
             //验证码的字元集
             char[] oCharacter =
             {
                 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
                 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'
             };
             Random oRnd = new Random();
             Bitmap oBmp = null;
             Graphics oGraphics = null;
             int N1 = ;
             //生成验证码字串
             for (N1 = ; N1 <= CodeLength - ; N1++)
             {
                 sCode += oCharacter[oRnd.Next(oCharacter.Length)];
             }
             oBmp = new Bitmap(Width, Height);
             oGraphics = Graphics.FromImage(oBmp);
             oGraphics.Clear(Color.White);
             try
             {
                 oGraphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
                 Font f = new System.Drawing.Font("宋体", FontSize, (System.Drawing.FontStyle.Bold));
                 // 前景色
                 Brush b = new System.Drawing.SolidBrush(Color.Black);
                 // 背景色
                 oGraphics.Clear(Color.White);
                 // 填充文字
                 for (int i = ; i < sCode.Length; i++)
                 {
                     oGraphics.DrawString(sCode[i].ToString(), f, b, new Rectangle(i * (FontSize - ), , (FontSize - ), Height));
                 }
                 // 随机线条
                 Pen linePen = new Pen(Color.Gray, );
                 Random rand = new Random();
                 for (int i = ; i < ; i++)
                 {
                     int x1 = rand.Next(oBmp.Width);
                     int y1 = rand.Next(oBmp.Height);
                     int x2 = rand.Next(oBmp.Width);
                     int y2 = rand.Next(oBmp.Height);
                     oGraphics.DrawLine(linePen, x1, y1, x2, y2);
                 }
 
                 // 随机点
                 for (int i = ; i < ; i++)
                 {
                     int x = rand.Next(oBmp.Width);
                     int y = rand.Next(oBmp.Height);
                     oBmp.SetPixel(x, y, Color.FromArgb(rand.Next(), rand.Next(), rand.Next()));
                 }
 
                 Code = sCode;
                 //保存图片数据
                 MemoryStream stream = new MemoryStream();
                 oBmp.Save(stream, ImageFormat.Jpeg);
                 //输出图片流
                 return stream.ToArray();
             }
             finally
             {
                 oGraphics.Dispose();
             }
         }

验证码中的字元集是可以改变的，可以去掉一些容易混淆的字元，我这里使用了全部的字元

　　数字字符验证码

  /// <summary>
         /// 纯数字图形验证码
         /// </summary>
         /// <param name="Code">传出验证码</param>
         /// <param name="CodeLength">验证码字符</param>
         /// <returns></returns>
         public static byte[] NumCode(out string Code, int CodeLength)
         {
             Code = CreateValidateCode(CodeLength);
             byte[] bytes = CreateValidateGraphic(Code);
             return bytes;
         }
         /// <summary>
         /// 生成验证码
         /// </summary>
         /// <param name="CodeLength">指定验证码的长度</param>
         /// <returns></returns>
         private static string CreateValidateCode(int CodeLength)
         {
             int[] randMembers = new int[CodeLength];
             int[] validateNums = new int[CodeLength];
             string validateNumberStr = "";
             //生成起始序列值
             int seekSeek = unchecked((int)DateTime.Now.Ticks);
             Random seekRand = new Random(seekSeek);
             int beginSeek = (int)seekRand.Next(, Int32.MaxValue - CodeLength * );
             int[] seeks = new int[CodeLength];
             for (int i = ; i < CodeLength; i++)
             {
                 beginSeek += ;
                 seeks[i] = beginSeek;
             }
             //生成随机数字
             for (int i = ; i < CodeLength; i++)
             {
                 Random rand = new Random(seeks[i]);
                 int pownum =  * (int)Math.Pow(, CodeLength);
                 randMembers[i] = rand.Next(pownum, Int32.MaxValue);
             }
             //抽取随机数字
             for (int i = ; i < CodeLength; i++)
             {
                 string numStr = randMembers[i].ToString();
                 int numCodeLength = numStr.Length;
                 Random rand = new Random();
                 int numPosition = rand.Next(, numCodeLength - );
                 validateNums[i] = Int32.Parse(numStr.Substring(numPosition, ));
             }
             //生成验证码
             for (int i = ; i < CodeLength; i++)
             {
                 validateNumberStr += validateNums[i].ToString();
             }
             return validateNumberStr;
         }
 
         /// <summary>
         /// 创建验证码的图片
         /// </summary>
         /// <param name="validateCode">验证码</param>
         private static byte[] CreateValidateGraphic(string validateCode)
         {
             Bitmap image = new Bitmap((int)Math.Ceiling(validateCode.Length * 12.0), );
             Graphics g = Graphics.FromImage(image);
             try
             {
                 //生成随机生成器
                 Random random = new Random();
                 //清空图片背景色
                 g.Clear(Color.White);
                 //画图片的干扰线
                 for (int i = ; i < ; i++)
                 {
                     int x1 = random.Next(image.Width);
                     int x2 = random.Next(image.Width);
                     int y1 = random.Next(image.Height);
                     int y2 = random.Next(image.Height);
                     g.DrawLine(new Pen(Color.Silver), x1, y1, x2, y2);
                 }
                 Font font = new Font("Arial", , (FontStyle.Bold | FontStyle.Italic));
                 LinearGradientBrush brush = new LinearGradientBrush(new Rectangle(, , image.Width, image.Height),
                  Color.Blue, Color.DarkRed, 1.2f, true);
                 g.DrawString(validateCode, font, brush, , );
                 //画图片的前景干扰点
                 for (int i = ; i < ; i++)
                 {
                     int x = random.Next(image.Width);
                     int y = random.Next(image.Height);
                     image.SetPixel(x, y, Color.FromArgb(random.Next()));
                 }
                 //画图片的边框线
                 g.DrawRectangle(new Pen(Color.Silver), , , image.Width - , image.Height - );
                 //保存图片数据
                 MemoryStream stream = new MemoryStream();
                 image.Save(stream, ImageFormat.Jpeg);
                 //输出图片流
                 return stream.ToArray();
             }
             finally
             {
                 g.Dispose();
                 image.Dispose();
             }
         }

数字与字符混合验证码

  /// <summary>
         /// 生成随机字符串
         /// </summary>
         /// <param name="NumCount"></param>
         /// <returns></returns>
         private static string CreateRandomNum(int NumCount)
         {
             char[] allCharArray =
             {
                 '','','','','','','','','',
                 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
                 'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'
             };
             string randomNum = "";
             int temp = -;//记录上次随机数的数值，尽量避免产生几个相同的随机数
             Random rand = new Random();
             for (int i = ; i < NumCount; i++)
             {
                 if (temp != -)
                 {
                     rand = new Random(i * temp * ((int)DateTime.Now.Ticks));
                 }
                 int t = rand.Next();
                 if (temp == t)
                 {
                     return CreateRandomNum(NumCount);
                 }
                 temp = t;
                 randomNum += allCharArray[t];
             }
             return randomNum;
         }
 
         /// <summary>
         /// 数字和字符混合验证码
         /// </summary>
         /// <param name="Code">传出字符</param>
         /// <param name="NumCount">字节长度</param>
         /// <param name="Width">图片宽度</param>
         /// <param name="Height">图片长度</param>
         /// <param name="FontSize">文字大小</param>
         /// <returns></returns>
         public static byte[] GNCode(out string Code, int NumCount, int Width, int Height, int FontSize)
         {
             string validateNum = CreateRandomNum(NumCount);
             Code = null;
             if (validateNum == null || validateNum.Trim() == String.Empty)
                 return null;
             //生成Bitmap图像
             System.Drawing.Bitmap image = new System.Drawing.Bitmap(Width, Height);
             Graphics g = Graphics.FromImage(image);
 
             try
             {
                 //生成随机生成器
                 Random random = new Random();
 
                 //清空图片背景色
                 g.Clear(Color.White);
 
                 g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit;
                 Font f = new System.Drawing.Font("宋体", FontSize, (System.Drawing.FontStyle.Bold));
                 // 前景色
                 Brush b = new System.Drawing.SolidBrush(Color.Black);
                 // 背景色
                 g.Clear(Color.White);
                 // 填充文字
                 for (int i = ; i < validateNum.Length; i++)
                 {
                     g.DrawString(validateNum[i].ToString(), f, b, new Rectangle(i * (FontSize - ), , (FontSize - ), Height));
                 }
                 // 随机线条
                 Pen linePen = new Pen(Color.Gray, );
                 Random rand = new Random();
                 for (int i = ; i < ; i++)
                 {
                     int x1 = rand.Next(image.Width);
                     int y1 = rand.Next(image.Height);
                     int x2 = rand.Next(image.Width);
                     int y2 = rand.Next(image.Height);
                     g.DrawLine(linePen, x1, y1, x2, y2);
                 }
 
                 // 随机点
                 for (int i = ; i < ; i++)
                 {
                     int x = rand.Next(image.Width);
                     int y = rand.Next(image.Height);
                     image.SetPixel(x, y, Color.FromArgb(rand.Next(), rand.Next(), rand.Next()));
                 }
 
                 Code = validateNum;
 
                 //保存图片数据
                 MemoryStream stream = new MemoryStream();
                 image.Save(stream, ImageFormat.Jpeg);
                 //输出图片流
                 return stream.ToArray();
             }
             finally
             {
                 g.Dispose();
                 image.Dispose();
             }
         }

数学算式验证码

 /// <summary>
         /// 数学算式的验证码
         /// </summary>
         /// <param name="Code"></param>
         /// <returns></returns>
         public static byte[] MathVerifyCode(out int Code)
         {
             int mathResult = ;
             string expression = null;
 
             Random rnd = new Random();
 
             ////生成3个10以内的整数，用来运算
             int operator1 = rnd.Next(, );
             int operator2 = rnd.Next(, );
             int operator3 = rnd.Next(, );
 
             ////随机组合运算顺序，只做 + 和 - 运算
             switch (rnd.Next(, ))
             {
                 case :
                     mathResult = operator1 + operator2 + operator3;
                     expression = string.Format("{0} + {1} + {2} = ?", operator1, operator2, operator3);
                     break;
                 case :
                     mathResult = operator2 - operator1 + operator3;
                     expression = string.Format("{0} - {1} + {2} = ?", operator2, operator1, operator3);
                     break;
                 default:
                     mathResult = operator2 + operator1 - operator3;
                     expression = string.Format("{0} + {1} - {2} = ?", operator2, operator1, operator3);
                     break;
             }
             Code = mathResult;
             using (Bitmap bmp = new Bitmap(, ))
             {
                 using (Graphics graph = Graphics.FromImage(bmp))
                 {
                     graph.Clear(Color.FromArgb(, , )); ////背景色，可自行设置
 
                     ////画噪点
                     for (int i = ; i <= ; i++)
                     {
                         graph.DrawRectangle(
                             new Pen(Color.FromArgb(rnd.Next(, ), rnd.Next(, ), rnd.Next(, ))),
                             rnd.Next(, ),
                             rnd.Next(, ),
                             ,
                             );
                     }
 
                     ////输出表达式
                     for (int i = ; i < expression.Length; i++)
                     {
                         graph.DrawString(expression.Substring(i, ),
                             new Font(FontFamily.GenericSansSerif, , FontStyle.Bold),
                             new SolidBrush(Color.FromArgb(rnd.Next(), rnd.Next(), rnd.Next())),
                              + i * ,
                             rnd.Next(, ));
                     }
 
                     ////画边框，不需要可以注释掉
                     graph.DrawRectangle(new Pen(Color.Firebrick), , ,  - ,  - );
                 }
 
                 MemoryStream stream = new MemoryStream();
                 bmp.Save(stream, ImageFormat.Jpeg);
                 //输出图片流
                 return stream.ToArray();
             }
         }

数学算式验证码里面的算式结构是可以改成更复杂的，不过个人觉得加减法已经可以满足日常需求

使用方式

以ASP.NET MVC为例，使用方式很简单，写一个方法，以图片文件的形式输出

         /// <summary>
         /// 验证码
         /// </summary>
         /// <returns></returns>
         public virtual ActionResult VerifyImage()
         {
             string Code = "";
             byte[] bytes = CodeHelper.GNCode(out Code, , , , );
             Session["Code"] = Code;
             return File(bytes, @"image/jpeg");
         }

这里的CodeHelper就是我们写好的验证码帮助类，直接调用

前端放一张图片来显示验证码

<img  src="@Url.Action("VerifyImage")" id="VerifyImage" title="点击换一个">

应用截图