为 npm 设置代理

发表于2020-02-12由jgh004

npm 有两个代理设置，一个是 http 代理，一个是 https 代理。

在命令行设置代理服务器。

#获取 http 请求的代理设置
npm config get proxy
npm config set proxy="http://127.0.0.1:1080"
#获取 https 请求的代理设置
npm config get https-proxy
npm config set https-proxy="http://127.0.0.1:1080"

#获取 http 请求的代理设置

npm config get proxy

npm config set proxy="http://127.0.0.1:1080"

#获取 https 请求的代理设置

npm config get https-proxy

npm config set https-proxy="http://127.0.0.1:1080"

代理服务器可以使用小灰机（小灰机同时支持 socks 代理和 http 代理）阅读全文

为 Visual Studio 设置 NuGet 代理

发表于2020-02-12由jgh004

因为众所周知的原因，在国内使用 NuGet 时会经常无法下载包，严重影响工作效率，下面说一下如何给 NuGet 设置代理。

找到 NuGet 配置文件

NuGet 仅支持 HTTP 代理，Visual Studio 的 NuGet 配置文件位于 “ %appdata%\NuGet\NuGet.Config” 目录，此配置的作用域为当前 Windows 用户，详情可参考微软文档。

设置 NuGet 代理

在 “ <configuration> ” 节下增加 “ <config> ” 节，添加 “ http_proxy” 配置项，值为 HTTP 代理服务器 url。

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <config>
    <add key="http_proxy" value="http://127.0.0.1:1080" />
  </config>
  <packageSources>
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
    <add key="Microsoft Visual Studio Offline Packages" value="C:\Program Files (x86)\Microsoft SDKs\NuGetPackages\" />
  </packageSources>
  <packageRestore>
    <add key="enabled" value="True" />
    <add key="automatic" value="True" />
  </packageRestore>
  <bindingRedirects>
    <add key="skip" value="False" />
  </bindingRedirects>
  <packageManagement>
    <add key="format" value="0" />
    <add key="disabled" value="False" />
  </packageManagement>
  <disabledPackageSources>
    <add key="Microsoft Visual Studio Offline Packages" value="true" />
  </disabledPackageSources>
</configuration>

<?xml version="1.0" encoding="utf-8"?>

</config>

</packageSources>

</packageRestore>

</bindingRedirects>

</packageManagement>

</disabledPackageSources>

</configuration>

代理服务器可以是任何 http 代理，也可以用小灰机代理（小灰机本身即是 socks 代理也是 http 代理）。阅读全文

CentOS 7 安装 .Net Core 环境

发表于2018-06-11由jgh004

当前最新 .net core 版本为 2.1

打开 .net core 下载页面，https://www.microsoft.com/net/download/linux ，页面包含 .net core sdk 及 .net core runtime 两个安装包。

如果需要在 linux 上进行开发，要安装 .net core sdk 版本，不需要开发推荐安装 .net core runtime 版本。

点击 install .NET Core 2.1 Runtime ，进入下载页面,在下拉框中选择 Centos。

按提示输入以下命令

rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm

#如果需要同时支持运行 asp.net core 和 .net core app ,则运行这条命令
yum install aspnetcore-runtime-2.1

#如果只要需运行 .net core app, 不需要 asp.net core ,则运行这条命令
yum install dotnet-runtime-2.1

rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm

#如果需要同时支持运行 asp.net core 和 .net core app ,则运行这条命令

yum install aspnetcore-runtime-2.1

#如果只要需运行 .net core app, 不需要 asp.net core ,则运行这条命令

yum install dotnet-runtime-2.1

安装完成后运行 dotnet –info 查看版本信息

Log4net 配置输出文本, 按年月日分文件夹

发表于2017-06-14由jgh004

在项目中新建 “log4net.config” 文件

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
    </configSections>
    <log4net>
        <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
            <File value="Log\" />
            <!--是否是向文件中追加日志-->
            <AppendToFile value="true" />
            <!--每个文件的大小-->
            <MaximumFileSize value="1MB"/>
            <!--log文件数-->
            <MaxSizeRollBackups value="10" />
            <!--日志文件名是否是固定不变的-->
            <StaticLogFileName value="false" />
            <!--日志文件名格式为:yyyy-MM-dd.log-->
            <DatePattern value="yyyy\\MM\\dd\\yyyy-MM-dd'.log'" />
            <!--日志根据日期滚动-->
            <RollingStyle value="Date" />
            <layout type="log4net.Layout.PatternLayout">
                <ConversionPattern value="%date %logger [%thread] %level %message%newline" />
            </layout>
        </appender>

        <root>
            <!--(高) OFF > FATAL > ERROR > WARN > INFO > DEBUG > ALL (低) -->
            <level value="all" />
            <appender-ref ref="RollingLogFileAppender" />
        </root>
    </log4net>
</configuration>

<?xml version="1.0" encoding="utf-8" ?>

</configSections>

</layout>

</appender>

<root>

<appender-ref ref="RollingLogFileAppender" />

</root>

</log4net>

</configuration>

配置好后在程序集 AssemblyInfo.cs 中加入

[assembly: log4net.Config.XmlConfigurator( ConfigFile = "log4net.config", Watch = true )]

1	[assembly: log4net.Config.XmlConfigurator( ConfigFile = "log4net.config", Watch = true )]

或者用代码初始化

private void InitLog4net()
{
    var logCfg = new FileInfo(AppDomain.CurrentDomain.BaseDirectory + "log4net.config");
    XmlConfigurator.ConfigureAndWatch(logCfg);
    //修改日志路径
    var repository = LogManager.GetRepository();
    var appenders = repository.GetAppenders();
    var targetApder = appenders.First() as RollingFileAppender;
    targetApder.File = string.IsNullOrWhiteSpace(Settings.Default.LogPath) ? Path.Combine( Environment.CurrentDirectory,"log.txt") : Settings.Default.LogPath;
    targetApder.ActivateOptions();

    this.log = LogManager.GetLogger("mainlog");
}

private void InitLog4net()

{

var logCfg = new FileInfo(AppDomain.CurrentDomain.BaseDirectory + "log4net.config");

XmlConfigurator.ConfigureAndWatch(logCfg);

//修改日志路径

var repository = LogManager.GetRepository();

var appenders = repository.GetAppenders();

var targetApder = appenders.First() as RollingFileAppender;

targetApder.File = string.IsNullOrWhiteSpace(Settings.Default.LogPath) ? Path.Combine( Environment.CurrentDirectory,"log.txt") : Settings.Default.LogPath;

targetApder.ActivateOptions();

this.log = LogManager.GetLogger("mainlog");

}

MySql EF6 DBFirst 向导无法生成 edmx 解决方法(同:您的项目引用了最新实体框架；但是，找不到数据链接所需的与版本兼容的实体框架数据库提供程序)

发表于2016-07-04由jgh004

使用 MySql EF6 DBfirst 生成模型时经常会遇到EF6模式无法选择的情况究其原因, 还是因为没有正确的使用 Connector/Net. 下面说一下使用方法. 使用 MySql DBFirst 前先确保安装了 MySql, MySQL for Visual Studio, Connector/Net 注意: MySQL for Visual Studio, Connector/Net 版本要对应 MySql 版本.

新建一个项目, 从 nuget 中添加 EF6

Install-Package EntityFramework

1	Install-Package EntityFramework

在项目的”引用”上点右键添加dll引用. 选择扩展程序集, 勾选 MySql.Data.Entity for EF6 , 注意提示框中的版本, 一个是4.0, 一个是 4.5. 这个dll 是安装 Connector/Net 后才有的.
注意: 用 nuget 安装 MySql.Data.Entity 也会自动引用 MySql.Data.Entity.EF6.dll. 但是这个 dll 在生成 edmx 时会出错. 所以才要像上面一样从扩展中引用 dll

修改 config 文件

添加一行 provider

<provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6" />

1	<provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6" />

添加完如下所示

<entityFramework>
  <defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
    <parameters>
      <parameter value="v12.0" />
    </parameters>
  </defaultConnectionFactory>
  <providers>
    <provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
    <provider invariantName="MySql.Data.MySqlClient" type="MySql.Data.MySqlClient.MySqlProviderServices, MySql.Data.Entity.EF6" />
  </providers>
</entityFramework>

</parameters>

</defaultConnectionFactory>

</providers>

</entityFramework>

重新生成一下项目, 到这里问题就已经解决了. 下面是效果.

在项目中添加新的 “Ado.Net 实体数据模型”(即 edmx 文件)

如果数据源不是 MySql, 点更新, 修改为MySql.如果没有MySql Database , 说明 Connector/Net 没有安装或安装不正确. 重新安装.这里可以正确显示了.

无法正常卸载 Visual Studio 时的处理方法

发表于2015-08-25由jgh004

因某些原因(例如删除了”C:ProgramDataPackage Cache” 中的内容)无法在卸载程序界面中卸载 VS, 可以使用下面的方法卸载.

