教你用C#实现：简单又高效的“爬虫”程序

起爬虫似乎都成了python的专属了，我不知道其他人怎么样？至少我平时对爬虫的应用场景很小，所以一直没有关注它。近期因为一个小项目——一个客户的网站忘了续费，结果被服务商索取高额服务费（好在网站还能打开），刚好客户遇到我们，我们当场从0开始开发了一个爬虫，一下午就把内容爬下来了。

一、原理（用大白话告诉你原理）

网页最终呈现在浏览器中，都是以html编码呈现的，html是什么都不懂的话，这篇文章都不懂的话，这篇文章可能不适合你，但我还是愿意给你扫扫盲；html就是把文字或图片进行定位排版的一种描述性语言。比如：加粗加粗，比如下划线这是下划线基本所有内容都是由类似这样的标签包裹起来的，下面看一组html的编码（你到任何一个网站点右键‘查看源文件’都能看到它的编码文件）。

html源文件

通过上图可以观察到，我们需要取的内容都在html标签内包含，再仔细观察这个html标签，发现两个特点：

1、新闻的标题在：<a>新闻标题</a>（a标签内包含）

2、新闻的下级链接：<a href="http://下级内容链接"> （a标签的href内包含）

这里你需要记住两个行业术语，1这种形态：标签内包含的叫“内容”，2这种形态：叫“属性”，一个完整的标签是由内容和属性构成，属性不是必须的，如果内容你也不写的话，就会什么也不显示，就成了无意义标签。

大量的标签构成了html网页，标签也有父子归属关系，就好比数学上的：大括号管中括号，中括号管小括号一样。

扫盲到此为止……

根据上面的html显示，我们需要用爬虫剔骨卸肉一般，将a标签中的标题文字，和下级链接取出。

二、关键技术——“解析”

本文开始说到python很擅长做爬虫，那是python语言的爱好者圈子里，贡献了很多解析html代码的小工具（行业内把各种工具类的代码片段叫：类库），比如这个类库的作用是：给它喂一篇html文档，你简单描述一下要求，（例如：要求取出所有a标签的文字），这个类库就可以高效的根据你的描述，把整个源码文档中的a标签的文字剔出来。这个“剔”的过程，行业内把它叫“解析”。

解析文档无论在什么语言中，都是一件非常细致且耗时的工作，“类库”只是某种语言的爱好者，把某个常用功能剥离出来，可以在不同的程序之间移植而已。

比如：上面介绍的就是html解析类库，python的这个语言并不是天生就会做什么，而是它的社区很活跃，被爱好者共享的类库很多而已。

但是话又说回来了，其他老牌语言也不见得类库就少，比如：C#或java各种工具类库也是铺天盖地，今天介绍的就是c#下的一款优秀的html解析类库——“HtmlAgilityPack”。

它的用法和jqurey非常像，如果你想取出下面链接地址和文字，那么就这么描述就行：

实现方法

//定义一个根节点
Dom_list="//table[@id='content_one_4']";
//查询指定容器下的组节点
 HtmlNode documentNode=doc.DocumentNode.SelectSingleNode(Dom_list);
 HtmlNodeCollection linklist=documentNode.SelectNodes(".//a");

//把这一组a标签循环取出
foreach (var item in linklist)
{
      //【核心】获取链接文字和链接的地址
      string link_title=item.InnerHtml;
      string link_url=item.Attributes["href"].Value;

       //检测重复记录后写入数据库：根据情况自己完成入库操作
}

这么简简单单的几句代码就完成了爬虫的核心工作，数据进了你本地库，你爱怎么变花样就怎么变。

如果你把爬虫的原理搞明白了，制作起来还是很容易的，但容易的前提是你用了别人的类库，如果让你从零开始，去分析解析一篇html文档，那就非常复杂。除了用常见的正则表达式去匹配各种规则，还要有大量的容错机制，确实不是一般程序员能快速搞定的事。

python之所以目前很受欢迎，主要得益于它的类库丰富，把程序开发活脱脱变成了套壳，小白上手很容易；但话又说回来，如果一个项目要你徒手从零完成，那无论用什么语言，工作量其实也都差不多了。

下面是我做的一个桌面爬虫应用程序，之所以用做成程序而不是网页，主要是考虑到这是个工具，开箱即用，web再方便也需要部署环境，在这一点上一个exe的绿色软件，还是有相当大的优势的。

我的爬虫软件

软件使用很简单：对目标网站进行简单进行配置以后，先点击【采集目录】就可以获得所有的内容页的地址存入“工作进程”中（例如：获取了1000条内容地址），然后点击【采集内容】，程序就依次从从“工作进程”中的地址采集内容。

多线程采集，网速够快几分钟就采集完成了，如果你想做个爬虫，就试试吧。

