C#使用tesseract3.02识别验证码模拟登录

一、前言

使用tesseract3.02识别有验证码的网站 安装tesseract3.02 在VS nuget 搜索Tesseract即可。

二、项目结构图

三、项目主要代码

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Net;
using System.Net.Cache;
using System.Text;

namespace Tesseract.Test.Tools
{
    /// <summary>
    /// http帮助类
    /// </summary>
    public class HttpHelper
    {
        /// <summary>
        /// 异步事件
        /// </summary>
        public HttpHelper()
        {
            CookieContainer = new CookieContainer();
            Encoding = Encoding.UTF8;
        }

        /// <summary>
        /// 访问次数字典
        /// </summary>
        private ConcurrentDictionary<String, int> urlTryList = new ConcurrentDictionary<string, int>();

        /// <summary>
        /// Cookie 容器
        /// </summary>
        public CookieContainer CookieContainer { set; get; }

        /// <summary>
        /// Post数据
        /// </summary>
        public String PostData { set; private get; }

        /// <summary>
        /// 页面语言
        /// </summary>
        public Encoding Encoding { set; private get; }

        /// <summary>
        /// 验证码路径
        /// </summary>
        public string CodePath { get; set; }

        /// <summary>
        /// 文件保存路径
        /// </summary>
        public String FileSavePath { set; private get; }

        /// <summary>
        /// 回调时间
        /// </summary>
        public Action<String, String> CallBackAction;


        /// <summary>
        /// 异步请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="tryTimes">错误重试次数</param>
        public void AsynRequest(String url, int tryTimes = 3)
        {
            Trace.TraceInformation(String.Concat("开始异步请求:", url));
            urlTryList.TryAdd(url, tryTimes);
            var request = WebRequest.Create(url) as HttpWebRequest;
            if (request == null) return;
            request.Headers.Add("Accept-Encoding", "gzip,deflate,sdch");
            request.Headers.Add("Accept-Language", "zh-CN,zh;q=0.8");
            request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate |
                                             DecompressionMethods.None;
            request.Credentials = CredentialCache.DefaultNetworkCredentials;
            request.UseDefaultCredentials = false;
            request.KeepAlive = false;
            request.PreAuthenticate = false;
            request.ProtocolVersion = HttpVersion.Version10;
            request.UserAgent =
                "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36";
            request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8";
            //request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
            request.Timeout = 1000*60*3;
            request.CookieContainer = CookieContainer;
            //request.AllowAutoRedirect = false;

            if (!String.IsNullOrEmpty(PostData))
            {
                request.ContentType = "application/x-www-form-urlencoded";
                request.Method = "POST";
                request.BeginGetRequestStream(GetRequestStreamCallback, request);
            }
            else
            {
                //request.AllowReadStreamBuffering = false;
                request.AllowWriteStreamBuffering = false;
                request.BeginGetResponse(GetResponseCallback, request);
            }
        }

        /// <summary>
        /// 开始对用来写入数据的 Stream 对象的异步请求。
        /// </summary>
        /// <param name="ar"></param>
        private void GetRequestStreamCallback(IAsyncResult ar)
        {
            var request = ar.AsyncState as HttpWebRequest;
            if (request == null) return;
            var postStream = request.EndGetRequestStream(ar);
            var byteArray = Encoding.GetBytes(PostData);
            postStream.Write(byteArray, 0, PostData.Length);
            postStream.Close();
            request.BeginGetResponse(GetResponseCallback, request);
        }