首先准备 VS 安装介质, 如 .iso 文件, 加载到虚拟光驱中.

再以管理员权限运行 CMD, 转到虚拟光驱的盘符, 输入以下命令

vs_community.exe /uninstall /force

1	vs_community.exe /uninstall /force

我的是社区版本, 如果是专业版或企业版, 只要将 vs_community 替换为对应介质中的程序名即可.

(转) C#如何验证一个PE文件的数字签名是否正确（1）

发表于2013-12-16由jgh004

本文转自 http://www.blogbus.com/softone-logs/105678346.html

作者：Eckel Chung blog地址：http://softone.blogbus.com/ 转载请保留

—————————————————————————

（1）前言

和网上大量的讨论如何制作数字签名和验证数字签名的文章本同，本文使用微软自带的API进行PE文件数字签名有效性的验证，使用语言C#。

我们可以在windows系统下直接右键查看某个PE文件数字签名的有效性，如下图：

这让我们想到，微软必然自带了对PE文件数字签名的验证办法，经过查找资料，确定其来自下图所示的dll文件里的WinVerifyTrust函数。

该函数在C#里的调用原型如下：

[DllImport("wintrust.dll", PreserveSig = true, SetLastError = false)]
private static extern uint WinVerifyTrust(IntPtr hWnd, IntPtr pgActionID, IntPtr pWinTrustData);

1 2	[DllImport("wintrust.dll", PreserveSig = true, SetLastError = false)] private static extern uint WinVerifyTrust(IntPtr hWnd, IntPtr pgActionID, IntPtr pWinTrustData);

关于这个函数的使用，可以查看MSDN上的说明。

(2) 构建将要用到的数据结构

根据微软官方材料，我们在使用这个函数前还得先准备几个数据结构：

using System;
using System.Runtime.InteropServices;

namespace VerifyDigitalSignature
{
	public enum AllocMethod
	{
		HGlobal,
		CoTaskMem
	}

	public enum UnionChoice
	{
		File = 1,
		Catalog,
		Blob,
		Signer,
		Cert
	}

	public enum UiChoice
	{
		All = 1,
		NoUI,
		NoBad,
		NoGood
	}

	public enum RevocationCheckFlags
	{
		None = 0,
		WholeChain
	}

	public enum StateAction
	{
		Ignore = 0,
		Verify,
		Close,
		AutoCache,
		AutoCacheFlush
	}

	public enum TrustProviderFlags
	{
		UseIE4Trust = 1,
		NoIE4Chain = 2,
		NoPolicyUsage = 4,
		RevocationCheckNone = 16,
		RevocationCheckEndCert = 32,
		RevocationCheckChain = 64,
		RecovationCheckChainExcludeRoot = 128,
		Safer = 256,
		HashOnly = 512,
		UseDefaultOSVerCheck = 1024,
		LifetimeSigning = 2048
	}

	public enum UIContext
	{
		Execute = 0,
		Install
	}

	#region UnmanagedPointer class

	internal sealed class UnmanagedPointer : IDisposable
	{
		private IntPtr m_ptr;
		private AllocMethod m_meth;

		internal UnmanagedPointer( IntPtr ptr, AllocMethod method )
		{
			m_meth = method;
			m_ptr = ptr;
		}

		~UnmanagedPointer()
		{
			Dispose( false );
		}

		#region IDisposable Members

		private void Dispose( bool disposing )
		{
			if ( m_ptr != IntPtr.Zero )
			{
				if ( m_meth == AllocMethod.HGlobal )
				{
					Marshal.FreeHGlobal( m_ptr );
				}
				else if ( m_meth == AllocMethod.CoTaskMem )
				{
					Marshal.FreeCoTaskMem( m_ptr );
				}

				m_ptr = IntPtr.Zero;
			}

			if ( disposing )
			{
				GC.SuppressFinalize( this );
			}
		}

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

		#endregion

		public static implicit operator IntPtr( UnmanagedPointer ptr )
		{
			return ptr.m_ptr;
		}
	}

	#endregion

	internal struct WINTRUST_FILE_INFO : IDisposable
	{
		public WINTRUST_FILE_INFO( string fileName, Guid subject )
		{
			cbStruct = (uint)Marshal.SizeOf( typeof( WINTRUST_FILE_INFO ) );
			pcwszFilePath = fileName;

			if ( subject != Guid.Empty )
			{
				pgKnownSubject = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( Guid ) ) );
				Marshal.StructureToPtr( subject, pgKnownSubject, true );
			}
			else
			{
				pgKnownSubject = IntPtr.Zero;
			}

			hFile = IntPtr.Zero;
		}

		public uint cbStruct;
		[MarshalAs( UnmanagedType.LPTStr )]
		public string pcwszFilePath;
		public IntPtr hFile;
		public IntPtr pgKnownSubject;

		#region IDisposable Members

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

		private void Dispose( bool disposing )
		{
			if ( pgKnownSubject != IntPtr.Zero )
			{
				Marshal.DestroyStructure( this.pgKnownSubject, typeof( Guid ) );
				Marshal.FreeHGlobal( this.pgKnownSubject );
			}
		}

		#endregion
	}

	[StructLayout( LayoutKind.Sequential )]
	internal struct WINTRUST_DATA : IDisposable
	{
		public WINTRUST_DATA( WINTRUST_FILE_INFO fileInfo )
		{
			this.cbStruct = (uint)Marshal.SizeOf( typeof( WINTRUST_DATA ) );
			pInfoStruct = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( WINTRUST_FILE_INFO ) ) );
			Marshal.StructureToPtr( fileInfo, pInfoStruct, true );
			this.dwUnionChoice = UnionChoice.File;

			pPolicyCallbackData = IntPtr.Zero;
			pSIPCallbackData = IntPtr.Zero;

			dwUIChoice = UiChoice.NoUI;
			fdwRevocationChecks = RevocationCheckFlags.None;
			dwStateAction = StateAction.Ignore;
			hWVTStateData = IntPtr.Zero;
			pwszURLReference = IntPtr.Zero;
			dwProvFlags = TrustProviderFlags.Safer;

			dwUIContext = UIContext.Execute;
		}

		public uint cbStruct;
		public IntPtr pPolicyCallbackData;
		public IntPtr pSIPCallbackData;
		public UiChoice dwUIChoice;
		public RevocationCheckFlags fdwRevocationChecks;
		public UnionChoice dwUnionChoice;
		public IntPtr pInfoStruct;
		public StateAction dwStateAction;
		public IntPtr hWVTStateData;
		private IntPtr pwszURLReference;
		public TrustProviderFlags dwProvFlags;
		public UIContext dwUIContext;

		#region IDisposable Members

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

		private void Dispose( bool disposing )
		{
			if ( dwUnionChoice == UnionChoice.File )
			{
				//WINTRUST_FILE_INFO info = new WINTRUST_FILE_INFO();
				//Marshal.PtrToStructure(pInfoStruct, info);
				//info.Dispose();
				Marshal.DestroyStructure( pInfoStruct, typeof( WINTRUST_FILE_INFO ) );
			}

			Marshal.FreeHGlobal( pInfoStruct );
		}

		#endregion
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

using System;

using System.Runtime.InteropServices;

namespace VerifyDigitalSignature