近有个概念吵得很火，网络爬虫，但是基本都是用什么python或者JAVA写，貌似很少看到用c++写的，我在网上找了一个，看到其实还是很简单的算法

算法讲解：1.遍历资源网站

　　　　　2.获取html信息

　　　　 3.然后解析网址和图片url下载。

　　　　 4.递归调用搜索网址

BFS是最重要的处理：

先是获取网页响应，保存到文本里面，然后找到其中的图片链接HTMLParse，

下载所有图片DownLoadImg。

//广度遍历  
void BFS( const string & url ){  
	char * response;  
	int bytes;  
	// 获取网页的相应，放入response中。  
	if( !GetHttpResponse( url, response, bytes ) ){  
		cout << "The url is wrong! ignore." << endl;  
		return;  
	}  
	string httpResponse=response;  
	free( response );  
	string filename=ToFileName( url );  
	ofstream ofile( "./html/"+filename );  
	if( ofile.is_open() ){  
		// 保存该网页的文本内容  
		ofile << httpResponse << endl;  
		ofile.close();  
	}  
	vector<string> imgurls;  
	//解析该网页的所有图片链接，放入imgurls里面  
	HTMLParse( httpResponse,  imgurls, url );  

	//下载所有的图片资源  
	DownLoadImg( imgurls, url );  
}

然后附上代码：

#include "stdafx.h"

//#include <Windows.h>

#include <string>

#include <iostream>

#include <fstream>

#include <vector>

#include "winsock2.h"

#include <time.h>

#include <queue>

#include <hash_set>

#pragma comment(lib, "ws2_32.lib")

using namespace std;

#define DEFAULT_PAGE_BUF_SIZE 1048576

queue<string> hrefUrl;

hash_set<string> visitedUrl;

hash_set<string> visitedImg;

int depth=0;

int g_ImgCnt=1;

//解析URL，解析出主机名，资源名

bool ParseURL( const string & url, string & host, string & resource){

if ( strlen(url.c_str()) > 2000 ) {

return false;

}

const char * pos=strstr( url.c_str(), "http://" );

if( pos==NULL ) pos=url.c_str();

else pos +=strlen("http://");

if( strstr( pos, "/")==0 )

return false;

char pHost[100];

char pResource[2000];

sscanf( pos, "%[^/]%s", pHost, pResource );

host=pHost;

resource=pResource;

return true;

}

//使用Get请求，得到响应

bool GetHttpResponse( const string & url, char * &response, int &bytesRead ){

string host, resource;

if(!ParseURL( url, host, resource )){

cout << "Can not parse the url"<<endl;

return false;

}

//建立socket

struct hostent * hp=gethostbyname( host.c_str() );

if( hp==NULL ){

cout<< "Can not find host address"<<endl;

return false;

}

SOCKET sock=socket( AF_INET, SOCK_STREAM, IPPROTO_TCP);

if( sock==-1 || sock==-2 ){

cout << "Can not create sock."<<endl;

return false;

}

//建立服务器地址

SOCKADDR_IN sa;

sa.sin_family=AF_INET;

sa.sin_port=htons( 80 );

//char addr[5];

//memcpy( addr, hp->h_addr, 4 );

//sa.sin_addr.s_addr=inet_addr(hp->h_addr);

memcpy( &sa.sin_addr, hp->h_addr, 4 );

//建立连接

if( 0!=connect( sock, (SOCKADDR*)&sa, sizeof(sa) ) ){

cout << "Can not connect: "<< url <<endl;

closesocket(sock);

return false;

};

//准备发送数据

string request="GET " + resource + " HTTP/1.1\r\nHost:" + host + "\r\nConnection:Close\r\n\r\n";

//发送数据

if( SOCKET_ERROR==send( sock, request.c_str(), request.size(), 0 ) ){

cout << "send error" <<endl;

closesocket( sock );

return false;

}

//接收数据

int m_nContentLength=DEFAULT_PAGE_BUF_SIZE;

char *pageBuf=(char *)malloc(m_nContentLength);

memset(pageBuf, 0, m_nContentLength);

bytesRead=0;

int ret=1;

cout <<"Read: ";

while(ret > 0){

ret=recv(sock, pageBuf + bytesRead, m_nContentLength - bytesRead, 0);

if(ret > 0)

{

bytesRead +=ret;

}

if( m_nContentLength - bytesRead<100){

cout << "\nRealloc memorry"<<endl;

m_nContentLength *=2;

pageBuf=(char*)realloc( pageBuf, m_nContentLength); //重新分配内存

}

cout << ret <<" ";

}

cout <<endl;

pageBuf[bytesRead]='> pageBuf[bytesRead]='\0'; <';

response=pageBuf;

closesocket( sock );

return true;

//cout<< response <<endl;

}

//提取所有的URL以及图片URL