        /// <summary>
        /// 开始对 Internet 资源的异步请求。 
        /// </summary>
        /// <param name="ar"></param>
        private void GetResponseCallback(IAsyncResult ar)
        {
            var request = ar.AsyncState as HttpWebRequest;
            if (request == null) return;
            try
            {
                using (var response = request.EndGetResponse(ar) as HttpWebResponse)
                {
                    if (response != null)
                    {
                        //if (response.StatusCode == HttpStatusCode.Found)
                        //{
                        //    string redirect = response.Headers["Location"];
                        //    if (!String.IsNullOrEmpty(redirect)) AsynRequest(redirect);
                        //    return;
                        //}

                        if (response.StatusCode != HttpStatusCode.OK)
                        {
                            Trace.TraceError(String.Concat("请求地址:", request.RequestUri, " 失败,HttpStatusCode",
                                response.StatusCode));
                            return;
                        }

                        using (var streamResponse = response.GetResponseStream())
                        {
                            if (streamResponse != null)
                            {
                                if (!IsText(response.ContentType))
                                {
                                    var contentEncodingStr = response.ContentEncoding;
                                    var contentEncoding = Encoding;
                                    if (!String.IsNullOrEmpty(contentEncodingStr))
                                        contentEncoding = Encoding.GetEncoding(contentEncodingStr);
                                    using (var streamRead = new StreamReader(streamResponse, contentEncoding))
                                    {
                                        var str = streamRead.ReadToEnd();
                                        if (CallBackAction != null && !String.IsNullOrEmpty(str))
                                            CallBackAction.BeginInvoke(str, request.RequestUri.ToString(), (s) => { },
                                                null);
                                    }
                                }
                                else
                                {
                                    var fileName = String.Concat(DateTime.Now.ToString("yyyyMMdd"), "/",
                                        DateTime.Now.ToString("yyyyMMddHHmmssffff"),
                                        //Extensions.String_.Extensions.GetRnd(6, true, false, false, false, String.Empty),
                                        ".jpg");
                                    var fileDirectory = Path.Combine(FileSavePath, DateTime.Now.ToString("yyyyMMdd"));
                                    CodePath = Path.Combine(FileSavePath, fileName);
                                    if (!Directory.Exists(fileDirectory))
                                        Directory.CreateDirectory(fileDirectory);

                                    //下载文件
                                    using (
                                        var fileStream = new FileStream(Path.Combine(FileSavePath, fileName),
                                            FileMode.Create))
                                    {
                                        var buffer = new byte[2048];
                                        int readLength;
                                        do
                                        {
                                            readLength = streamResponse.Read(buffer, 0, buffer.Length);
                                            fileStream.Write(buffer, 0, readLength);
                                        } while (readLength != 0);
                                    }
                                    if (CallBackAction != null && !String.IsNullOrEmpty(fileName))
                                        CallBackAction.BeginInvoke(fileName, request.RequestUri.ToString(), (s) => { },
                                            null);
                                }
                            }
                        }
                        response.Close();
                    }
                }
            }
            catch (WebException ex)
            {
                Trace.TraceError(String.Concat("请求地址:", request.RequestUri, " 失败信息:", ex.Message));
                var toUrl = request.RequestUri.ToString();
                int tryTimes;
                if (urlTryList.TryGetValue(toUrl, out tryTimes))
                {
                    urlTryList.TryUpdate(toUrl, tryTimes, tryTimes - 1);
                    if (tryTimes - 1 <= 0)
                    {
                        urlTryList.TryRemove(toUrl, out tryTimes);
                        return;
                    }
                    AsynRequest(toUrl);
                }
            }
            finally
            {
                request.Abort();
            }
        }