{

public enum AllocMethod

{

HGlobal,

CoTaskMem

}

public enum UnionChoice

{

File = 1,

Catalog,

Blob,

Signer,

Cert

}

public enum UiChoice

{

All = 1,

NoUI,

NoBad,

NoGood

}

public enum RevocationCheckFlags

{

None = 0,

WholeChain

}

public enum StateAction

{

Ignore = 0,

Verify,

Close,

AutoCache,

AutoCacheFlush

}

public enum TrustProviderFlags

{

UseIE4Trust = 1,

NoIE4Chain = 2,

NoPolicyUsage = 4,

RevocationCheckNone = 16,

RevocationCheckEndCert = 32,

RevocationCheckChain = 64,

RecovationCheckChainExcludeRoot = 128,

Safer = 256,

HashOnly = 512,

UseDefaultOSVerCheck = 1024,

LifetimeSigning = 2048

}

public enum UIContext

{

Execute = 0,

Install

}

#region UnmanagedPointer class

internal sealed class UnmanagedPointer : IDisposable

{

private IntPtr m_ptr;

private AllocMethod m_meth;

internal UnmanagedPointer( IntPtr ptr, AllocMethod method )

{

m_meth = method;

m_ptr = ptr;

}

~UnmanagedPointer()

{

Dispose( false );

}

#region IDisposable Members

private void Dispose( bool disposing )

{

if ( m_ptr != IntPtr.Zero )

{

if ( m_meth == AllocMethod.HGlobal )

{

Marshal.FreeHGlobal( m_ptr );

}

else if ( m_meth == AllocMethod.CoTaskMem )

{

Marshal.FreeCoTaskMem( m_ptr );

}

m_ptr = IntPtr.Zero;

}

if ( disposing )

{

GC.SuppressFinalize( this );

}

public void Dispose()

{

Dispose( true );

}

#endregion

public static implicit operator IntPtr( UnmanagedPointer ptr )

{

return ptr.m_ptr;

}

#endregion

internal struct WINTRUST_FILE_INFO : IDisposable

{

public WINTRUST_FILE_INFO( string fileName, Guid subject )

{

cbStruct = (uint)Marshal.SizeOf( typeof( WINTRUST_FILE_INFO ) );

pcwszFilePath = fileName;

if ( subject != Guid.Empty )

{

pgKnownSubject = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( Guid ) ) );

Marshal.StructureToPtr( subject, pgKnownSubject, true );

}

else

{

pgKnownSubject = IntPtr.Zero;

}

hFile = IntPtr.Zero;

}

public uint cbStruct;

[MarshalAs( UnmanagedType.LPTStr )]

public string pcwszFilePath;

public IntPtr hFile;

public IntPtr pgKnownSubject;

#region IDisposable Members

public void Dispose()

{

Dispose( true );

}

private void Dispose( bool disposing )

{

if ( pgKnownSubject != IntPtr.Zero )

{

Marshal.DestroyStructure( this.pgKnownSubject, typeof( Guid ) );

Marshal.FreeHGlobal( this.pgKnownSubject );

}

#endregion

}

[StructLayout( LayoutKind.Sequential )]

internal struct WINTRUST_DATA : IDisposable

{

public WINTRUST_DATA( WINTRUST_FILE_INFO fileInfo )

{

this.cbStruct = (uint)Marshal.SizeOf( typeof( WINTRUST_DATA ) );

pInfoStruct = Marshal.AllocHGlobal( Marshal.SizeOf( typeof( WINTRUST_FILE_INFO ) ) );

Marshal.StructureToPtr( fileInfo, pInfoStruct, true );

this.dwUnionChoice = UnionChoice.File;

pPolicyCallbackData = IntPtr.Zero;

pSIPCallbackData = IntPtr.Zero;

dwUIChoice = UiChoice.NoUI;

fdwRevocationChecks = RevocationCheckFlags.None;

dwStateAction = StateAction.Ignore;

hWVTStateData = IntPtr.Zero;

pwszURLReference = IntPtr.Zero;

dwProvFlags = TrustProviderFlags.Safer;

dwUIContext = UIContext.Execute;

}

public uint cbStruct;

public IntPtr pPolicyCallbackData;

public IntPtr pSIPCallbackData;

public UiChoice dwUIChoice;

public RevocationCheckFlags fdwRevocationChecks;

public UnionChoice dwUnionChoice;

public IntPtr pInfoStruct;

public StateAction dwStateAction;

public IntPtr hWVTStateData;

private IntPtr pwszURLReference;

public TrustProviderFlags dwProvFlags;

public UIContext dwUIContext;

#region IDisposable Members

public void Dispose()

{

Dispose( true );

}

private void Dispose( bool disposing )

{

if ( dwUnionChoice == UnionChoice.File )

{

//WINTRUST_FILE_INFO info = new WINTRUST_FILE_INFO();

//Marshal.PtrToStructure(pInfoStruct, info);

//info.Dispose();

Marshal.DestroyStructure( pInfoStruct, typeof( WINTRUST_FILE_INFO ) );

}

Marshal.FreeHGlobal( pInfoStruct );

}

#endregion

}

（3）构建我们的验证类

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using Microsoft.Win32;

namespace VerifyDigitalSignature
{
        public class Authentication
	{
		[DllImport( "wintrust.dll", PreserveSig = true, SetLastError = false )]
		private static extern uint WinVerifyTrust( IntPtr hWnd, IntPtr pgActionID, IntPtr pWinTrustData );

		private static List<Guid> GetTrustGuid()
		{
			//HKEY_LOCAL_MACHINESOFTWAREMicrosoftCryptographyProvidersTrustInitialization
			List<Guid> trustGuids = new List<Guid>();
			RegistryKey hklm = Registry.LocalMachine;
			RegistryKey initialization = hklm.OpenSubKey( @"SOFTWAREMicrosoftCryptographyProvidersTrustInitialization" );
			string[] guidNames = initialization.GetSubKeyNames();

			foreach ( string guidName in guidNames )
			{
				trustGuids.Add( new Guid( guidName ) );
			}

			return trustGuids;
		}