void HTMLParse ( string & htmlResponse, vector<string> & imgurls, const string & host ){

//找所有连接，加入queue中

const char *p=htmlResponse.c_str();

char *tag="href=\"";

const char *pos=strstr( p, tag );

ofstream ofile("url.txt", ios::app);

while( pos ){

pos +=strlen(tag);

const char * nextQ=strstr( pos, "\"" );

if( nextQ ){

char * url=new char[ nextQ-pos+1 ];

//char url[100]; //固定大小的会发生缓冲区溢出的危险

sscanf( pos, "%[^\"]", url);

string surl=url; // 转换成string类型，可以自动释放内存

if( visitedUrl.find( surl )==visitedUrl.end() ){

visitedUrl.insert( surl );

ofile << surl<<endl;

hrefUrl.push( surl );

}

pos=strstr(pos, tag );

delete [] url; // 释放掉申请的内存

}

ofile << endl << endl;

ofile.close();

tag="<img ";

const char* att1="src=\"";

const char* att2="lazy-src=\"";

const char *pos0=strstr( p, tag );

while( pos0 ){

pos0 +=strlen( tag );

const char* pos2=strstr( pos0, att2 );

if( !pos2 || pos2 > strstr( pos0, ">") ) {

pos=strstr( pos0, att1);

if(!pos) {

pos0=strstr(att1, tag );

continue;

} else {

pos=pos + strlen(att1);

}

else {

pos=pos2 + strlen(att2);

}

const char * nextQ=strstr( pos, "\"");

if( nextQ ){

char * url=new char[nextQ-pos+1];

sscanf( pos, "%[^\"]", url);

cout << url<<endl;

string imgUrl=url;

if( visitedImg.find( imgUrl )==visitedImg.end() ){

visitedImg.insert( imgUrl );

imgurls.push_back( imgUrl );

}

pos0=strstr(pos0, tag );

delete [] url;

}

cout << "end of Parse this html"<<endl;

}

//把URL转化为文件名

string ToFileName( const string &url ){

string fileName;

fileName.resize( url.size());

int k=0;

for( int i=0; i<(int)url.size(); i++){

char ch=url[i];

if( ch!='\'&&ch!='/'&&ch!=':'&&ch!='*'&&ch!='?'&&ch!='"'&&ch!='<'&&ch!='>'&&ch!='|')

fileName[k++]=ch;

}

return fileName.substr(0,k) + ".txt";

}

//下载图片到img文件夹

void DownLoadImg( vector<string> & imgurls, const string &url ){

//生成保存该url下图片的文件夹

string foldname=ToFileName( url );

foldname="./img/"+foldname;

if(!CreateDirectory( foldname.c_str(),NULL ))

cout << "Can not create directory:"<< foldname<<endl;

char *image;

int byteRead;

for( int i=0; i<imgurls.size(); i++){

//判断是否为图片，bmp，jgp，jpeg，gif

string str=imgurls[i];

int pos=str.find_last_of(".");

if( pos==string::npos )

continue;

else{

string ext=str.substr( pos+1, str.size()-pos-1 );

if( ext!="bmp"&& ext!="jpg" && ext!="jpeg"&& ext!="gif"&&ext!="png")

continue;

}

//下载其中的内容

if( GetHttpResponse(imgurls[i], image, byteRead)){

if ( strlen(image)==0 ) {

continue;

}

const char *p=image;

const char * pos=strstr(p,"\r\n\r\n")+strlen("\r\n\r\n");

int index=imgurls[i].find_last_of("/");

if( index!=string::npos ){

string imgname=imgurls[i].substr( index , imgurls[i].size() );

ofstream ofile( foldname+imgname, ios::binary );

if( !ofile.is_open() )

continue;

cout <<g_ImgCnt++<< foldname+imgname<<endl;

ofile.write( pos, byteRead- (pos-p) );

ofile.close();

}

free(image);

}

//广度遍历

void BFS( const string & url ){

char * response;

int bytes;

// 获取网页的相应，放入response中。

if( !GetHttpResponse( url, response, bytes ) ){

cout << "The url is wrong! ignore." << endl;

return;

}

string httpResponse=response;

free( response );

string filename=ToFileName( url );

ofstream ofile( "./html/"+filename );

if( ofile.is_open() ){

// 保存该网页的文本内容

ofile << httpResponse << endl;

ofile.close();

}

vector<string> imgurls;

//解析该网页的所有图片链接，放入imgurls里面

HTMLParse( httpResponse, imgurls, url );

//下载所有的图片资源

DownLoadImg( imgurls, url );

}

void main()

{

//初始化socket，用于tcp网络连接

WSADATA wsaData;

if( WSAStartup(MAKEWORD(2,2), &wsaData) !=0 ){

return;

}

// 创建文件夹，保存图片和网页文本文件

CreateDirectory( "./img",0);

CreateDirectory("./html",0);

//string urlStart="http://hao.360.cn/meinvdaohang.html";

// 遍历的起始地址

string urlStart="http://desk.zol.com.cn/bizhi/7018_87137_2.html";

//string urlStart="http://item.taobao.com/item.htm?spm=a230r.1.14.19.sBBNbz&id=36366887850&ns=1#detail";

// 使用广度遍历

// 提取网页中的超链接放入hrefUrl中，提取图片链接，下载图片。

BFS( urlStart );

// 访问过的网址保存起来

visitedUrl.insert( urlStart );

while( hrefUrl.size()!=0 ){

string url=hrefUrl.front(); // 从队列的最开始取出一个网址

cout << url << endl;

BFS( url ); // 遍历提取出来的那个网页，找它里面的超链接网页放入hrefUrl，下载它里面的文本，图片

hrefUrl.pop(); // 遍历完之后，删除这个网址

}

WSACleanup();

return;

}

学习网络爬虫要掌握哪些技术?#

挑战升级！老板又为我设定了新的任务目标：利用C#开发一款超能爬虫，它必须深入挖掘我们网站的每一个细节，不论是主体内容、相关链接，甚至是细微至页面标题，都需快速精准获取，全程保持高效稳定的运行状态。

这不仅是一个任务，还是一次创新能力的试炼。那天，我坐在电脑前，心里琢磨着，这得怎么开始呢？

好吧，我得先熟悉我们网站的结构，就像了解一个新朋友一样。我打开了浏览器，一页一页地翻，仔细观察那些HTML代码，找到了BODY、链接和标题的蛛丝马迹。

根据我们网站结构,我开始了针对这个任务的计划：

需求分析：

抓取页面内容（BODY）：需要从目标网页中提取出HTML的主体部分，这通常包括文字、图片、视频等内容。

抓取网站链接：我需要识别网页中的超链接（如<a>标签），并提取出它们的href属性，以获取其他相关页面的链接。

抓取页面标题：页面标题通常位于<title>标签内，我要能够提取并存储这些标题信息。

技术选型：

由于使用C#作为开发语言，我可以使用HttpClient来实现HTTP请求和响应处理。利用解析库（这次用AngleSharp）来解析网页内容，提取所需信息。

主要实现步骤：

初始化：设置爬虫的基本配置，如并发请求数、超时时间等。网页抓取：通过HTTP请求获取目标网页的HTML内容。内容解析：使用HTML解析库提取页面内容、链接和标题。数据演示（实际是要保存的）：将提取的信息展示到控制台中显示，以便查看、分析和处理。错误处理：实现适当的错误处理机制，如展示异常记录等。

测试与验证：

对爬虫程序进行单元测试，确保每个功能模块都能正常工作。进行集成测试，确保整个爬虫流程的流畅性和稳定性。在实际网站上进行验证，确保抓取到的数据准确无误。

维护与更新：

定期检查爬虫程序的运行状态，及时处理可能出现的问题。根据网站结构和内容的变化，适时更新爬虫程序以适应新的抓取需求。当然，原来的爬虫程序需要改进，功能需要增强。

根据这个计划，我初步修改了原来的代码，把要求的三个功能都完成了，看效果：

关键实现代码：

        // 发送HTTP GET请求并获取网页内容
        public async Task<string> GetWebPageContentAsync(string url)
        {
            try
            {
                HttpResponseMessage response=await _httpClient.GetAsync(url);
                response.EnsureSuccessStatusCode();
                string content=await response.Content.ReadAsStringAsync();
                return content;
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine($"从URL {url} 获取内容时出错: {e.Message}");
                return null;
            }
        }

        // 解析网页内容，提取<body>、链接和标题
        public async Task CrawlAndParseAsync(string url)
        {
            string content=await GetWebPageContentAsync(url);
            if (content !=null)
            {
                var document=_htmlParser.ParseDocument(content);

                // 获取并打印<body>的内容
                var bodyContent=document.Body.InnerHtml;
                Console.WriteLine($"网页<body>内容：\n{bodyContent}\n");

                // 提取并打印所有链接
                foreach (var link in document.QuerySelectorAll("a[href]"))
                {
                    var href=link.GetAttribute("href");
                    Console.WriteLine($"找到的链接: {href}");
                }

                // 提取并打印页面标题
                var title=document.Title;
                Console.WriteLine($"页面标题: {title}");
            }
        }

如有需要完整代码的朋友，请关注我并留言。

在线咨询

上一篇：这篇文章值得收藏，尤其是喜欢黑客网络知识的朋友
下一篇：为什么你永远不应该在CSS中使用px来设置字体大小

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

教你用C#实现：简单又高效的“爬虫”程序

您的项目需求