        /// <summary>
        /// 同步请求
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="tryTimes">错误重试次数</param>
        public String SyncRequest(String url, int tryTimes = 3)
        {
            Trace.TraceInformation(String.Concat("开始同步请求:", url));
            urlTryList.TryAdd(url, tryTimes);
            var request = WebRequest.Create(url) as HttpWebRequest;
            if (request == null) return String.Empty;
            request.Headers.Add("Accept-Encoding", "gzip,deflate,sdch");
            request.Headers.Add("Accept-Language", "zh-CN,zh;q=0.8");
            request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate |
                                             DecompressionMethods.None;
            request.Credentials = CredentialCache.DefaultNetworkCredentials;
            request.UseDefaultCredentials = false;
            request.KeepAlive = false;
            request.PreAuthenticate = false;
            request.ProtocolVersion = HttpVersion.Version10;
            request.UserAgent =
                "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36";
            request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8";
            request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
            request.Timeout = 1000*60*3;
            request.CookieContainer = CookieContainer;
            request.AllowAutoRedirect = true;

            if (!String.IsNullOrEmpty(PostData))
            {
                request.ContentType = "application/x-www-form-urlencoded";
                request.Method = "POST";
                using (var postStream = request.GetRequestStream())
                {
                    var byteArray = Encoding.GetBytes(PostData);
                    postStream.Write(byteArray, 0, PostData.Length);
                    postStream.Close();
                }
            }
            else
            {
                //request.AllowReadStreamBuffering = false;
                request.AllowWriteStreamBuffering = false;
            }
            try
            {
                using (var response = request.GetResponse() as HttpWebResponse)
                {
                    if (response != null)
                    {
                        if (response.StatusCode != HttpStatusCode.OK)
                        {
                            Trace.TraceError(String.Concat("请求地址:", request.RequestUri, " 失败,HttpStatusCode",
                                response.StatusCode));
                            return String.Empty;
                        }
                        using (var streamResponse = response.GetResponseStream())
                        {
                            if (streamResponse != null)
                            {
                                if (!IsText(response.ContentType))
                                {
                                    var contentEncodingStr = response.ContentEncoding;
                                    var contentEncoding = Encoding;
                                    if (!String.IsNullOrEmpty(contentEncodingStr))
                                        contentEncoding = Encoding.GetEncoding(contentEncodingStr);
                                    var streamRead = new StreamReader(streamResponse, contentEncoding);
                                    var str = streamRead.ReadToEnd();
                                    if (CallBackAction != null && !String.IsNullOrEmpty(str))
                                        CallBackAction.BeginInvoke(str, request.RequestUri.ToString(), (s) => { }, null);
                                    return str;
                                }

                                var fileName = String.Concat(DateTime.Now.ToString("yyyyMMdd"), "/",
                                    DateTime.Now.ToString("yyyyMMddHHmmssffff"),
                                    //Extensions.String_.Extensions.GetRnd(6, true, false, false, false, String.Empty),
                                    Path.GetExtension(request.RequestUri.AbsoluteUri));
                                var fileDirectory = Path.Combine(FileSavePath, DateTime.Now.ToString("yyyyMMdd"));
                                if (!Directory.Exists(fileDirectory))
                                    Directory.CreateDirectory(fileDirectory);

                                //下载文件
                                using (
                                    var fileStream = new FileStream(Path.Combine(FileSavePath, fileName),
                                        FileMode.Create))
                                {
                                    var buffer = new byte[2048];
                                    int readLength;
                                    do
                                    {
                                        readLength = streamResponse.Read(buffer, 0, buffer.Length);
                                        fileStream.Write(buffer, 0, readLength);
                                    } while (readLength != 0);
                                }
                                if (CallBackAction != null && !String.IsNullOrEmpty(fileName))
                                    CallBackAction.BeginInvoke(fileName, request.RequestUri.ToString(), (s) => { }, null);
                                return fileName;
                            }
                        }
                        response.Close();
                    }
                }
            }
            catch (WebException ex)
            {
                Trace.TraceError(String.Concat("请求地址:", request.RequestUri, " 失败信息:", ex.Message));
                var toUrl = request.RequestUri.ToString();
                if (urlTryList.TryGetValue(toUrl, out tryTimes))
                {
                    urlTryList.TryUpdate(toUrl, tryTimes, tryTimes - 1);
                    if (tryTimes - 1 <= 0)
                    {
                        urlTryList.TryRemove(toUrl, out tryTimes);
                        Trace.TraceError(String.Concat("请求地址重试失败:", request.RequestUri));
                        return String.Empty;
                    }
                    SyncRequest(toUrl);
                }
            }
            finally
            {
                request.Abort();
            }
            return String.Empty;
        }

        /// <summary>
        /// 验证码获取
        /// </summary>
        /// <param name="url">请求地址</param>
        /// <param name="tryTimes">错误重试次数</param>
        public Bitmap GetCheckCode(String url, int tryTimes = 3)
        {
            Trace.TraceInformation(String.Concat("开始同步请求:", url));
            urlTryList.TryAdd(url, tryTimes);
            var request = WebRequest.Create(url) as HttpWebRequest;
            if (request == null) return null;
            request.Headers.Add("Accept-Encoding", "gzip,deflate,sdch");
            request.Headers.Add("Accept-Language", "zh-CN,zh;q=0.8");
            request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate |
                                             DecompressionMethods.None;
            request.Credentials = CredentialCache.DefaultNetworkCredentials;
            request.UseDefaultCredentials = false;
            request.KeepAlive = false;
            request.PreAuthenticate = false;
            request.ProtocolVersion = HttpVersion.Version10;
            request.UserAgent =
                "Mozilla/5.0 (Windows NT 6.2; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36";
            request.Accept = "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8";
            request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
            request.Timeout = 1000*60*3;
            request.CookieContainer = CookieContainer;
            request.AllowAutoRedirect = true;

            if (!String.IsNullOrEmpty(PostData))
            {
                request.ContentType = "application/x-www-form-urlencoded";
                request.Method = "POST";
                using (var postStream = request.GetRequestStream())
                {
                    var byteArray = Encoding.GetBytes(PostData);
                    postStream.Write(byteArray, 0, PostData.Length);
                    postStream.Close();
                }
            }
            else
            {
                //request.AllowReadStreamBuffering = false;
                request.AllowWriteStreamBuffering = false;
            }
            try
            {
                using (var response = request.GetResponse() as HttpWebResponse)
                {
                    if (response != null)
                    {
                        if (response.StatusCode != HttpStatusCode.OK)
                        {
                            Trace.TraceError(String.Concat("请求地址:", request.RequestUri, " 失败,HttpStatusCode",
                                response.StatusCode));
                            return null;
                        }
                        using (var streamResponse = response.GetResponseStream())
                        {
                            if (streamResponse != null)
                            {
                                return (Bitmap) Bitmap.FromStream(streamResponse);
                            }
                        }
                        response.Close();
                    }
                }
            }
            catch (WebException ex)
            {
                Trace.TraceError(String.Concat("请求地址:", request.RequestUri, " 失败信息:", ex.Message));
                var toUrl = request.RequestUri.ToString();
                if (urlTryList.TryGetValue(toUrl, out tryTimes))
                {
                    urlTryList.TryUpdate(toUrl, tryTimes, tryTimes - 1);
                    if (tryTimes - 1 <= 0)
                    {
                        urlTryList.TryRemove(toUrl, out tryTimes);
                        Trace.TraceError(String.Concat("请求地址重试失败:", request.RequestUri));
                        return null;
                    }
                    GetCheckCode(toUrl);
                }
            }
            finally
            {
                request.Abort();
            }
            return null;
        }

        /// <summary>
        /// 判断文件是否为文本类型
        /// </summary>
        /// <param name="contentType">内容类型</param>
        /// <returns></returns>
        private static bool IsText(String contentType)
        {
            var fileContentType = new List<string>
            {
                "image/Bmp",
                "image/gif",
                "image/jpeg",
                "image/png",
                "image/tiff",
                "application/octet-stream"
            };
            return fileContentType.Contains(contentType);
        }
    }
}

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace Tesseract.Test.Tools
{
    public class UnCodebase
    {
        public Bitmap bmpobj;

        public UnCodebase(Bitmap pic)
        {
            bmpobj = new Bitmap(pic); //转换为Format32bppRgb
        }

        /// <summary>
        /// 根据RGB，计算灰度值
        /// </summary>
        /// <param name="posClr">Color值</param>
        /// <returns>灰度值，整型</returns>
        private int GetGrayNumColor(Color posClr)
        {
            return (posClr.R*19595 + posClr.G*38469 + posClr.B*7472) >> 16;
        }

        /// <summary>
        /// 灰度转换,逐点方式
        /// </summary>
        public Bitmap GrayByPixels()
        {
            for (int i = 0; i < bmpobj.Height; i++)
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    int tmpValue = GetGrayNumColor(bmpobj.GetPixel(j, i));
                    bmpobj.SetPixel(j, i, Color.FromArgb(tmpValue, tmpValue, tmpValue));
                }
            }
            return bmpobj;
        }

        /// <summary>
        /// 去图形边框
        /// </summary>
        /// <param name="borderWidth"></param>
        public Bitmap ClearPicBorder(int borderWidth)
        {
            for (int i = 0; i < bmpobj.Height; i++)
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    if (i < borderWidth || j < borderWidth || j > bmpobj.Width - 1 - borderWidth ||
                        i > bmpobj.Height - 1 - borderWidth)
                        bmpobj.SetPixel(j, i, Color.FromArgb(255, 255, 255));
                }
            }
            return bmpobj;
        }

        /// <summary>
        /// 灰度转换,逐行方式
        /// </summary>
        public Bitmap GrayByLine()
        {
            Rectangle rec = new Rectangle(0, 0, bmpobj.Width, bmpobj.Height);
            BitmapData bmpData = bmpobj.LockBits(rec, ImageLockMode.ReadWrite, bmpobj.PixelFormat);
            // PixelFormat.Format32bppPArgb);
            //    bmpData.PixelFormat = PixelFormat.Format24bppRgb;
            IntPtr scan0 = bmpData.Scan0;
            int len = bmpobj.Width*bmpobj.Height;
            int[] pixels = new int[len];
            Marshal.Copy(scan0, pixels, 0, len);

            //对图片进行处理
            int GrayValue = 0;
            for (int i = 0; i < len; i++)
            {
                GrayValue = GetGrayNumColor(Color.FromArgb(pixels[i]));
                pixels[i] = (byte) (Color.FromArgb(GrayValue, GrayValue, GrayValue)).ToArgb(); //Color转byte
            }

            bmpobj.UnlockBits(bmpData);
            return bmpobj;
        }

        /// <summary>
        /// 得到有效图形并调整为可平均分割的大小
        /// </summary>
        /// <param name="dgGrayValue">灰度背景分界值</param>
        /// <param name="CharsCount">有效字符数</param>
        /// <returns></returns>
        public void GetPicValidByValue(int dgGrayValue, int CharsCount)
        {
            int posx1 = bmpobj.Width;
            int posy1 = bmpobj.Height;
            int posx2 = 0;
            int posy2 = 0;
            for (int i = 0; i < bmpobj.Height; i++) //找有效区
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    int pixelValue = bmpobj.GetPixel(j, i).R;
                    if (pixelValue < dgGrayValue) //根据灰度值
                    {
                        if (posx1 > j) posx1 = j;
                        if (posy1 > i) posy1 = i;

                        if (posx2 < j) posx2 = j;
                        if (posy2 < i) posy2 = i;
                    }
                    ;
                }
                ;
            }
            ;
            // 确保能整除
            int Span = CharsCount - (posx2 - posx1 + 1)%CharsCount; //可整除的差额数
            if (Span < CharsCount)
            {
                int leftSpan = Span/2; //分配到左边的空列 ，如span为单数,则右边比左边大1
                if (posx1 > leftSpan)
                    posx1 = posx1 - leftSpan;
                if (posx2 + Span - leftSpan < bmpobj.Width)
                    posx2 = posx2 + Span - leftSpan;
            }
            //复制新图
            Rectangle cloneRect = new Rectangle(posx1, posy1, posx2 - posx1 + 1, posy2 - posy1 + 1);
            bmpobj = bmpobj.Clone(cloneRect, bmpobj.PixelFormat);
        }

        /// <summary>
        /// 得到有效图形,图形为类变量
        /// </summary>
        /// <param name="dgGrayValue">灰度背景分界值</param>
        /// <param name="CharsCount">有效字符数</param>
        /// <returns></returns>
        public void GetPicValidByValue(int dgGrayValue)
        {
            int posx1 = bmpobj.Width;
            int posy1 = bmpobj.Height;
            int posx2 = 0;
            int posy2 = 0;
            for (int i = 0; i < bmpobj.Height; i++) //找有效区
            {
                for (int j = 0; j < bmpobj.Width; j++)
                {
                    int pixelValue = bmpobj.GetPixel(j, i).R;
                    if (pixelValue < dgGrayValue) //根据灰度值
                    {
                        if (posx1 > j) posx1 = j;
                        if (posy1 > i) posy1 = i;

                        if (posx2 < j) posx2 = j;
                        if (posy2 < i) posy2 = i;
                    }
                    ;
                }
                ;
            }
            ;
            //复制新图
            Rectangle cloneRect = new Rectangle(posx1, posy1, posx2 - posx1 + 1, posy2 - posy1 + 1);
            bmpobj = bmpobj.Clone(cloneRect, bmpobj.PixelFormat);
        }

        /// <summary>
        /// 得到有效图形,图形由外面传入
        /// </summary>
        /// <param name="dgGrayValue">灰度背景分界值</param>
        /// <param name="CharsCount">有效字符数</param>
        /// <returns></returns>
        public Bitmap GetPicValidByValue(Bitmap singlepic, int dgGrayValue)
        {
            int posx1 = singlepic.Width;
            int posy1 = singlepic.Height;
            int posx2 = 0;
            int posy2 = 0;
            for (int i = 0; i < singlepic.Height; i++) //找有效区
            {
                for (int j = 0; j < singlepic.Width; j++)
                {
                    int pixelValue = singlepic.GetPixel(j, i).R;
                    if (pixelValue < dgGrayValue) //根据灰度值
                    {
                        if (posx1 > j) posx1 = j;
                        if (posy1 > i) posy1 = i;

                        if (posx2 < j) posx2 = j;
                        if (posy2 < i) posy2 = i;
                    }
                    ;
                }
                ;
            }
            ;
            //复制新图
            Rectangle cloneRect = new Rectangle(posx1, posy1, posx2 - posx1 + 1, posy2 - posy1 + 1);
            return singlepic.Clone(cloneRect, singlepic.PixelFormat);
        }

        /// <summary>
        /// 平均分割图片
        /// </summary>
        /// <param name="RowNum">水平上分割数</param>
        /// <param name="ColNum">垂直上分割数</param>
        /// <returns>分割好的图片数组</returns>
        public Bitmap[] GetSplitPics(int RowNum, int ColNum)
        {
            if (RowNum == 0 || ColNum == 0)
                return null;
            int singW = bmpobj.Width/RowNum;
            int singH = bmpobj.Height/ColNum;
            Bitmap[] PicArray = new Bitmap[RowNum*ColNum];

            Rectangle cloneRect;
            for (int i = 0; i < ColNum; i++) //找有效区
            {
                for (int j = 0; j < RowNum; j++)
                {
                    cloneRect = new Rectangle(j*singW, i*singH, singW, singH);
                    PicArray[i*RowNum + j] = bmpobj.Clone(cloneRect, bmpobj.PixelFormat); //复制小块图
                }
            }
            return PicArray;
        }

        /// <summary>
        /// 返回灰度图片的点阵描述字串，1表示灰点，0表示背景
        /// </summary>
        /// <param name="singlepic">灰度图</param>
        /// <param name="dgGrayValue">背前景灰色界限</param>
        /// <returns></returns>
        public string GetSingleBmpCode(Bitmap singlepic, int dgGrayValue)
        {
            Color piexl;
            string code = "";
            for (int posy = 0; posy < singlepic.Height; posy++)
                for (int posx = 0; posx < singlepic.Width; posx++)
                {
                    piexl = singlepic.GetPixel(posx, posy);
                    if (piexl.R < dgGrayValue) // Color.Black )
                        code = code + "1";
                    else
                        code = code + "0";
                }
            return code;
        }

        /// <summary>
        /// 去掉噪点
        /// </summary>
        /// <param name="dgGrayValue"></param>
        /// <param name="MaxNearPoints"></param>
        public Bitmap ClearNoise(int dgGrayValue, int MaxNearPoints)
        {
            Color piexl;
            int nearDots = 0;
            int XSpan, YSpan, tmpX, tmpY;
            //逐点判断
            for (int i = 0; i < bmpobj.Width; i++)
                for (int j = 0; j < bmpobj.Height; j++)
                {
                    piexl = bmpobj.GetPixel(i, j);
                    if (piexl.R < dgGrayValue)
                    {
                        nearDots = 0;
                        //判断周围8个点是否全为空
                        if (i == 0 || i == bmpobj.Width - 1 || j == 0 || j == bmpobj.Height - 1) //边框全去掉
                        {
                            bmpobj.SetPixel(i, j, Color.FromArgb(255, 255, 255));
                        }
                        else
                        {
                            if (bmpobj.GetPixel(i - 1, j - 1).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i, j - 1).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i + 1, j - 1).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i - 1, j).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i + 1, j).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i - 1, j + 1).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i, j + 1).R < dgGrayValue) nearDots++;
                            if (bmpobj.GetPixel(i + 1, j + 1).R < dgGrayValue) nearDots++;
                        }

                        if (nearDots < MaxNearPoints)
                            bmpobj.SetPixel(i, j, Color.FromArgb(255, 255, 255)); //去掉单点 && 粗细小3邻边点
                    }
                    else //背景
                        bmpobj.SetPixel(i, j, Color.FromArgb(255, 255, 255));
                }
            return bmpobj;
        }

        /// <summary>
        /// 扭曲图片校正
        /// </summary>
        public Bitmap ReSetBitMap()
        {
            Graphics g = Graphics.FromImage(bmpobj);
            Matrix X = new Matrix();
            //  X.Rotate(30);
            X.Shear((float) 0.16666666667, 0); //  2/12
            g.Transform = X;
            // Draw image
            //Rectangle cloneRect = GetPicValidByValue(128);  //Get Valid Pic Rectangle
            Rectangle cloneRect = new Rectangle(0, 0, bmpobj.Width, bmpobj.Height);
            Bitmap tmpBmp = bmpobj.Clone(cloneRect, bmpobj.PixelFormat);
            g.DrawImage(tmpBmp,
                new Rectangle(0, 0, bmpobj.Width, bmpobj.Height),
                0, 0, tmpBmp.Width,
                tmpBmp.Height,
                GraphicsUnit.Pixel);

            return tmpBmp;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tesseract.Test.Tools;

namespace Tesseract.Test
{
    /// <summary>
    /// 网站用户
    /// </summary>
    public class WebUser
    {
        /// <summary>
        /// 用户名
        /// </summary>
        private string _userName = string.Empty;

        /// <summary>
        /// 密码
        /// </summary>
        private string _password = string.Empty;

        /// <summary>
        /// 验证码
        /// </summary>
        private string _checkCode = string.Empty;

        private HttpHelper _httpHelper = new HttpHelper();

        /// <summary>
        /// 构造函数
        /// </summary>
        public WebUser()
        {
            _userName = "admin"; //初始化用户
            _password = "password"; //初始化密码
            Login();
        }


        /// <summary>
        /// 登录
        /// </summary>
        private void Login()
        {
            //登录页
            _httpHelper.SyncRequest("Login.html");

            //获取验证码图片
            var bitmap = _httpHelper.GetCheckCode("CheckCode.html");

            //解析验证码
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default))
            {
                using (var entity = engine.Process(bitmap))
                {
                    _checkCode = entity.GetText();
                }
            }

            //登录验证
            _httpHelper.PostData = string.Format("userName={0}&password={1}&checkcode={2}",
                _userName, _password, _checkCode);
            _httpHelper.SyncRequest("CheckLogin.html");
        }
    }
}

四、代码解释

1、模拟登录的过程基本都是访问登录页面获取相关的cookie。

2、访问验证码页面这样就不用将验证码下载到本地再解析。直接在程序内解析。减少验证码本地图片文件增加。

3、使用tesseract来解析验证码。（需要看验证码的干扰是否严重，使用UnCodebase对验证码图片适当的处理可以增加识别正确率）

4、访问登录验证页面将用户名密码验证码POST过去。

5、登录成功。