		public static uint CSWinVerifyTrust( string fileName )
		{
			uint result = 1516356;

			try
			{
				List<Guid> trustGuids = GetTrustGuid();

				foreach ( Guid guid in trustGuids )
				{
					Guid wintrust_action_generic_verify_v2 = guid;

					WINTRUST_FILE_INFO fileInfo = new WINTRUST_FILE_INFO( fileName, Guid.Empty );
					WINTRUST_DATA data = new WINTRUST_DATA( fileInfo );
					UnmanagedPointer guidPtr = new UnmanagedPointer( Marshal.AllocHGlobal( Marshal.SizeOf( typeof( Guid ) ) ), AllocMethod.HGlobal );
					UnmanagedPointer wvtDataPtr = new UnmanagedPointer( Marshal.AllocHGlobal( Marshal.SizeOf( typeof( WINTRUST_DATA ) ) ), AllocMethod.HGlobal );

					IntPtr pGuid = guidPtr;
					IntPtr pData = wvtDataPtr;

					Marshal.StructureToPtr( wintrust_action_generic_verify_v2, pGuid, true );
					Marshal.StructureToPtr( data, pData, true );

					result = WinVerifyTrust( IntPtr.Zero, pGuid, pData );

					if ( result == 0 )
					{
						break;
					}
				}
			}
			catch ( Exception ex )
			{
				throw new Exception( "VerifyDigitalSignature error.", ex );
			}

			return result;
		}
	}
}

using System;

using System.Collections.Generic;

using System.Runtime.InteropServices;

using Microsoft.Win32;

namespace VerifyDigitalSignature

{

public class Authentication

{

[DllImport( "wintrust.dll", PreserveSig = true, SetLastError = false )]

private static extern uint WinVerifyTrust( IntPtr hWnd, IntPtr pgActionID, IntPtr pWinTrustData );

private static List<Guid> GetTrustGuid()

{

//HKEY_LOCAL_MACHINESOFTWAREMicrosoftCryptographyProvidersTrustInitialization

List<Guid> trustGuids = new List<Guid>();

RegistryKey hklm = Registry.LocalMachine;

RegistryKey initialization = hklm.OpenSubKey( @"SOFTWAREMicrosoftCryptographyProvidersTrustInitialization" );

string[] guidNames = initialization.GetSubKeyNames();

foreach ( string guidName in guidNames )

{

trustGuids.Add( new Guid( guidName ) );

}

return trustGuids;

}

public static uint CSWinVerifyTrust( string fileName )

{

uint result = 1516356;

try

{

List<Guid> trustGuids = GetTrustGuid();

foreach ( Guid guid in trustGuids )

{

Guid wintrust_action_generic_verify_v2 = guid;

WINTRUST_FILE_INFO fileInfo = new WINTRUST_FILE_INFO( fileName, Guid.Empty );

WINTRUST_DATA data = new WINTRUST_DATA( fileInfo );

UnmanagedPointer guidPtr = new UnmanagedPointer( Marshal.AllocHGlobal( Marshal.SizeOf( typeof( Guid ) ) ), AllocMethod.HGlobal );

UnmanagedPointer wvtDataPtr = new UnmanagedPointer( Marshal.AllocHGlobal( Marshal.SizeOf( typeof( WINTRUST_DATA ) ) ), AllocMethod.HGlobal );

IntPtr pGuid = guidPtr;

IntPtr pData = wvtDataPtr;

Marshal.StructureToPtr( wintrust_action_generic_verify_v2, pGuid, true );

Marshal.StructureToPtr( data, pData, true );

result = WinVerifyTrust( IntPtr.Zero, pGuid, pData );

if ( result == 0 )

{

break;

}

catch ( Exception ex )

{

throw new Exception( "VerifyDigitalSignature error.", ex );

}

return result;

}

注意这里，WinVerifyTrust的返回值有多种，0表示数字签名各项指标都是正常的，其他代码我们下一部分再来讨论。

实测通过：

Fiddler 过滤 css,图片等请求url 正则表达式

发表于2013-12-06由jgh004

设置步骤:
1.勾选 Request Headers 中的 Hide if url contains 过滤项
2.贴入下方正则表达式

REGEX:(?insx)/[^?/]*.(css|ico|jpg|png|gif|bmp|wav)(?.*)?$

1	REGEX:(?insx)/[^?/].(css\|ico\|jpg\|png\|gif\|bmp\|wav)(?.)?$

REGEX: 表示启用正则表达式
(?insx) 设置正则解释的规则, 忽略大小写等.

此表达式表示过滤掉 url 中包括 css, ico, jpg 等后缀的请求.

C# 使用 Socket 实现 http 协议全功能版

发表于2013-06-02由jgh004

有人说用 Socket 请求 http 服务效率要比 HttpWebRequest 高很多, 但是又没有提供源码或者对比测试结果. 我对此很好奇, 到底能差多少? 所以决定自己写个类实现 Socket 请求 http 的功能.

下面的代码实现了基本的 http ,https 请求, 支持 gzip 解压, 分块传输.

经本人多次试验, 得出如下结论:

如果仅用 Socket 获取文本类型的内容, 且不考虑分块传输的情况, 那么 Socket 方式可比 HttpWebRequest 方式效率高 30%-40%.

如果考虑更多因素,需要做更多处理, 所以多数时候效率不如 HttpWebRequest, 当然与我写的代码效率有很大关系.

欢迎共同探讨技术问题,提供建议, 请留言,我会尽快回复.

/* Name:	Socket 实现 http 协议全功能版
 * Version: v0.6
 * Description: 此版本实现了 http 及 https 的 get 或 post 访问, 自动处理301,302跳转, 支持 gzip 解压, 分块传输.
 *				支持的操作: 获取文本,图片,文件形式的内容.
 * 使用方法:	new HttpWebSocket(); 调用实例的 Get.... 方法.
 * 声明:		本代码仅做技术探讨,可任意转载,请勿用于商业用途.
 * 本人博客:	http://blog.itnmg.net   http://www.cnblogs.com/lhg-net
 * 创建日期:	2013-01-15
 * 修订日期:	2013-06-03
 */
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Net.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.IO;
using System.IO.Compression;
using System.Web;
using System.Drawing;
using System.Security.Cryptography.X509Certificates;

namespace ExtLibrary.Net
{
	class HttpWebSocket
	{
		/// <summary>
		/// 获取或设置请求与回应的超时时间,默认3秒.
		/// </summary>
		public int TimeOut
		{
			get;
			set;
		}

		/// <summary>
		/// 获取或设置请求cookie
		/// </summary>
		public List<string> Cookies
		{
			get;
			set;
		}

		/// <summary>
		/// 获取请求返回的 HTTP 头部内容
		/// </summary>
		public HttpHeader HttpHeaders
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取或设置错误信息分隔符
		/// </summary>
		private string ErrorMessageSeparate;

		public HttpWebSocket()
		{
			this.TimeOut = 3;
			this.Cookies = new List<string>();
			this.ErrorMessageSeparate = ";;";
			this.HttpHeaders = new HttpHeader();
		}

		/// <summary>
		/// get或post方式请求一个 http 或 https 地址.使用 Socket 方式
		/// </summary>
		/// <param name="url">请求绝对地址</param>
		/// <param name="referer">请求来源地址,可为空</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <returns>返回图像</returns>
		public Image GetImageUseSocket( string url, string referer, string postData = null )
		{
			Image result = null;
			MemoryStream ms = this.GetSocketResult( url, referer, postData );

			try
			{
				if ( ms != null )
				{
					result = Image.FromStream( ms );
				}
			}
			catch ( Exception e )
			{
				string ss = e.Message;
			}

			return result;
		}

		/// <summary>
		/// get或post方式请求一个 http 或 https 地址.使用 Socket 方式
		/// </summary>
		/// <param name="url">请求绝对地址</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <returns>返回 html 内容,如果发生异常将返回上次http状态码及异常信息</returns>
		public string GetHtmlUseSocket( string url, string postData = null )
		{
			return this.GetHtmlUseSocket( url, null, postData );
		}

		/// <summary>
		/// get或post方式请求一个 http 或 https 地址.使用 Socket 方式
		/// </summary>
		/// <param name="url">请求绝对地址</param>
		/// <param name="referer">请求来源地址,可为空</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <returns>返回 html 内容,如果发生异常将返回上次http状态码及异常信息</returns>
		public string GetHtmlUseSocket( string url, string referer, string postData = null )
		{
			string result = string.Empty;

			try
			{
				MemoryStream ms = this.GetSocketResult( url, referer, postData );

				if ( ms != null )
				{
					result = Encoding.GetEncoding( string.IsNullOrWhiteSpace( this.HttpHeaders.Charset ) ? "UTF-8" : this.HttpHeaders.Charset ).GetString( ms.ToArray() );
				}
			}
			catch ( SocketException se )
			{
				result = this.HttpHeaders.ResponseStatusCode + this.ErrorMessageSeparate + se.ErrorCode.ToString() + this.ErrorMessageSeparate + se.SocketErrorCode.ToString( "G" ) + this.ErrorMessageSeparate + se.Message;
			}
			catch ( Exception e )
			{
				result = this.HttpHeaders.ResponseStatusCode + this.ErrorMessageSeparate + e.Message;
			}

			return result;
		}

		/// <summary>
		/// get或post方式请求一个 http 或 https 地址.
		/// </summary>
		/// <param name="url">请求绝对地址</param>
		/// <param name="referer">请求来源地址,可为空</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <returns>返回的已解压的数据内容</returns>
		private MemoryStream GetSocketResult( string url, string referer, string postData )
		{
			if ( string.IsNullOrWhiteSpace( url ) )
			{
				throw new UriFormatException( "'Url' cannot be empty." );
			}

			MemoryStream result = null;
			Uri uri = new Uri( url );

			if ( uri.Scheme == "http" )
			{
				result = this.GetHttpResult( uri, referer, postData );
			}
			else if ( uri.Scheme == "https" )
			{
				result = this.GetSslResult( uri, referer, postData );
			}
			else
			{
				throw new ArgumentException( "url must start with HTTP or HTTPS.", "url" );
			}

			if ( !string.IsNullOrWhiteSpace( this.HttpHeaders.Location ) )
			{
				result = GetSocketResult( this.HttpHeaders.Location, uri.AbsoluteUri, null );
			}
			else
			{
				result = unGzip( result );
			}

			return result;
		}

		/// <summary>
		/// get或post方式请求一个 http 地址.
		/// </summary>
		/// <param name="uri">请求绝对地址</param>
		/// <param name="referer">请求来源地址,可为空</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <param name="headText">输出包含头部内容的StringBuilder</param>
		/// <returns>返回未解压的数据流</returns>
		private MemoryStream GetHttpResult( Uri uri, string referer, string postData )
		{
			MemoryStream result = new MemoryStream( 10240 );
			Socket HttpSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );
			HttpSocket.SendTimeout = this.TimeOut * 1000;
			HttpSocket.ReceiveTimeout = this.TimeOut * 1000;

			try
			{
				byte[] send = GetSendHeaders( uri, referer, postData );
				HttpSocket.Connect( uri.Host, uri.Port );

				if ( HttpSocket.Connected )
				{
					HttpSocket.Send( send, SocketFlags.None );
					this.ProcessData( HttpSocket, ref result );
				}

				result.Flush();
			}
			finally
			{
				HttpSocket.Shutdown( SocketShutdown.Both );
				HttpSocket.Close();
			}

			result.Seek( 0, SeekOrigin.Begin );

			return result;
		}

		/// <summary>
		/// get或post方式请求一个 https 地址.
		/// </summary>
		/// <param name="uri">请求绝对地址</param>
		/// <param name="referer">请求来源地址,可为空</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <param name="headText">输出包含头部内容的StringBuilder</param>
		/// <returns>返回未解压的数据流</returns>
		private MemoryStream GetSslResult( Uri uri, string referer, string postData )
		{
			MemoryStream result = new MemoryStream( 10240 );
			StringBuilder sb = new StringBuilder( 1024 );

			byte[] send = GetSendHeaders( uri, referer, postData );
			TcpClient client = new TcpClient( uri.Host, uri.Port );

			try
			{
				SslStream sslStream = new SslStream( client.GetStream(), true
					, new RemoteCertificateValidationCallback( ( sender, certificate, chain, sslPolicyErrors )
						=>  {
								return sslPolicyErrors == SslPolicyErrors.None;
							}
						), null );
				sslStream.ReadTimeout = this.TimeOut * 1000;
				sslStream.WriteTimeout = this.TimeOut * 1000;

				X509Store store = new X509Store( StoreName.My );

				sslStream.AuthenticateAsClient( uri.Host, store.Certificates, System.Security.Authentication.SslProtocols.Default, false );

				if ( sslStream.IsAuthenticated )
				{
					sslStream.Write( send, 0, send.Length );
					sslStream.Flush();

					this.ProcessData( sslStream, ref result );
				}

				result.Flush();
			}
			finally
			{
				client.Close();
			}

			result.Seek( 0, SeekOrigin.Begin );

			return result;
		}

		/// <summary>
		/// 返回请求的头部内容
		/// </summary>
		/// <param name="uri">请求绝对地址</param>
		/// <param name="referer">请求来源地址,可为空</param>
		/// <param name="postData">post请求参数. 设置空值为get方式请求</param>
		/// <returns>请求头部数据</returns>
		private byte[] GetSendHeaders( Uri uri, string referer, string postData )
		{
			string sendString = @"{0} {1} HTTP/1.1
Accept: text/html, application/xhtml+xml, */*
Referer: {2}
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)
Accept-Encoding: gzip, deflate
Host: {3}
Connection: Keep-Alive
Cache-Control: no-cache
";

			sendString = string.Format( sendString, string.IsNullOrWhiteSpace( postData ) ? "GET" : "POST", uri.PathAndQuery
				, string.IsNullOrWhiteSpace( referer ) ? uri.AbsoluteUri : referer, uri.Host );

			if ( this.Cookies != null && this.Cookies.Count > 0 )
			{
				sendString += string.Format( "Cookie: {0}rn", string.Join( "; ", this.Cookies.ToArray() ) );
			}

			if ( string.IsNullOrWhiteSpace( postData ) )
			{
				sendString += "rn";
			}
			else
			{
				int dlength = Encoding.UTF8.GetBytes( postData ).Length;

				sendString += string.Format( @"Content-Type: application/x-www-form-urlencoded
Content-Length: {0}

{1}
", postData.Length, postData );
			}

			return Encoding.UTF8.GetBytes( sendString );
			;
		}

		/// <summary>
		/// 设置此类的字段
		/// </summary>
		/// <param name="headText">头部文本</param>
		private void SetThisHeaders( string headText )
		{
			if ( string.IsNullOrWhiteSpace( headText ) )
			{
				throw new ArgumentNullException( "'WithHeadersText' cannot be empty." );
			}

			//Match m = Regex.Match( withHeadersText,@".*(?=rnrn)",  RegexOptions.Singleline | RegexOptions.IgnoreCase );

			//if ( m == null || string.IsNullOrWhiteSpace( m.Value ) )
			//{
			//	throw new HttpParseException( "'SetThisHeaders' method has bug." );
			//}

			string[] headers = headText.Split( new string[] { "rn" }, StringSplitOptions.RemoveEmptyEntries );

			if ( headers == null || headers.Length == 0 )
			{
				throw new ArgumentException( "'WithHeadersText' param format error." );
			}

			this.HttpHeaders = new HttpHeader();

			foreach ( string head in headers )
			{
				if ( head.StartsWith( "HTTP", StringComparison.OrdinalIgnoreCase ) )
				{
					string[] ts = head.Split( ' ' );
					if ( ts.Length > 1 )
					{
						this.HttpHeaders.ResponseStatusCode = ts[1];
					}
				}
				else if ( head.StartsWith( "Set-Cookie:", StringComparison.OrdinalIgnoreCase ) )
				{
					this.Cookies = this.Cookies ?? new List<string>();
					string tCookie = head.Substring( 11, head.IndexOf( ";" ) < 0 ? head.Length - 11 : head.IndexOf( ";" ) - 10 ).Trim();

					if ( !this.Cookies.Exists( f => f.Split( '=' )[0] == tCookie.Split( '=' )[0] ) )
					{
						this.Cookies.Add( tCookie );
					}
				}
				else if ( head.StartsWith( "Location:", StringComparison.OrdinalIgnoreCase ) )
				{
					this.HttpHeaders.Location = head.Substring( 9 ).Trim();
				}
				else if ( head.StartsWith( "Content-Encoding:", StringComparison.OrdinalIgnoreCase ) )
				{
					if ( head.IndexOf( "gzip", StringComparison.OrdinalIgnoreCase ) >= 0 )
					{
						this.HttpHeaders.IsGzip = true;
					}
				}
				else if ( head.StartsWith( "Content-Type:", StringComparison.OrdinalIgnoreCase ) )
				{
					string[] types = head.Substring( 13 ).Split( new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries );

					foreach ( string t in types )
					{
						if ( t.IndexOf( "charset=", StringComparison.OrdinalIgnoreCase ) >= 0 )
						{
							this.HttpHeaders.Charset = t.Trim().Substring( 8 );
						}
						else if ( t.IndexOf( '/' ) >= 0 )
						{
							this.HttpHeaders.ContentType = t.Trim();
						}
					}
				}
				else if ( head.StartsWith( "Content-Length:", StringComparison.OrdinalIgnoreCase ) )
				{
					this.HttpHeaders.ContentLength = long.Parse( head.Substring( 15 ).Trim() );
				}
				else if ( head.StartsWith( "Transfer-Encoding:", StringComparison.OrdinalIgnoreCase ) && head.EndsWith( "chunked", StringComparison.OrdinalIgnoreCase ) )
				{
					this.HttpHeaders.IsChunk = true;
				}
			}
		}

		/// <summary>
		/// 解压数据流
		/// </summary>
		/// <param name="data">数据流, 压缩或未压缩的.</param>
		/// <returns>返回解压缩的数据流</returns>
		private MemoryStream unGzip( MemoryStream data )
		{
			if ( data == null )
			{
				throw new ArgumentNullException( "data cannot be null.", "data" );
			}

			data.Seek( 0, SeekOrigin.Begin );
			MemoryStream result = data;

			if ( this.HttpHeaders.IsGzip )
			{
				GZipStream gs = new GZipStream( data, CompressionMode.Decompress );
				result = new MemoryStream( 1024 );

				try
				{
					byte[] buffer = new byte[1024];
					int length = -1;

					do
					{
						length = gs.Read( buffer, 0, buffer.Length );
						result.Write( buffer, 0, length );
					}
					while ( length != 0 );

					gs.Flush();
					result.Flush();
				}
				finally
				{
					gs.Close();
				}
			}

			return result;
		}

		/// <summary>
		/// 处理请求返回的数据.
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">数据源实例</param>
		/// <param name="body">保存数据的流</param>
		private void ProcessData<T>( T reader, ref MemoryStream body )
		{
			byte[] data = new byte[10240];
			int bodyStart = -1;//数据部分起始位置
			int readLength = 0;

			bodyStart = GetHeaders( reader, ref data, ref readLength );

			if ( bodyStart >= 0 )
			{
				if ( this.HttpHeaders.IsChunk )
				{
					GetChunkData( reader, ref data, ref bodyStart, ref readLength, ref body );
				}
				else
				{
					GetBodyData( reader, ref data, bodyStart, readLength, ref body );
				}
			}
		}

		/// <summary>
		/// 取得返回的http头部内容,并设置相关属性.
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">数据源实例</param>
		/// <param name="data">待处理的数据</param>
		/// <param name="readLength">读取的长度</param>
		/// <returns>数据内容的起始位置,返回-1表示未读完头部内容</returns>
		private int GetHeaders<T>( T reader, ref byte[] data, ref int readLength )
		{
			int result = -1;
			StringBuilder sb = new StringBuilder( 1024 );

			do
			{
				readLength = this.ReadData( reader, ref data );

				if ( result < 0 )
				{
					for ( int i = 0; i < data.Length; i++ )
					{
						char c = (char)data[i];
						sb.Append( c );

						if ( c == 'n' && string.Concat( sb[sb.Length - 4], sb[sb.Length - 3], sb[sb.Length - 2], sb[sb.Length - 1] ).Contains( "rnrn" ) )
						{
							result = i + 1;
							this.SetThisHeaders( sb.ToString() );
							break;
						}
					}
				}

				if ( result >= 0 )
				{
					break;
				}
			}
			while ( readLength > 0 );

			return result;
		}

		/// <summary>
		/// 取得未分块数据的内容
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">数据源实例</param>
		/// <param name="data">已读取未处理的字节数据</param>
		/// <param name="startIndex">起始位置</param>
		/// <param name="readLength">读取的长度</param>
		/// <param name="body">保存块数据的流</param>
		private void GetBodyData<T>( T reader, ref byte[] data, int startIndex, int readLength, ref MemoryStream body )
		{
			int contentTotal = 0;

			if ( startIndex < data.Length )
			{
				int count = readLength - startIndex;
				body.Write( data, startIndex, count );
				contentTotal += count;
			}

			int tlength = 0;

			do
			{
				tlength = this.ReadData( reader, ref data );
				contentTotal += tlength;
				body.Write( data, 0, tlength );

				if ( this.HttpHeaders.ContentLength > 0 && contentTotal >= this.HttpHeaders.ContentLength )
				{
					break;
				}
			}
			while ( tlength > 0 );
		}

		/// <summary>
		/// 取得分块数据
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">Socket实例</param>
		/// <param name="data">已读取未处理的字节数据</param>
		/// <param name="startIndex">起始位置</param>
		/// <param name="readLength">读取的长度</param>
		/// <param name="body">保存块数据的流</param>
		private void GetChunkData<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength, ref MemoryStream body )
		{
			int chunkSize = -1;//每个数据块的长度,用于分块数据.当长度为0时,说明读到数据末尾.

			while ( true )
			{
				chunkSize = this.GetChunkHead( reader, ref data, ref startIndex, ref readLength );
				this.GetChunkBody( reader, ref data, ref startIndex, ref readLength, ref body, chunkSize );

				if ( chunkSize <= 0 )
				{
					break;
				}
			}
		}

		/// <summary>
		/// 取得分块数据的数据长度
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">Socket实例</param>
		/// <param name="data">已读取未处理的字节数据</param>
		/// <param name="startIndex">起始位置</param>
		/// <param name="readLength">读取的长度</param>
		/// <returns>块长度,返回0表示已到末尾.</returns>
		private int GetChunkHead<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength )
		{
			int chunkSize = -1;
			List<char> tChars = new List<char>();//用于临时存储块长度字符

			if ( startIndex >= data.Length || startIndex >= readLength )
			{
				readLength = this.ReadData( reader, ref data );
				startIndex = 0;
			}

			do
			{
				for ( int i = startIndex; i < readLength; i++ )
				{
					char c = (char)data[i];

					if ( c == 'n' )
					{
						try
						{
							chunkSize = Convert.ToInt32( new string( tChars.ToArray() ).TrimEnd( 'r' ), 16 );
							startIndex = i + 1;
						}
						catch ( Exception e )
						{
							throw new Exception( "Maybe exists 'chunk-ext' field.", e );
						}

						break;
					}

					tChars.Add( c );
				}

				if ( chunkSize >= 0 )
				{
					break;
				}

				startIndex = 0;
				readLength = this.ReadData( reader, ref data );
			}
			while ( readLength > 0 );

			return chunkSize;
		}

		/// <summary>
		/// 取得分块传回的数据内容
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">Socket实例</param>
		/// <param name="data">已读取未处理的字节数据</param>
		/// <param name="startIndex">起始位置</param>
		/// <param name="readLength">读取的长度</param>
		/// <param name="body">保存块数据的流</param>
		/// <param name="chunkSize">块长度</param>
		private void GetChunkBody<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength, ref MemoryStream body, int chunkSize )
		{
			if ( chunkSize <= 0 )
			{
				return;
			}

			int chunkReadLength = 0;//每个数据块已读取长度

			if ( startIndex >= data.Length || startIndex >= readLength )
			{
				readLength = this.ReadData( reader, ref data );
				startIndex = 0;
			}

			do
			{
				int owing = chunkSize - chunkReadLength;
				int count = Math.Min( readLength - startIndex, owing );

				body.Write( data, startIndex, count );
				chunkReadLength += count;

				if ( owing <= count )
				{
					startIndex += count + 2;
					break;
				}

				startIndex = 0;
				readLength = this.ReadData( reader, ref data );
			}
			while ( readLength > 0 );
		}

		/// <summary>
		/// 从数据源读取数据
		/// </summary>
		/// <typeparam name="T">数据源类型</typeparam>
		/// <param name="reader">数据源</param>
		/// <param name="data">用于存储读取的数据</param>
		/// <returns>读取的数据长度,无数据为-1</returns>
		private int ReadData<T>( T reader, ref byte[] data )
		{
			int result = -1;

			if ( reader is Socket )
			{
				result = (reader as Socket).Receive( data, SocketFlags.None );
			}
			else if ( reader is SslStream )
			{
				result = (reader as SslStream).Read( data, 0, data.Length );
			}

			return result;
		}
	}

	public class HttpHeader
	{
		/// <summary>
		/// 获取请求回应状态码
		/// </summary>
		public string ResponseStatusCode
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取跳转url
		/// </summary>
		public string Location
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取是否由Gzip压缩
		/// </summary>
		public bool IsGzip
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取返回的文档类型
		/// </summary>
		public string ContentType
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取内容使用的字符集
		/// </summary>
		public string Charset
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取内容长度
		/// </summary>
		public long ContentLength
		{
			get;
			internal set;
		}

		/// <summary>
		/// 获取是否分块传输
		/// </summary>
		public bool IsChunk
		{
			get;
			internal set;
		}
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

/* Name: Socket 实现 http 协议全功能版

* Version: v0.6

* Description: 此版本实现了 http 及 https 的 get 或 post 访问, 自动处理301,302跳转, 支持 gzip 解压, 分块传输.

* 支持的操作: 获取文本,图片,文件形式的内容.

* 使用方法: new HttpWebSocket(); 调用实例的 Get.... 方法.

* 声明: 本代码仅做技术探讨,可任意转载,请勿用于商业用途.

* 本人博客: http://blog.itnmg.net http://www.cnblogs.com/lhg-net

* 创建日期: 2013-01-15

* 修订日期: 2013-06-03

using System;

using System.Collections.Generic;

using System.Net;

using System.Net.Sockets;

using System.Net.Security;

using System.Text;

using System.Text.RegularExpressions;

using System.IO;

using System.IO.Compression;

using System.Web;

using System.Drawing;

using System.Security.Cryptography.X509Certificates;

namespace ExtLibrary.Net

{

class HttpWebSocket

{

/// <summary>

/// 获取或设置请求与回应的超时时间,默认3秒.

/// </summary>

public int TimeOut

{

get;

set;

}

/// <summary>

/// 获取或设置请求cookie

/// </summary>

public List<string> Cookies

{

get;

set;

}

/// <summary>

/// 获取请求返回的 HTTP 头部内容

/// </summary>

public HttpHeader HttpHeaders

{

get;

internal set;

}

/// <summary>

/// 获取或设置错误信息分隔符

/// </summary>

private string ErrorMessageSeparate;

public HttpWebSocket()

{

this.TimeOut = 3;

this.Cookies = new List<string>();

this.ErrorMessageSeparate = ";;";

this.HttpHeaders = new HttpHeader();

}

/// <summary>

/// get或post方式请求一个 http 或 https 地址.使用 Socket 方式

/// </summary>

/// <param name="url">请求绝对地址</param>

/// <param name="referer">请求来源地址,可为空</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <returns>返回图像</returns>

public Image GetImageUseSocket( string url, string referer, string postData = null )

{

Image result = null;

MemoryStream ms = this.GetSocketResult( url, referer, postData );

try

{

if ( ms != null )

{

result = Image.FromStream( ms );

}

catch ( Exception e )

{

string ss = e.Message;

}

return result;

}

/// <summary>

/// get或post方式请求一个 http 或 https 地址.使用 Socket 方式

/// </summary>

/// <param name="url">请求绝对地址</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <returns>返回 html 内容,如果发生异常将返回上次http状态码及异常信息</returns>

public string GetHtmlUseSocket( string url, string postData = null )

{

return this.GetHtmlUseSocket( url, null, postData );

}

/// <summary>

/// get或post方式请求一个 http 或 https 地址.使用 Socket 方式

/// </summary>

/// <param name="url">请求绝对地址</param>

/// <param name="referer">请求来源地址,可为空</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <returns>返回 html 内容,如果发生异常将返回上次http状态码及异常信息</returns>

public string GetHtmlUseSocket( string url, string referer, string postData = null )

{

string result = string.Empty;

try

{

MemoryStream ms = this.GetSocketResult( url, referer, postData );

if ( ms != null )

{

result = Encoding.GetEncoding( string.IsNullOrWhiteSpace( this.HttpHeaders.Charset ) ? "UTF-8" : this.HttpHeaders.Charset ).GetString( ms.ToArray() );

}

catch ( SocketException se )

{

result = this.HttpHeaders.ResponseStatusCode + this.ErrorMessageSeparate + se.ErrorCode.ToString() + this.ErrorMessageSeparate + se.SocketErrorCode.ToString( "G" ) + this.ErrorMessageSeparate + se.Message;

}

catch ( Exception e )

{

result = this.HttpHeaders.ResponseStatusCode + this.ErrorMessageSeparate + e.Message;

}

return result;

}

/// <summary>

/// get或post方式请求一个 http 或 https 地址.

/// </summary>

/// <param name="url">请求绝对地址</param>

/// <param name="referer">请求来源地址,可为空</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <returns>返回的已解压的数据内容</returns>

private MemoryStream GetSocketResult( string url, string referer, string postData )

{

if ( string.IsNullOrWhiteSpace( url ) )

{

throw new UriFormatException( "'Url' cannot be empty." );

}

MemoryStream result = null;

Uri uri = new Uri( url );

if ( uri.Scheme == "http" )

{

result = this.GetHttpResult( uri, referer, postData );

}

else if ( uri.Scheme == "https" )

{

result = this.GetSslResult( uri, referer, postData );

}

else

{

throw new ArgumentException( "url must start with HTTP or HTTPS.", "url" );

}

if ( !string.IsNullOrWhiteSpace( this.HttpHeaders.Location ) )

{

result = GetSocketResult( this.HttpHeaders.Location, uri.AbsoluteUri, null );

}

else

{

result = unGzip( result );

}

return result;

}

/// <summary>

/// get或post方式请求一个 http 地址.

/// </summary>

/// <param name="uri">请求绝对地址</param>

/// <param name="referer">请求来源地址,可为空</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <param name="headText">输出包含头部内容的StringBuilder</param>

/// <returns>返回未解压的数据流</returns>

private MemoryStream GetHttpResult( Uri uri, string referer, string postData )

{

MemoryStream result = new MemoryStream( 10240 );

Socket HttpSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );

HttpSocket.SendTimeout = this.TimeOut * 1000;

HttpSocket.ReceiveTimeout = this.TimeOut * 1000;

try

{

byte[] send = GetSendHeaders( uri, referer, postData );

HttpSocket.Connect( uri.Host, uri.Port );

if ( HttpSocket.Connected )

{

HttpSocket.Send( send, SocketFlags.None );

this.ProcessData( HttpSocket, ref result );

}

result.Flush();

}

finally

{

HttpSocket.Shutdown( SocketShutdown.Both );

HttpSocket.Close();

}

result.Seek( 0, SeekOrigin.Begin );

return result;

}

/// <summary>

/// get或post方式请求一个 https 地址.

/// </summary>

/// <param name="uri">请求绝对地址</param>

/// <param name="referer">请求来源地址,可为空</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <param name="headText">输出包含头部内容的StringBuilder</param>

/// <returns>返回未解压的数据流</returns>

private MemoryStream GetSslResult( Uri uri, string referer, string postData )

{

MemoryStream result = new MemoryStream( 10240 );

StringBuilder sb = new StringBuilder( 1024 );

byte[] send = GetSendHeaders( uri, referer, postData );

TcpClient client = new TcpClient( uri.Host, uri.Port );

try

{

SslStream sslStream = new SslStream( client.GetStream(), true

, new RemoteCertificateValidationCallback( ( sender, certificate, chain, sslPolicyErrors )

=> {

return sslPolicyErrors == SslPolicyErrors.None;

}

), null );

sslStream.ReadTimeout = this.TimeOut * 1000;

sslStream.WriteTimeout = this.TimeOut * 1000;

X509Store store = new X509Store( StoreName.My );

sslStream.AuthenticateAsClient( uri.Host, store.Certificates, System.Security.Authentication.SslProtocols.Default, false );

if ( sslStream.IsAuthenticated )

{

sslStream.Write( send, 0, send.Length );

sslStream.Flush();

this.ProcessData( sslStream, ref result );

}

result.Flush();

}

finally

{

client.Close();

}

result.Seek( 0, SeekOrigin.Begin );

return result;

}

/// <summary>

/// 返回请求的头部内容

/// </summary>

/// <param name="uri">请求绝对地址</param>

/// <param name="referer">请求来源地址,可为空</param>

/// <param name="postData">post请求参数. 设置空值为get方式请求</param>

/// <returns>请求头部数据</returns>

private byte[] GetSendHeaders( Uri uri, string referer, string postData )

{

string sendString = @"{0} {1} HTTP/1.1

Accept: text/html, application/xhtml+xml, */*

Referer: {2}

Accept-Language: zh-CN

User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)

Accept-Encoding: gzip, deflate

Host: {3}

Connection: Keep-Alive

Cache-Control: no-cache

sendString = string.Format( sendString, string.IsNullOrWhiteSpace( postData ) ? "GET" : "POST", uri.PathAndQuery

, string.IsNullOrWhiteSpace( referer ) ? uri.AbsoluteUri : referer, uri.Host );

if ( this.Cookies != null && this.Cookies.Count > 0 )

{

sendString += string.Format( "Cookie: {0}rn", string.Join( "; ", this.Cookies.ToArray() ) );

}

if ( string.IsNullOrWhiteSpace( postData ) )

{

sendString += "rn";

}

else

{

int dlength = Encoding.UTF8.GetBytes( postData ).Length;

sendString += string.Format( @"Content-Type: application/x-www-form-urlencoded

Content-Length: {0}

{1}

", postData.Length, postData );

}

return Encoding.UTF8.GetBytes( sendString );

;

}

/// <summary>

/// 设置此类的字段

/// </summary>

/// <param name="headText">头部文本</param>

private void SetThisHeaders( string headText )

{

if ( string.IsNullOrWhiteSpace( headText ) )

{

throw new ArgumentNullException( "'WithHeadersText' cannot be empty." );

}

//Match m = Regex.Match( withHeadersText,@".*(?=rnrn)", RegexOptions.Singleline | RegexOptions.IgnoreCase );

//if ( m == null || string.IsNullOrWhiteSpace( m.Value ) )

//{

// throw new HttpParseException( "'SetThisHeaders' method has bug." );

//}

string[] headers = headText.Split( new string[] { "rn" }, StringSplitOptions.RemoveEmptyEntries );

if ( headers == null || headers.Length == 0 )

{

throw new ArgumentException( "'WithHeadersText' param format error." );

}

this.HttpHeaders = new HttpHeader();

foreach ( string head in headers )

{

if ( head.StartsWith( "HTTP", StringComparison.OrdinalIgnoreCase ) )

{

string[] ts = head.Split( ' ' );

if ( ts.Length > 1 )

{

this.HttpHeaders.ResponseStatusCode = ts[1];

}

else if ( head.StartsWith( "Set-Cookie:", StringComparison.OrdinalIgnoreCase ) )

{

this.Cookies = this.Cookies ?? new List<string>();

string tCookie = head.Substring( 11, head.IndexOf( ";" ) < 0 ? head.Length - 11 : head.IndexOf( ";" ) - 10 ).Trim();

if ( !this.Cookies.Exists( f => f.Split( '=' )[0] == tCookie.Split( '=' )[0] ) )

{

this.Cookies.Add( tCookie );

}

else if ( head.StartsWith( "Location:", StringComparison.OrdinalIgnoreCase ) )

{

this.HttpHeaders.Location = head.Substring( 9 ).Trim();

}

else if ( head.StartsWith( "Content-Encoding:", StringComparison.OrdinalIgnoreCase ) )

{

if ( head.IndexOf( "gzip", StringComparison.OrdinalIgnoreCase ) >= 0 )

{

this.HttpHeaders.IsGzip = true;

}

else if ( head.StartsWith( "Content-Type:", StringComparison.OrdinalIgnoreCase ) )

{

string[] types = head.Substring( 13 ).Split( new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries );

foreach ( string t in types )

{

if ( t.IndexOf( "charset=", StringComparison.OrdinalIgnoreCase ) >= 0 )

{

this.HttpHeaders.Charset = t.Trim().Substring( 8 );

}

else if ( t.IndexOf( '/' ) >= 0 )

{

this.HttpHeaders.ContentType = t.Trim();

}

else if ( head.StartsWith( "Content-Length:", StringComparison.OrdinalIgnoreCase ) )

{

this.HttpHeaders.ContentLength = long.Parse( head.Substring( 15 ).Trim() );

}

else if ( head.StartsWith( "Transfer-Encoding:", StringComparison.OrdinalIgnoreCase ) && head.EndsWith( "chunked", StringComparison.OrdinalIgnoreCase ) )

{

this.HttpHeaders.IsChunk = true;

}

/// <summary>

/// 解压数据流

/// </summary>

/// <param name="data">数据流, 压缩或未压缩的.</param>

/// <returns>返回解压缩的数据流</returns>

private MemoryStream unGzip( MemoryStream data )

{

if ( data == null )

{

throw new ArgumentNullException( "data cannot be null.", "data" );

}

data.Seek( 0, SeekOrigin.Begin );

MemoryStream result = data;

if ( this.HttpHeaders.IsGzip )

{

GZipStream gs = new GZipStream( data, CompressionMode.Decompress );

result = new MemoryStream( 1024 );

try

{

byte[] buffer = new byte[1024];

int length = -1;

{

length = gs.Read( buffer, 0, buffer.Length );

result.Write( buffer, 0, length );

}

while ( length != 0 );

gs.Flush();

result.Flush();

}

finally

{

gs.Close();

}

return result;

}

/// <summary>

/// 处理请求返回的数据.

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">数据源实例</param>

/// <param name="body">保存数据的流</param>

private void ProcessData<T>( T reader, ref MemoryStream body )

{

byte[] data = new byte[10240];

int bodyStart = -1;//数据部分起始位置

int readLength = 0;

bodyStart = GetHeaders( reader, ref data, ref readLength );

if ( bodyStart >= 0 )

{

if ( this.HttpHeaders.IsChunk )

{

GetChunkData( reader, ref data, ref bodyStart, ref readLength, ref body );

}

else

{

GetBodyData( reader, ref data, bodyStart, readLength, ref body );

}

/// <summary>

/// 取得返回的http头部内容,并设置相关属性.

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">数据源实例</param>

/// <param name="data">待处理的数据</param>

/// <param name="readLength">读取的长度</param>

/// <returns>数据内容的起始位置,返回-1表示未读完头部内容</returns>

private int GetHeaders<T>( T reader, ref byte[] data, ref int readLength )

{

int result = -1;

StringBuilder sb = new StringBuilder( 1024 );

{

readLength = this.ReadData( reader, ref data );

if ( result < 0 )

{

for ( int i = 0; i < data.Length; i++ )

{

char c = (char)data[i];

sb.Append( c );

if ( c == 'n' && string.Concat( sb[sb.Length - 4], sb[sb.Length - 3], sb[sb.Length - 2], sb[sb.Length - 1] ).Contains( "rnrn" ) )

{

result = i + 1;

this.SetThisHeaders( sb.ToString() );

break;

}

if ( result >= 0 )

{

break;

}

while ( readLength > 0 );

return result;

}

/// <summary>

/// 取得未分块数据的内容

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">数据源实例</param>

/// <param name="data">已读取未处理的字节数据</param>

/// <param name="startIndex">起始位置</param>

/// <param name="readLength">读取的长度</param>

/// <param name="body">保存块数据的流</param>

private void GetBodyData<T>( T reader, ref byte[] data, int startIndex, int readLength, ref MemoryStream body )

{

int contentTotal = 0;

if ( startIndex < data.Length )

{

int count = readLength - startIndex;

body.Write( data, startIndex, count );

contentTotal += count;

}

int tlength = 0;

{

tlength = this.ReadData( reader, ref data );

contentTotal += tlength;

body.Write( data, 0, tlength );

if ( this.HttpHeaders.ContentLength > 0 && contentTotal >= this.HttpHeaders.ContentLength )

{

break;

}

while ( tlength > 0 );

}

/// <summary>

/// 取得分块数据

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">Socket实例</param>

/// <param name="data">已读取未处理的字节数据</param>

/// <param name="startIndex">起始位置</param>

/// <param name="readLength">读取的长度</param>

/// <param name="body">保存块数据的流</param>

private void GetChunkData<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength, ref MemoryStream body )

{

int chunkSize = -1;//每个数据块的长度,用于分块数据.当长度为0时,说明读到数据末尾.

while ( true )

{

chunkSize = this.GetChunkHead( reader, ref data, ref startIndex, ref readLength );

this.GetChunkBody( reader, ref data, ref startIndex, ref readLength, ref body, chunkSize );

if ( chunkSize <= 0 )

{

break;

}

/// <summary>

/// 取得分块数据的数据长度

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">Socket实例</param>

/// <param name="data">已读取未处理的字节数据</param>

/// <param name="startIndex">起始位置</param>

/// <param name="readLength">读取的长度</param>

/// <returns>块长度,返回0表示已到末尾.</returns>

private int GetChunkHead<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength )

{

int chunkSize = -1;

List<char> tChars = new List<char>();//用于临时存储块长度字符

if ( startIndex >= data.Length || startIndex >= readLength )

{

readLength = this.ReadData( reader, ref data );

startIndex = 0;

}

{

for ( int i = startIndex; i < readLength; i++ )

{

char c = (char)data[i];

if ( c == 'n' )

{

try

{

chunkSize = Convert.ToInt32( new string( tChars.ToArray() ).TrimEnd( 'r' ), 16 );

startIndex = i + 1;

}

catch ( Exception e )

{

throw new Exception( "Maybe exists 'chunk-ext' field.", e );

}

break;

}

tChars.Add( c );

}

if ( chunkSize >= 0 )

{

break;

}

startIndex = 0;

readLength = this.ReadData( reader, ref data );

}

while ( readLength > 0 );

return chunkSize;

}

/// <summary>

/// 取得分块传回的数据内容

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">Socket实例</param>

/// <param name="data">已读取未处理的字节数据</param>

/// <param name="startIndex">起始位置</param>

/// <param name="readLength">读取的长度</param>

/// <param name="body">保存块数据的流</param>

/// <param name="chunkSize">块长度</param>

private void GetChunkBody<T>( T reader, ref byte[] data, ref int startIndex, ref int readLength, ref MemoryStream body, int chunkSize )

{

if ( chunkSize <= 0 )

{

return;

}

int chunkReadLength = 0;//每个数据块已读取长度

if ( startIndex >= data.Length || startIndex >= readLength )

{

readLength = this.ReadData( reader, ref data );

startIndex = 0;

}

{

int owing = chunkSize - chunkReadLength;

int count = Math.Min( readLength - startIndex, owing );

body.Write( data, startIndex, count );

chunkReadLength += count;

if ( owing <= count )

{

startIndex += count + 2;

break;

}

startIndex = 0;

readLength = this.ReadData( reader, ref data );

}

while ( readLength > 0 );

}

/// <summary>

/// 从数据源读取数据

/// </summary>

/// <typeparam name="T">数据源类型</typeparam>

/// <param name="reader">数据源</param>

/// <param name="data">用于存储读取的数据</param>

/// <returns>读取的数据长度,无数据为-1</returns>

private int ReadData<T>( T reader, ref byte[] data )

{

int result = -1;

if ( reader is Socket )

{

result = (reader as Socket).Receive( data, SocketFlags.None );

}

else if ( reader is SslStream )

{

result = (reader as SslStream).Read( data, 0, data.Length );

}

return result;

}

public class HttpHeader

{

/// <summary>

/// 获取请求回应状态码

/// </summary>

public string ResponseStatusCode

{

get;

internal set;

}

/// <summary>

/// 获取跳转url

/// </summary>

public string Location

{

get;

internal set;

}

/// <summary>

/// 获取是否由Gzip压缩

/// </summary>

public bool IsGzip

{

get;

internal set;

}

/// <summary>

/// 获取返回的文档类型

/// </summary>

public string ContentType

{

get;

internal set;

}

/// <summary>

/// 获取内容使用的字符集

/// </summary>

public string Charset

{

get;

internal set;

}

/// <summary>

/// 获取内容长度

/// </summary>

public long ContentLength

{

get;

internal set;

}

/// <summary>

/// 获取是否分块传输

/// </summary>

public bool IsChunk

{

get;

internal set;

}

申请免费代码签名证书

发表于2013-01-18由jgh004

最近在研究代码签名技术, 花了不少时间, 下面记录一下从了解代码签名到获得一个有效的代码签名证书的过程.

首先说一下什么是”代码签名”:

代码签名即软件的所有者使用受全球认可的第三方发放的能证明其真实身份的 “代码签名数字证书” 为其开发的软件添加一个标记, 即所谓的 “签名”, 因而增强了可信度.
耳听为虚, 眼见为实, 有图有真象.

代码签名的作用:

证明软件在发行和传播过程中未经篡改, 增强安全性.
当软件中有涉及到安全方面或底层代码的地方, 如果没有代码签名, 系统会弹出警示框是否要继续安装或执行, 而签名之后的代码便会顺利通过安全检测, 不会弹出警示框.

代码签名的对象:

按照不同的系统和文件类型可以为多种文件进行签名. 比如微软常见的 .exe, .dll, .cab, .msi, .ocx, .sys, .cat, .vbs 等文件类型. Android 系统中的 .apk 文件. Java 中的 .jar 文件等.

代码签名需要的工具:

代码签名证书: 通过 sn.exe 自制证书或申请免费证书, 稍后重点介绍申请免费证书.
签名工具: .net 中为 SignTool.exe, 已随 Visual Studio 或 Windows SDK 安装.
时间戳服务器: 网络上有很多提供免费时间戳服务的机构, 最著名的有 Symantec 的时间戳服务, 下面列举一些常用的.
http://timestamp.verisign.com/scripts/timstamp.dll
http://timestamp.comodoca.com/authenticode
http://www.startssl.com/timestamp
http://timestamp.wosign.com/timestamp
http://timestamp.globalsign.com/scripts/timstamp.dll
http://www.trustcenter.de/codesigning/timestamp

申请代码签名证书: 阅读全文

IT农民工

又一码农的一亩三分地

分类目录归档：.Net

为 npm 设置代理

为 Visual Studio 设置 NuGet 代理

找到 NuGet 配置文件

设置 NuGet 代理

CentOS 7 安装 .Net Core 环境

Log4net 配置输出文本, 按年月日分文件夹

MySql EF6 DBFirst 向导无法生成 edmx 解决方法(同:您的项目引用了最新实体框架；但是，找不到数据链接所需的与版本兼容的实体框架数据库提供程序)

新建一个项目, 从 nuget 中添加 EF6

修改 config 文件

在项目中添加新的 “Ado.Net 实体数据模型”(即 edmx 文件)

无法正常卸载 Visual Studio 时的处理方法

(转) C#如何验证一个PE文件的数字签名是否正确（1）

Fiddler 过滤 css,图片等请求url 正则表达式

C# 使用 Socket 实现 http 协议全功能版

申请免费代码签名证书

首先说一下什么是”代码签名”:

代码签名的作用:

代码签名的对象:

代码签名需要的工具: