完成替换之后重启计算机从硬盘启动，你就会发现登录Windows时不需要密码了
利用net user命令修改本地管理员账户的密码
net users adminuser Password /add
net localgroup administrators adminuser /add/*===================下载文件
* options:{
* url:'', //下载地址
* data:{name:value}, //要发送的数据
* method:'post'
* }
*/
var DownLoadFile = function (options) {
var config = $.extend(true, { method: 'post' }, options);
var $iframe = $('<iframe id="down-file-iframe" />');
var $form = $('<form target="down-file-iframe" method="' + config.method + '" />');
$form.attr('action', config.url);
for (var key in config.data) {
$form.append('<input type="hidden" name="' + key + '" value="' + config.data[key] + '" />');
}
$iframe.append($form);
$(document.body).append($iframe);
$form[0].submit();
$iframe.remove();
}if (!Array.prototype.indexOf){
Array.prototype.indexOf = function(elt /*, from*/){
var len = this.length >>> 0;
var from = Number(arguments[1]) || 0;
from = (from < 0)
? Math.ceil(from)
: Math.floor(from);
if (from < 0)
from += len;
for (; from < len; from++){
if (from in this && this[from] === elt)
return from;
}
return -1;
};
}window._console = window.console;//将原始console对象缓存
window.console = (function (orgConsole) {
return {//构造的新console对象
log: getConsoleFn("log"),
debug: getConsoleFn("debug"),
info: getConsoleFn("info"),
warn: getConsoleFn("warn"),
exception: getConsoleFn("exception"),
assert: getConsoleFn("assert"),
dir: getConsoleFn("dir"),
dirxml: getConsoleFn("dirxml"),
trace: getConsoleFn("trace"),
group: getConsoleFn("group"),
groupCollapsed: getConsoleFn("groupCollapsed"),
groupEnd: getConsoleFn("groupEnd"),
profile: getConsoleFn("profile"),
profileEnd: getConsoleFn("profileEnd"),
count: getConsoleFn("count"),
clear: getConsoleFn("clear"),
time: getConsoleFn("time"),
timeEnd: getConsoleFn("timeEnd"),
timeStamp: getConsoleFn("timeStamp"),
table: getConsoleFn("table"),
error: getConsoleFn("error"),
memory: getConsoleFn("memory"),
markTimeline: getConsoleFn("markTimeline"),
timeline: getConsoleFn("timeline"),
timelineEnd: getConsoleFn("timelineEnd")
};
function getConsoleFn(name) {
return function actionConsole() {
if (typeof (orgConsole) !== "object") return;
if (typeof (orgConsole[name]) !== "function") return;//判断原始console对象中是否含有此方法，若没有则直接返回
return orgConsole[name].apply(orgConsole, Array.prototype.slice.call(arguments));//调用原始函数
};
}
}(window._console)); using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace Helper
{
public class CV300EHelper
{
#region 指纹特征提取函数接口
/// <summary>
/// 版本信息获取
/// 函数原型：int __stdcall FP_GetVersion(unsigned char code[4])
/// </summary>
/// <param name="code">unsigned char code[4] 版本信息格式为XXYY，XX为开发者代码，YY为版本号。如“1201” 则code的填写方式为：，code[0]=‘1’ code[1]=，‘2’ code[3]=，‘0’ code[4]=,‘1’。输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求。输出参数。</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_GetVersion", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_GetVersion(System.IntPtr code);
/// <summary>
/// 初始化操作
/// 函数原型：int __stdcall FP_Begin()
/// </summary>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 B.4 的要求。</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_Begin", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_Begin();
/// <summary>
/// 指纹图像特征提取
/// 函数原型：int __stdcall FP_FeatureExtract(unsigned char cScannerType,unsigned char cFingerCode,unsigned char * pFingerImgBuf,unsigned char * pFeatureData)
/// </summary>
/// <param name="cScannerType">unsigned char cScannerType 指纹采集器代码。输入参数。</param>
/// <param name="cFingerCode">unsigned char cFingerCode 指位代码。输入参数。</param>
/// <param name="pFingerImgBuf">unsigned char * pFingerImgBuf 指纹图像数据指针，指纹图像为RAW格式。输入参数。</param>
/// <param name="pFeatureData">unsigned char * pFeatureData 指纹特征数据指针，存储生成的指纹特征数据，由调用者分配内存空间，输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_FeatureExtract", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_FeatureExtract(byte cScannerType, byte cFingerCode, System.IntPtr pFingerImgBuf, System.IntPtr pFeatureData);
/// <summary>
/// 指纹图像数据与指纹特征数据比对
/// 函数原型：int __stdcall FP_FeatureMatch(unsigned char * pFeatureData1,unsigned char* pFeatureData2,float * pfSimilarity)
/// 对两个指纹特征数据进行比对，得到相似度值
/// </summary>
/// <param name="pFeatureData1">unsigned char * pFeatureData1 指纹特征数据指针1。输入参数。</param>
/// <param name="pFeatureData2">unsigned char * pFeatureData2 指纹特征数据指针2。输入参数。</param>
/// <param name="pfSimilarity">float * pfSimilarity 相似度，取值范围为0.00 ～ 1.00，值0.00表示不匹配，值1.00 表示完全匹配。输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_FeatureMatch", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_FeatureMatch(System.IntPtr pFeatureData1, System.IntPtr pFeatureData2, ref float pfSimilarity);
/// <summary>
/// 指纹图像数据与指纹特征数据比对
/// 函数原型：int __stdcall FP_ImageMatch(unsigned char * pFingerImgBuf,unsigned char *pFeatureData,float * pfSimilarity)。
/// 对指纹图像数据与指纹特征数据进行比对，得到相似度值。
/// </summary>
/// <param name="pFingerImgBuf">unsigned char * pFingerImgBuf 指纹图像数据指针,指纹图像为RAW格式。输入参数。</param>
/// <param name="pFeatureData">unsigned char * pFeatureData 指纹特征数据指针。输入参数。</param>
/// <param name="pfSimilarity">float * pfSimilarity 相似度，取值范围为0.00 ～ 1.00，值0.00表示不匹配，值1.00 表示完全匹配。输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_ImageMatch", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_ImageMatch(System.IntPtr pFingerImgBuf, System.IntPtr pFeatureData, ref float pfSimilarity);
/// <summary>
/// 指纹图像数据压缩
/// 函数原型：int __stdcall FP_Compress(unsigned char cScannerType, unsigned char cEnrolResult,unsigned char cFingerCode, unsigned char* pFingerImgBuf,int nCompressRatio, unsigned char* pCompressedImgBuf, unsigned char strBuf[256])。
/// 对指纹图像数据进行压缩。
/// </summary>
/// <param name="cScannerType">unsigned char cScannerType 指纹采集器代码。输入参数。</param>
/// <param name="cEnrolResult">unsigned char cEnrolResult 注册结果代码。输入参数。</param>
/// <param name="cFingerCode">unsigned char cFingerCode 指位代码。输入参数。</param>
/// <param name="pFingerImgBuf">unsigned char * pFingerImgBuf 指纹图像数据指针，指纹图像为RAW格式。输入参数。</param>
/// <param name="nCompressRatio">int nCompressRatio 指纹图像数据压缩倍数。输入参数。</param>
/// <param name="pCompressedImgBuf">unsigned char * pCompressedImgBuf 指纹压缩图像数据指针，调用者在调用此函数前，应当分配不小于20 480字节的内存，指纹压缩图像数据文件结构应符合附录A要求。输出参数。</param>
/// <param name="strBuf">unsigned char strBuf[256] 错误信息，如果压缩图像发生错误，并且返回值为-9的情况下，strBuf填写错误信息。错误信息为以数值0结尾的字符串，采用GB 13000中规定的字符。输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求。</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_Compress", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_Compress(byte cScannerType, byte cEnrolResult, byte cFingerCode, System.IntPtr pFingerImgBuf,
int nCompressRatio, System.IntPtr pCompressedImgBuf, byte[] strBuf);
/// <summary>
/// 指纹图像数据复现
/// 函数原型：int __stdcall FP_Decompress(unsigned char * pCompressedImgBuf,unsigned char* pFingerImgBuf,unsigned char strBuf[256])。
/// 对指纹原始图像数据进行复现。
/// </summary>
/// <param name="pCompressedImgBuf">unsigned char * pCompressedImgBuf 指纹压缩图像数据指针，压缩图像数据长度不大 于20 480字节。输入参数。</param>
/// <param name="pFingerImgBuf">unsigned char * pFingerImgBuf 指纹复现图像数据指针，指纹图像为RAW格式，调用者在调用此函数前，应当分配92 160字节的内存。输出参数。</param>
/// <param name="strBuf">unsigned char strBuf[256] 错误信息，如果压缩图像发生错误，并且返回值为-9的情况下，strBuf填写错误信息。错误信息为以数值0结尾的字符串，采用GB 13000中规定的 字符。输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_Decompress", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_Decompress(System.IntPtr pCompressedImgBuf, System.IntPtr pFingerImgBuf, byte[] strBuf);
/// <summary>
/// 指纹图像质量值获取
/// 函数原型：int __stdcall FP_GetQualityScore(unsigned char * pFingerImgBuf,unsigned char* pnScore)。
/// 获取指纹图像的质量值
/// </summary>
/// <param name="pFingerImgBuf">unsigned char * pFingerImgBuf 指纹图像数据指针，指纹图像为RAW格式。输入参数。</param>
/// <param name="pnScore">unsigned char * pnScore 指纹图像质量值指针，指纹图像质量值取值范围为00H ～ 64H，值01H表示最低质量，值64H表示最高质量，值00H表示未知。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求。</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_GetQualityScore", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_GetQualityScore(System.IntPtr pFingerImgBuf, ref int pnScore);
/// <summary>
/// 生成“注册失败”指纹特征数据
/// 函数原型：int __stdcall FP_GenFeatureFromEmpty1(unsigned char cScannerType,unsigned char cFingerCode,unsigned char * pFeatureData)
/// 本函数针对“注册失败”手指的情况，生成“注册失败”指纹特征数据。其中，字段5设置为02H；字段9、字段10均设置为00H。
/// </summary>
/// <param name="cScannerType">unsigned char cScannerType 指纹采集器代码。输入参数。</param>
/// <param name="cFingerCode">unsigned char cFingerCode 指位代码。输入参数。</param>
/// <param name="pFeatureData">unsigned char * pFeatureData 指纹特征数据指针，存储生成的指纹特征数据，由调用者分配内存空间，输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_GenFeatureFromEmpty1", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_GenFeatureFromEmpty1(byte cScannerType, byte cFingerCode, System.IntPtr pFeatureData);
/// <summary>
/// 生成“未注册”指纹特征数据
/// 函数原型：int __stdcall FP_GenFeatureFromEmpty2(unsigned char cFingerCode,unsigned char * pFeatureData)
/// 本函数针对“未注册”手指的情况，生成“未注册”指纹特征数据。其中，字段5设置为03H；字段6设置为61H、62H或63H；字段7、字段9、字段10均设置为00H。
/// </summary>
/// <param name="cFingerCode">unsigned char cFingerCode 指位代码。输入参数。</param>
/// <param name="pFeatureData">unsigned char * pFeatureData 指纹特征数据指针，存储生成的指纹特征数据，由调用者分配内存空间，输出参数。</param>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求。</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_GenFeatureFromEmpty2", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_Decompress(byte cFingerCode, System.IntPtr pFeatureData);
/// <summary>
/// 结束操作
/// 函数原型：int __stdcall FP_End()
/// </summary>
/// <returns>调用成功，返回1；否则返回错误代码，错误代码值应符合B.4的要求。</returns>
[DllImport("ID_Fpr.dll", EntryPoint = "FP_End", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int FP_End();
#endregion
#region 指纹仪函数接口
/// <summary>
/// 初始化采集器
/// 函数原型：int _stdcall LIVESCAN_Init()。
/// 初始化采集器，分配相应的资源。
/// 在所有接口函数中，通常首先调用此函数。只需要调用一次，允许重复调用，其结果与一次调用相同。
/// </summary>
/// <returns>调用成功返回1。否则返回错误代码，调用LIVESCAN_GetErrInfo函数获取错误信息。错误代码值符合A.4的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_Init", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_Init();
/// <summary>
/// 释放采集器
/// 函数原型：int _stdcall LIVESCAN_Close()。
/// 关闭指纹采集器，释放分配的资源。
/// 调用此函数后，在没有调用 LIVESCAN_Init 函数之前，仅可调用 LIVESCAN_GetVersion、LIVESCAN_GetDesc 和 LIVESCAN_GetErrorInfo 函数。
/// 调用此函数后，应重新调用 LIVESCAN_Init 来初始化采集器。
/// </summary>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_Close", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_Close();
/// <summary>
/// 获得采集器通道数量
/// 函数原型：int _stdcall LIVESCAN_GetChannelCount()。
/// 获得采集器可以使用的通道数量及通道号。
/// </summary>
/// <returns>调用成功返回通道数量（＞0）。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetChannelCount", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetChannelCount();
/// <summary>
/// 获得采集器采集图像的宽度、高度的最大值
/// 函数原型：int _stdcall LIVESCAN_GetMaxImageSize（int nChannel,int * pnWidth, int * pnHeight)。
/// 获得采集器可采集图像的宽度、高度的最大值。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="pnWidth">int * pnWidth 存放图像宽度的整形指针。输出参数。</param>
/// <param name="pnHeight">int * pnHeight 存放图像高度的整形指针。输出参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetMaxImageSize", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetMaxImageSize(int nChannel, ref int pnWidth, ref int pnHeight);
/// <summary>
/// 获得采集器当前的亮度
/// 函数原型：int _stdcall LIVESCAN_GetBright(int nChannel,int * pnBright)。
/// 获得采集器当前亮度。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="pnBright">int * pnBright 存放当前亮度的整形指针。输出参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码 ,调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetBright", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetBright(int nChannel, ref int pnBright);
/// <summary>
/// 设置采集器当前的亮度
/// 函数原型：int _stdcall LIVESCAN_SetBright(int nChannel, int nBright)。
/// 设置采集器当前亮度
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="nBright">int nBright 亮度，范围为 0～255，输入参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_SetBright", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_SetBright(int nChannel, int nBright);
/// <summary>
/// 获得采集器当前对比度
/// 函数原型：int _stdcall LIVESCAN_GetContrast(int nChannel,int * pnContrast)。
/// 获得采集器当前对比度。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="pnContrast">int * pnContrast 存放当前对比度的整型指针。输出参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetContrast", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetContrast(int nChannel, ref int pnContrast);
/// <summary>
/// 设置采集器当前对比度
/// 函数原型：int _stdcall LIVESCAN_SetContrast(int nChannel,int Contrast)。
/// 设置采集器当前对比度。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="nContrast">int nContrast 对比度, 范围0～255。输入参数。</param>
/// <returns>调用成功返回1。否则返回错误代码，调用LIVESCAN_GetErrInfo函数获取错误信息。错误代码值符合A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_SetContrast", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_SetContrast(int nChannel, int nContrast);
/// <summary>
/// 获得当前图像的采集位置、宽度和高度
/// 函数原型：int _stdcall LIVESCAN_GetCaptWindow(int nChannel,int * pnOriginX, int * pnOriginY,int * pnWidth, int * pnHeight)。
/// 获得采集器当前图像的采集位置、宽度和高度。当前图像宽度初始值为 256，高度初始值为360。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="pnOriginX">int *pnOriginX 存放图像采集窗口的采集原点坐标X值的整型指针。输出参数。</param>
/// <param name="pnOriginY">int *pnOriginY 存放图像采集窗口的采集原点坐标Y值的整型指针。输出参数。</param>
/// <param name="pnWidth">int *pnWidth 存放采集图像宽度的整形指针。输出参数。</param>
/// <param name="pnHeight">int *pnHeight 存放采集图像高度的整形指针。输出参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetCaptWindow", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetCaptWindow(int nChannel, ref int pnOriginX, ref int pnOriginY, ref int pnWidth, ref int pnHeight);
/// <summary>
/// 设置当前图像的采集位置、宽度和高度
/// 函数原型：int _stdcall LIVESCAN_SetCaptWindow(int nChannel,int nOriginX, int nOriginY,int nWidth,int nHeight)。
/// 设置采集器当前图像的采集位置、宽度和高度。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <param name="nOriginX">int nOriginX 图像采集窗口的采集原点坐标 X 值。输入参数。</param>
/// <param name="nOriginY">int nOriginY 图像采集窗口的采集原点坐标 Y 值。输入参数。</param>
/// <param name="nWidth">int nWidth 采集图像的宽度。对于居民身份证用单指指纹采集，应大于等于 256。否则应返回参数错误代码。输入参数。</param>
/// <param name="nHeight">int nHeight 采集图像的高度。对于居民身份证用单指指纹采集，应大于等于 360。否则应返回参数错误代码。输入参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_SetCaptWindow", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_SetCaptWindow(int nChannel, int nOriginX, int nOriginY, int nWidth, int nHeight);
/// <summary>
/// 准备采集一帧图像
/// 函数原型：int _stdcall LIVESCAN_BeginCapture(int nChannel)。
/// 采集图像的一个前缀函数，使得采集器有机会进行另外一个采集之前的初始化工作。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_BeginCapture", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_BeginCapture(int nChannel);
/// <summary>
/// 结束采集一帧图像
/// 函数原型：int _stdcall LIVESCAN_EndCapture(int nChannel)。
/// 结束采集一帧图像或预览图像。
/// </summary>
/// <param name="nChannel">int nChannel 通道号。输入参数。</param>
/// <returns>调用成功返回1。否则返回错误代码，调用LIVESCAN_GetErrInfo函数获取错误信息。错误代码值符合A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_EndCapture", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_EndCapture(int nChannel);
/// <summary>
/// 采集一帧图像
/// 函数原型：int _stdcall LIVESCAN_GetFPRawData(int nChannel,unsigned char *pRawData)。
/// </summary>
/// <param name="nChannel">int nChannel通道号。输入参数。</param>
/// <param name="pRawData">unsigned char* pRawData指向存放采集数据的内存块，调用者分配。 返回图像数据，大小应为：当前图像采集宽度×当前图像采集高度。输出参数。</param>
/// <returns>调用成功返回1。否则返回错误代码，调用LIVESCAN_GetErrInfo函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetFPRawData", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetFPRawData(int nChannel, System.IntPtr pRawData);
/// <summary>
/// 采集一帧BMP格式图像数据
/// 函数原型：int _stdcall LIVESCAN_GetFPBmpData(int nChannel, unsigned char * pBmpData)。
/// 采集一帧8位灰度 BMP 格式图像。
/// </summary>
/// <param name="nChannel">int nChannel通道号。输入参数。</param>
/// <param name="pBmpData">unsigned char* pBmpData 指向存放8位灰度BMP格式采集数据的内存块，调用者分配。返回8位灰度BMP格式图像数据。大小应为：当前图像采集宽度×当前图像采集高度+1078。输出参数。</param>
/// <returns>调用成功，返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetFPBmpData", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetFPBmpData(int nChannel, System.IntPtr pBmpData);
/// <summary>
/// 调用采集器的属性设置对话框
/// 函数原型：int _stdcall LIVESCAN_Setup()。
/// 此函数弹出一个模式对话框，用户可以设置除去对比度、亮度、采集窗口参数外的其它参数，如GAMMA值等，使得设置适合采集器本身的特点。
/// </summary>
/// <returns>调用成功返回 1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合 A.4 的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_Setup", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_Setup();
/// <summary>
/// 采集器是否支持设置对话框
/// 函数原型：int _stdcall LIVESCAN_IsSupportSetup()。
/// 此函数用来确认是否支持设置对话框。
/// </summary>
/// <returns>若采集接口支持LIVESCAN_setup，则返回1，否则返回0。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合A.4的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_IsSupportSetup", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_IsSupportSetup();
/// <summary>
/// 取得接口规范的版本
/// 函数原型：int ¬_stdcall LIVESCAN_GetVersion()。
/// 获得接口版本号。
/// </summary>
/// <returns>获得接口规范的版本。当前版本为1.00，返回值为100。若以后扩展接口，则需要修改此版本号。否则返回错误代码，调用LIVESCAN_GetErrorInfo函数获取错误信息。错误代码值应符合 A.4的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetVersion", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetVersion();
/// <summary>
/// 获得接口规范的说明
/// 函数原型：int _stdcall LIVESCAN_GetDesc(char pszDesc[1024])。
/// 获得接口说明，不需要初始化就可以调用。pszDesc以数值0结尾的字符串，采用GB13000 中规定的字符。
/// </summary>
/// <param name="pszDesc">char pszDesc[1024]存放接口说明，其中pszDesc[0]用于存储采集器代码，缺省为FFH。 输出参数。</param>
/// <returns>调用成功返回1。否则返回错误代码，调用LIVESCAN_GetErrorInfo函数获取错误信息。错误代码值应符合 A.4的要求</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetDesc", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetDesc(System.IntPtr pszDesc);
/// <summary>
/// 设置存放采集数据的内存块为空
/// 函数原型：int _stdcall LIVESCAN_SetBufferEmpty(unsigned char * pImageData, long imageLength）。
/// 将存放采集数据的内存块中的每一个字节的值置为0x00。
/// </summary>
/// <param name="pImageData">unsigned char * pImageData 指向存放采集数据的内存块。输入参数。</param>
/// <param name="imageLength">long imageLength 存放采集数据的内存块长度。输入参数。</param>
/// <returns>调用成功返回1。否则返回错误代码，调用 LIVESCAN_GetErrInfo 函数获取错误信息。错误代码值符合A.4的要求。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_SetBufferEmpty", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_SetBufferEmpty(System.IntPtr pImageData, long imageLength);
/// <summary>
/// 获得采集接口错误信息
/// 函数原型：int _stdcall LIVESCAN_GetErrorInfo(int nErrorNo,char pszErrorInfo[256])。
/// pszErrorInfo 采用GB13000中规定的字符。
/// </summary>
/// <param name="nErrorNo">char pszErrorInfo[256]用来存放错误信息的内存块，错误信息的长度不能超过 256 个字节。输出参数。</param>
/// <param name="pszErrorInfo">int nErrorNo 错误代码(＜0)。输入参数。</param>
/// <returns>若为合法的错误代码返回 1，pszErrorInfo中为错误信息。若 nErrorNo 为非法的错误代码，则返回-6，同时设置 pszErrorInfo为“非法错误号”错误。</returns>
[DllImport("ID_FprCap.dll", EntryPoint = "LIVESCAN_GetErrorInfo", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int LIVESCAN_GetErrorInfo(int nErrorNo, System.IntPtr pszErrorInfo);
[DllImport("Kernel32.dll")]
static extern bool QueryPerformanceCounter(ref long count);
[DllImport("Kernel32.dll")]
static extern bool QueryPerformanceFrequency(ref long count);
#endregion
#region 二代证接口
/// <summary>
/// 初始化连接
/// 原 型：int CVR_InitComm (int Port)
/// 本函数用于PC与华视电子第二代居民身份证阅读器的连接。
/// </summary>
/// <param name="Port">连接串口（COM1~COM16）或USB口(1001~1016)[1,串口1],[2,串口2],[3,串口3],[4,串口4],[1001,USB口1],[1002,USB口2],[1003,USB口3],[1004,USB口4]</param>
/// <returns>[1,正确],[2,端口打开失败],[0,动态库加载失败]</returns>
[DllImport("termb.dll", EntryPoint = "CVR_InitComm", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int CVR_InitComm(int Port);//声明外部的标准动态库, 跟Win32API是一样的
/// <summary>
/// 卡认证
/// 原 型：int CVR_Authenticate (void)
/// 本函数用于读卡器和卡片之间的合法身份确认。卡认证循环间隔大于300ms。
/// </summary>
/// <returns>[值,意义,说明][1,正确,卡片认证成功],[2,错误,寻卡失败],[3,错误,选卡失败],[0,错误,初始化失败]</returns>
[DllImport("termb.dll", EntryPoint = "CVR_Authenticate", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int CVR_Authenticate();
/// <summary>
/// 读卡操作
/// 原 型：int CVR_Read_Content(int active)
/// 本函数用于通过阅读器从第二代居民身份证中读取相应信息。卡认证成功以后才可做读卡操作，读卡完毕若继续读卡应移走二代证卡片重新放置做卡认证。
/// 读卡成功后在termb.dll文件所在路径下生成wz.txt（文字信息）和zp.bmp（照片信息）
/// wz.txt内容示例如下：
/// 张红叶
/// 女
/// 汉
/// 1988-11-18
/// 河北省邯郸市临漳县称勾镇称勾东村复兴路25号
/// 130423198811184328
/// 临漳县公安局
/// 2011.03.30-2021.03.30
/// </summary>
/// <param name="Active">active：兼容以前版本，无实际意义</param>
/// <returns>[1,正确],[2,错误],[99,异常]</returns>
[DllImport("termb.dll", EntryPoint = "CVR_Read_Content", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int CVR_Read_Content(int Active);
/// <summary>
/// 读取文字,照片，指纹，操
/// 原 型：int CVR_Read_FPContent ()
/// 本函数用于通过阅读器从第二代居民身份证中读取相应信息。卡认证成功以后才可做读卡操作，读卡完毕若继续读卡应移走二代证卡片重新放置做卡认证。
/// 读卡成功后在termb.dll文件所在路径下生成wz.txt（文字信息）和zp.bmp（照片信息）
/// wz.txt内容示例如下：
/// 张红叶
/// 女
/// 汉
/// 1988-11-18
/// 河北省邯郸市临漳县称勾镇称勾东村复兴路25号
/// 130423198811184328
/// 临漳县公安局
/// 2011.03.30-2021.03.30
/// </summary>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "CVR_Read_FPContent", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int CVR_Read_FPContent();
/// <summary>
/// 关闭连接
/// 原 型：int CVR_CloseComm(void)
/// </summary>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "CVR_CloseComm", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int CVR_CloseComm();
/// <summary>
/// 得到姓名信息
/// 原 型：int GetPeopleName(char *strTmp, int *strLen)
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetPeopleName", CharSet = CharSet.Ansi, SetLastError = false)]
public static extern int GetPeopleName(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到民族信息
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetPeopleNation", CharSet = CharSet.Ansi, SetLastError = false)]
public static extern int GetPeopleNation(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到出生日期
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetPeopleBirthday", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetPeopleBirthday(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到地址信息
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetPeopleAddress", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetPeopleAddress(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到身份证号信息
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetPeopleIDCode", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetPeopleIDCode(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到发证机关信息
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetDepartment", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetDepartment(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到有效开始日期
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetStartDate", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetStartDate(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到有效截止日期
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetEndDate", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetEndDate(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到性别信息
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <param name="strLen">*strLen 返回的信息长度指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetPeopleSex", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetPeopleSex(ref byte strTmp, ref int strLen);
/// <summary>
/// 读取指纹信息
/// 函数原型：int GetFPDate(unsigned char* pucFPMsgValue,int* nlen)
/// 本函数用于通过阅读器从第二代居民身份证中读取指纹信息。CVR_Read_FPContent()调用成功以后才可以调用该函数
/// 以下是指纹信息的相关说明，供调用者参考：
/// 第一枚指纹信息：
/// pucFPMsgValue[0] 字段文件头类型，记录字符“C”（43H）
/// pucFPMsgValue[1] 指纹算法版本号
/// pucFPMsgValue[2] 指纹采集器代码
/// pucFPMsgValue[3] 指纹算法开发者代码
/// pucFPMsgValue[4] 注册结果代码，01H 表示“注册成功”，02H 表示“注册失败”，03H 表示“未注册”，09H 表示“未知”
/// pucFPMsgValue[5] 指位代码 具体见指位说明
/// pucFPMsgValue[6] 指纹质量值，以00H～64H来表示，值01H表示最低质量，值64H表示最高质量，值00H表示“未知”
/// 第二枚指纹信息：
/// pucFPMsgValue[512] 字段文件头类型，记录字符“C”（43H）
/// pucFPMsgValue[513] 指纹算法版本号
/// pucFPMsgValue[514] 指纹采集器代码
/// pucFPMsgValue[515] 指纹算法开发者代码
/// pucFPMsgValue[516] 注册结果代码，01H 表示“注册成功”，02H 表示“注册失败”，03H 表示“未注册”，09H 表示“未知”
/// pucFPMsgValue[517] 指位代码 具体见指位说明
/// pucFPMsgValue[518] 指纹质量值，以00H～64H来表示，值01H表示最低质量，值64H表示最高质量，值00H表示“未知”
/// 指位码说明：[pucFPMsgValue[5or517],指位]
/// [0BH,右手拇指],[0CH,右手食指],[0DH,右手中指],[0EH,右手环指],[0FH,右手小指]
/// [10H,左手拇指],[11H,左手食指],[12H,左手中指],[13H,左手环指],[14H,左手小指]
/// [61H,右手不确定指位],[62H,左手不确定指位],[63H,其他不确定指位]
/// </summary>
/// <param name="strTmp">pucFPMsgValue 存放指纹信息的内存缓冲，大小由调用者分配1024字节大小。</param>
/// <param name="strLen">nlen 指纹数据的大小，传出参数，0 表示没有指纹信息，大于0表示 存在指纹信息。一个指纹信息转占512字节大小，身份证中一般存储两个指纹信息。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetFPDate", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetFPDate(ref byte strTmp, ref int strLen);
/// <summary>
/// 得到安全模块号
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "CVR_GetSAMID", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int CVR_GetSAMID(ref byte strTmp);
/// <summary>
///
/// </summary>
/// <param name="strTmp">*strTmp 返回的信息缓存指针。</param>
/// <returns>[1,正确],[0,错误]</returns>
[DllImport("termb.dll", EntryPoint = "GetManuID", CharSet = CharSet.Ansi, SetLastError = false, CallingConvention = CallingConvention.StdCall)]
public static extern int GetManuID(ref byte strTmp);
#endregion
#region 语音提示接口
/// <summary>
/// 原 型：int SendReport (int nIndex)
/// 本函数用于PC与华视电子第二代居民身份证阅读器的连接。
/// 参数:nIndex
/// [1,请将您的身份证放在读卡区域内],[2,读卡成功],[3,读卡失败请重新放卡]
/// [4,请采集右手拇指指纹],[5,请采集右手无名指指纹],[6,请采集右手中指指纹],[7,请采集右手食指指纹],[8,请采集右手小指指纹]
/// [9,请采集左手拇指指纹],[10,请采集左手食指指纹],[11,请采集左手中指指纹],[12,请采集左手无名指指纹],[13,请采集左手小指指纹]
/// [14,指纹采集成功],[15,指纹对比成功],[16,请面对摄像头],[17,照片采集成功]
/// </summary>
/// <param name="nIndex">。输入参数</param>
/// <returns>[1,正确],[0,失败]</returns>
[DllImport("HIDSENREPORT.dll", EntryPoint = "SendReport", CharSet = CharSet.Auto, SetLastError = false)]
public static extern int CVR_SendReport(int nIndex);
#endregion
#region 整合类
/// <summary>
/// 指纹仪初始化,不初始化算法
/// </summary>
/// <returns>[1,初始化成功],[-1,初始化失败]</returns>
public static int HelperZhiWenChuShiHua()
{
int ret = LIVESCAN_Init();
if (ret == 1)
{
ret = LIVESCAN_BeginCapture(0);
if (ret == 1)
{
return 1;
}
else
return -1;
}
else
return -1;
}
/// <summary>
/// 指纹仪初始化，初始化算法
/// </summary>
/// <returns>[1,初始化成功],[-1,初始化失败]</returns>
public static int HelperZhiWenChuShiHuaAll()
{
int ret = HelperZhiWenChuShiHua();
if (ret == 1)
{
ret = FP_Begin();
if (ret == 1)
return 1;
else
return -1;
}
else
return -1;
}
/// <summary>
/// 初始化读卡器
/// </summary>
/// <returns>[1,初始化成功],[-1,初始化失败]</returns>
public static int HelperIDCardChuShiHua()
{
int iPort, iRetUSB = 0, iRetCOM = 0;
for (iPort = 1001; iPort <= 1004; iPort++)
{
iRetUSB = CVR_InitComm(iPort);
if (iRetUSB == 1)
{
break;
}
}
if (iRetUSB != 1)
{
for (iPort = 1; iPort <= 4; iPort++)
{
iRetCOM = CVR_InitComm(iPort);
if (iRetCOM == 1)
{
break;
}
}
}
if ((iRetCOM == 1) || (iRetUSB == 1))
{
return 1;
}
else
{
return -1;
}
}
/// <summary>
/// 读取身份证
/// </summary>
/// <returns></returns>
public static PeopleBean HelperGetPeopleBean()
{
int authenticate = CVR_Authenticate();
if (authenticate == 1)
{
int readContent = CVR_Read_FPContent();
if (readContent == 1)
{
PeopleBean people = new PeopleBean();
HelperSendReport(EnumSendReport.读卡成功);
byte[] name = new byte[30];
int length = 30;
GetPeopleName(ref name[0], ref length);
people.name = Encoding.GetEncoding("GB2312").GetString(name).Replace("\0", "").Trim();
byte[] number = new byte[36];
length = 36;
GetPeopleIDCode(ref number[0], ref length);
people.number = Encoding.GetEncoding("GB2312").GetString(number).Replace("\0", "").Trim();
byte[] nation = new byte[4];
length = 4;
GetPeopleNation(ref nation[0], ref length);
people.nation = Encoding.GetEncoding("GB2312").GetString(nation).Replace("\0", "").Trim();
byte[] validtermOfStart = new byte[30];
length = 16;
GetStartDate(ref validtermOfStart[0], ref length);
people.validtermOfStart = Encoding.GetEncoding("GB2312").GetString(validtermOfStart).Replace("\0", "").Trim();
byte[] birthday = new byte[30];
length = 16;
GetPeopleBirthday(ref birthday[0], ref length);
people.birthday = Encoding.GetEncoding("GB2312").GetString(birthday).Replace("\0", "").Trim();
byte[] address = new byte[70];
length = 70;
GetPeopleAddress(ref address[0], ref length);
people.address = Encoding.GetEncoding("GB2312").GetString(address).Replace("\0", "").Trim();
byte[] validtermOfEnd = new byte[30];
length = 16;
GetEndDate(ref validtermOfEnd[0], ref length);
people.validtermOfEnd = Encoding.GetEncoding("GB2312").GetString(validtermOfEnd).Replace("\0", "").Trim();
byte[] signdate = new byte[30];
length = 30;
GetDepartment(ref signdate[0], ref length);
people.signdate = Encoding.GetEncoding("GB2312").GetString(signdate).Replace("\0", "").Trim();
byte[] sex = new byte[30];
length = 3;
GetPeopleSex(ref sex[0], ref length);
people.sex = Encoding.GetEncoding("GB2312").GetString(sex).Replace("\0", "").Trim();
byte[] samid = new byte[32];
CVR_GetSAMID(ref samid[0]);
people.samid = Encoding.GetEncoding("GB2312").GetString(samid).Replace("\0", "").Trim();
byte[] ICFeatureData = new byte[1024];
GetFPDate(ref ICFeatureData[0], ref length);
people.listFeatureDataBean = new List<ICFeatureDataBean>();
ICFeatureDataBean f1 = new ICFeatureDataBean();
Array.Copy(ICFeatureData, 0, f1.buffer, 0, 512);
f1.fileHeadType = ICFeatureData[0];
f1.version = ICFeatureData[1];
f1.collectorCode = ICFeatureData[2];
f1.developerCode = ICFeatureData[3];
f1.registrationResultCode = (EnumRegistrationResult)ICFeatureData[4];
f1.fingerPositionCode = (EnumFingerPosition)ICFeatureData[5];
f1.quality = ICFeatureData[6];
people.listFeatureDataBean.Add(f1);
ICFeatureDataBean f2 = new ICFeatureDataBean();
Array.Copy(ICFeatureData, 512, f2.buffer, 0, 512);
f2.fileHeadType = ICFeatureData[512];
f2.version = ICFeatureData[513];
f2.developerCode = ICFeatureData[514];
f2.collectorCode = ICFeatureData[515];
f2.registrationResultCode = (EnumRegistrationResult)ICFeatureData[516];
f2.fingerPositionCode = (EnumFingerPosition)ICFeatureData[517];
f2.quality = ICFeatureData[518];
people.listFeatureDataBean.Add(f2);
FileStream file = new FileStream(System.Windows.Forms.Application.StartupPath + "\\zp.bmp", FileMode.Open);
Image img = Image.FromStream(file);
file.Close();
people.photo = img;
return people;
}
else
return null;
}
else
return null;
}
/// <summary>
/// 获取指纹
/// </summary>
/// <returns></returns>
public static byte[] HelperGetFPRawData()
{
System.IntPtr pRawData = Marshal.AllocHGlobal(92160);
byte[] RawData = new byte[92160];
int ret = LIVESCAN_GetFPRawData(0, pRawData);
if (ret == 1)
{
Marshal.Copy(pRawData, RawData, 0, 92160);
Marshal.FreeHGlobal(pRawData);
return RawData;
}
else
return null;
}
/// <summary>
/// 获取指纹特征
/// </summary>
/// <param name="cFingerCode"></param>
/// <param name="buffer"></param>
/// <returns></returns>
public static ICFeatureDataBean HelperGetFPFeatureExtract(EnumFingerPosition cFingerCode,byte[] buffer)
{
System.IntPtr pFingerImgBuf1 = Marshal.AllocHGlobal(buffer.Length);
Marshal.Copy(buffer, 0, pFingerImgBuf1, buffer.Length);
System.IntPtr pFingerFeatureBuf1 = Marshal.AllocHGlobal(512);
int ret = FP_FeatureExtract(0, (byte)cFingerCode, pFingerImgBuf1, pFingerFeatureBuf1);
if (ret == 1)
{
byte[] FeatureData = new byte[512];
Marshal.Copy(pFingerFeatureBuf1, FeatureData, 0, 512);
Marshal.FreeHGlobal(pFingerImgBuf1);
Marshal.FreeHGlobal(pFingerFeatureBuf1);
ICFeatureDataBean f1 = new ICFeatureDataBean();
f1.buffer = FeatureData;
f1.fileHeadType = f1.buffer[0];
f1.version = f1.buffer[1];
f1.collectorCode = f1.buffer[2];
f1.developerCode = f1.buffer[3];
f1.registrationResultCode = (EnumRegistrationResult)f1.buffer[4];
f1.fingerPositionCode = (EnumFingerPosition)f1.buffer[5];
f1.quality = f1.buffer[6];
return f1;
}
else
{
Marshal.FreeHGlobal(pFingerImgBuf1);
Marshal.FreeHGlobal(pFingerFeatureBuf1);
return null;
}
}
/// <summary>
/// 获取指纹图像
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static Bitmap HelperGetFPBitmap(byte[] buffer)
{
Bitmap bm = new Bitmap(256, 360, PixelFormat.Format8bppIndexed);
Rectangle dimension = new Rectangle(0, 0, bm.Width, bm.Height);
BitmapData picData = bm.LockBits(dimension, ImageLockMode.ReadWrite, bm.PixelFormat);
IntPtr pixelStartAddress = picData.Scan0;
System.Runtime.InteropServices.Marshal.Copy(buffer, 0, pixelStartAddress, buffer.Length);
bm.UnlockBits(picData);
ColorPalette tempPalette;
using (Bitmap tempBmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed))
{
tempPalette = tempBmp.Palette;
}
for (int i = 0; i < 256; i++)
{
tempPalette.Entries[i] = Color.FromArgb(i, i, i);
}
bm.Palette = tempPalette;
return bm;
}
/// <summary>
/// 获取指纹质量
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static int HelperGetFPQuality(byte[] buffer)
{
System.IntPtr pFingerImgBuf = Marshal.AllocHGlobal(92160);
Marshal.Copy(buffer, 0, pFingerImgBuf, buffer.Length);
int sb = 0;
int ret = FP_GetQualityScore(pFingerImgBuf, ref sb);
if (ret == 1)
return sb;
else
return 0;
}
/// <summary>
/// 指纹特征对比
/// </summary>
/// <param name="buffer1"></param>
/// <param name="buffer2"></param>
/// <returns></returns>
public static float HelperGetFeatureMatch(byte[] buffer1,byte[] buffer2)
{
System.IntPtr pFingerFeatureBuf1 = Marshal.AllocHGlobal(buffer1.Length);
Marshal.Copy(buffer1, 0, pFingerFeatureBuf1, buffer1.Length);
System.IntPtr pFingerFeatureBuf2 = Marshal.AllocHGlobal(buffer2.Length);
Marshal.Copy(buffer2, 0, pFingerFeatureBuf2, buffer2.Length);
float f = 0;
int ret = FP_FeatureMatch(pFingerFeatureBuf1, pFingerFeatureBuf2, ref f);
Marshal.FreeHGlobal(pFingerFeatureBuf1);
Marshal.FreeHGlobal(pFingerFeatureBuf2);
return f;
}
/// <summary>
/// 关闭
/// </summary>
public static void Close()
{
int ret = LIVESCAN_EndCapture(0);
ret = FP_End();
}
/// <summary>
/// 发出声音
/// </summary>
/// <param name="sendReport"></param>
public static void HelperSendReport(EnumSendReport sendReport)
{
CVR_SendReport((int)sendReport);
}
public static void HelperSendReport(EnumFingerPosition figerPostion)
{
switch (figerPostion)
{
case EnumFingerPosition.右手中指:
HelperSendReport(EnumSendReport.请采集右手中指指纹);
break;
case EnumFingerPosition.右手小指:
HelperSendReport(EnumSendReport.请采集右手小指指纹);
break;
case EnumFingerPosition.右手拇指:
HelperSendReport(EnumSendReport.请采集右手拇指指纹);
break;
case EnumFingerPosition.右手环指:
HelperSendReport(EnumSendReport.请采集右手无名指指纹);
break;
case EnumFingerPosition.右手食指:
HelperSendReport(EnumSendReport.请采集右手食指指纹);
break;
case EnumFingerPosition.左手中指:
HelperSendReport(EnumSendReport.请采集左手中指指纹);
break;
case EnumFingerPosition.左手小指:
HelperSendReport(EnumSendReport.请采集左手小指指纹);
break;
case EnumFingerPosition.左手拇指:
HelperSendReport(EnumSendReport.请采集左手拇指指纹);
break;
case EnumFingerPosition.左手环指:
HelperSendReport(EnumSendReport.请采集左手无名指指纹);
break;
case EnumFingerPosition.左手食指:
HelperSendReport(EnumSendReport.请采集左手食指指纹);
break;
}
}
#endregion
#region 附件
/* *
* B.4
* 错误代码 [-1,参数错误],[-2,内存分配失败，没有分配到足够的内存],[-3,功能未实现],[-4,设备不存在],[-5,设备未初始化],[-6,非法错误号],[-9,其他错误]
*
*
* */
#endregion
}
public class PeopleBean
{
/// <summary>
/// 姓名
/// </summary>
public string name { get; set; }
/// <summary>
/// 性别
/// </summary>
public string sex { get; set; }
/// <summary>
/// 民族
/// </summary>
public string nation { get; set; }
/// <summary>
/// 出生日期
/// </summary>
public string birthday { get; set; }
/// <summary>
/// 地址
/// </summary>
public string address { get; set; }
/// <summary>
/// 身份证号码
/// </summary>
public string number { get; set; }
/// <summary>
/// 签发机关
/// </summary>
public string signdate { get; set; }
/// <summary>
/// 起始日期
/// </summary>
public string validtermOfStart { get; set; }
/// <summary>
/// 截至日期
/// </summary>
public string validtermOfEnd { get; set; }
/// <summary>
/// 安全模块号
/// </summary>
public string samid { get; set;}
/// <summary>
/// 指纹
/// </summary>
public List<ICFeatureDataBean> listFeatureDataBean { get; set; }
/// <summary>
/// 照片
/// </summary>
public Image photo { get; set; }
}
/// <summary>
/// 指纹信息
/// </summary>
public class ICFeatureDataBean
{
/// <summary>
/// 文件头类型
/// </summary>
public int fileHeadType { get; set; }
/// <summary>
/// 指纹算法版本号
/// </summary>
public int version { get; set; }
/// <summary>
/// 指纹采集器代码
/// </summary>
public int collectorCode { get; set; }
/// <summary>
/// 指纹算法开发者代码
/// </summary>
public int developerCode { get; set; }
/// <summary>
/// 注册结果代码
/// 01H 表示“注册成功”，02H 表示“注册失败”，03H 表示“未注册”，09H 表示“未知”
/// </summary>
public EnumRegistrationResult registrationResultCode { get; set; }
/// <summary>
/// 指位代码
/// [0BH,右手拇指],[0CH,右手食指],[0DH,右手中指],[0EH,右手环指],[0FH,右手小指]
/// [10H,左手拇指],[11H,左手食指],[12H,左手中指],[13H,左手环指],[14H,左手小指]
/// [61H,右手不确定指位],[62H,左手不确定指位],[63H,其他不确定指位]
/// </summary>
public EnumFingerPosition fingerPositionCode { get; set; }
/// <summary>
/// 质量
/// 值01H表示最低质量，值64H表示最高质量，值00H表示“未知”
/// </summary>
public int quality { get; set; }
/// <summary>
/// 指纹数据
/// </summary>
public byte[] buffer = new byte[512];
}
/// <summary>
/// 注册结果
/// </summary>
public enum EnumRegistrationResult : int
{
注册成功=1,
注册失败=2,
未注册=3,
未知=9,
}
/// <summary>
/// 指位
/// </summary>
public enum EnumFingerPosition :int
{
右手拇指=11,
右手食指=12,
右手中指=13,
右手环指=14,
右手小指=15,
左手拇指=16,
左手食指=17,
左手中指=18,
左手环指=19,
左手小指=20,
右手不确定指位=97,
左手不确定指位=98,
其他不确定指位=99,
}
/// <summary>
/// 声音
/// </summary>
public enum EnumSendReport :int
{
请将您的身份证放在读卡区域内=1,
读卡成功=2,
读卡失败请重新放卡=3,
请采集右手拇指指纹=4,
请采集右手无名指指纹=5,
请采集右手中指指纹=6,
请采集右手食指指纹=7,
请采集右手小指指纹=8,
请采集左手拇指指纹=9,
请采集左手食指指纹=10,
请采集左手中指指纹=11,
请采集左手无名指指纹=12,
请采集左手小指指纹=13,
指纹采集成功=14,
指纹对比成功=15,
请面对摄像头=16,
照片采集成功=17,
}
}using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
namespace API
{
public static class ET99_API
{
#region 常量
/// <summary>
/// 函数执行成功
/// </summary>
public const int ET_SUCCESS = 0x00;
/// <summary>
/// 访问被拒绝，权限不够
/// </summary>
public const int ET_ACCESS_DENY = 0x01;
/// <summary>
/// 通讯错误，没有打开设备
/// </summary>
public const int ET_COMMUNICATIONS_ERROR = 0x02;
/// <summary>
/// 无效的参数，参数出错
/// </summary>
public const int ET_INVALID_PARAMETER = 0x03;
/// <summary>
/// 没有设置 PID
/// </summary>
public const int ET_NOT_SET_PID = 0x04;
/// <summary>
/// 打开指定的设备失败
/// </summary>
public const int ET_UNIT_NOT_FOUND = 0x05;
/// <summary>
/// 硬件错误
/// </summary>
public const int ET_HARD_ERROR = 0x06;
/// <summary>
/// 未知错误
/// </summary>
public const int ET_UNKNOWN_ERROR = 0x07;
/// <summary>
/// 验证 PIN码掩码
/// </summary>
public const int ET_PIN_ERR_MASK = 0x0F;
/// <summary>
/// 验证 PIN码,设备被锁定
/// </summary>
public const int ET_PIN_ERR_LOCKED = 0xF0;
/// <summary>
/// 验证 PIN码错误且永远不锁死
/// </summary>
public const int ET_PIN_ERR_MAX = 0xFF;
/// <summary>
/// 表示验证普通用户 pin
/// </summary>
public const int ET_VERIFY_USERPIN = 0;
/// <summary>
/// 表示验证超级用户 pin
/// </summary>
public const int ET_VERIFY_SOPIN = 1;
/// <summary>
/// 表示数据区可读写
/// </summary>
public const int ET_USER_WRITE_READ = 0;
/// <summary>
/// 表示数据区只允许读
/// </summary>
public const int ET_USER_READ_ONLY = 1;
/// <summary>
/// 常量 PID,默认的产品PID
/// </summary>
public const string CONST_PID = "ffffffff";
#endregion
/// <summary>
/// 根据错误码显示错误提示内容
/// </summary>
/// <param name="result"></param>
public static string ShowResultText(uint result)
{
switch (result)
{
case (ET_SUCCESS):
{
return "操作成功！";
}
case (ET_ACCESS_DENY):
{
return "访问被拒绝，权限不够！";
}
case (ET_COMMUNICATIONS_ERROR):
{
return "通讯错误，没有打开设备 ！";
}
case (ET_INVALID_PARAMETER):
{
return "无效的参数，参数出错 ！";
}
case (ET_NOT_SET_PID):
{
return "没有设置 PID ！";
}
case (ET_UNIT_NOT_FOUND):
{
return "打开指定的设备失败！";
}
case (ET_HARD_ERROR):
{
return "硬件错误！";
}
case (ET_UNKNOWN_ERROR):
{
return "未知错误！";
}
case (ET_PIN_ERR_MAX):
{
return "PIN码错误！请核实。";
}
case (ET_PIN_ERR_LOCKED):
{
return "PIN码错误！设备已经被锁死。";
}
}
//输出剩余PIN验证次数
if (result > ET_PIN_ERR_LOCKED && result < ET_PIN_ERR_MAX)
{
return "PIN码验证错误！剩余重试次数：" + (result - ET_PIN_ERR_LOCKED).ToString();
}
return "未知代码！";
}
/// <summary>
/// 查找计算机上指定 pid 的 ET99 个数。
/// </summary>
/// <param name="pid">[in]产品标识, 为固定长度 8 个字节的字符串； </param>
/// <param name="count">[out]还回的设备个数；</param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_FindToken(byte[] pid, out int count);
/// <summary>
/// 打开指定 PID的硬件,由 index 指定打开硬件的索引， index 应该小于等于找到的 Token 数目。进入匿名用户状态。
/// </summary>
/// <param name="hHandle">[out]打开设备的句柄，返回给用户，供以后的函数调用；</param>
/// <param name="pid">[in]输入的硬件设备的 pid, 为固定长度 8 个字节的字符串；</param>
/// <param name="index">[in]打开第 index 个硬件设备。 </param>
/// <returns>ET_SUCCESS：执行成功。 ET_UNIT_NOT_FOUND：打开指定的设备失败。</returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_OpenToken(ref IntPtr hHandle, byte[] pid, int index);
/// <summary>
/// 关闭指定的设备。
/// </summary>
/// <param name="hHandle">[in] 设备句柄。</param>
/// <returns>ET_SUCCESS：关闭成功。 ET_COMMUNICATIONS_ERROR：没有打开设备。</returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_CloseToken(IntPtr hHandle);
/// <summary>
/// 从指定的位置，读取指定的数据到指定的 BUFFER 中。此函数调用需要有User权限，且调用以后不改变安全状态。
/// </summary>
/// <param name="hHandle">：[in]设备句柄</param>
/// <param name="offset">[in]偏移量 </param>
/// <param name="len">[in]长度，不能超过 60，如果超过则需要读多次。</param>
/// <param name="pucReadBuf">[out]读出的数据存放此缓存区中，调用者保证缓冲区大小至少是 Len，否则可能产生系统存取异常。 </param>
/// <returns>第二章 API接口函数 ET_COMMUNICATIONS_ERROR：没有打开设备。ET_SUCCESS：表示成功。 ET_INVALID_PARAMETER：无效的参数。 ET_NOT_SET_PID：没有设置 PID。 ET_ACCESS_DENY：权限不够。 </returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_Read(IntPtr hHandle, ushort offset, int len, byte[] pucReadBuf);
/// <summary>
/// 将 buf 中，Length 长的数据写到指定的偏移。有存取权限控制。匿名状态不可用，且在普通用户状态时还需要检查设备的配置。不改变安全状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄；</param>
/// <param name="offset">[in]偏移；</param>
/// <param name="len">[in]长度，不能超过 60，如果超过则需要写多次； </param>
/// <param name="pucReadBuf">[in]等写入的数据缓存区指针； </param>
/// <returns>ET_SUCCESS：表示成功。 ET_HARD_ERROR：硬件错误 ET_INVALID_PARAMETER：无效的参数。 ET_NOT_SET_PID：没有设置 PID。 ET_ACCESS_DENY：权限不够。 ET_COMMUNICATIONS_ERROR：没有打开设备。 </returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_Write(IntPtr hHandle, ushort offset, int len, byte[] pucWriteBuf);
/// <summary>
/// 根据参数中指定的种子，产生产品标识。种子长度不能超过 51 个字节。必须在超级用户状态下才能用，调用以后不改变安全状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄； </param>
/// <param name="seedlen">[in]种子； </param>
/// <param name="pucseed">[in]种子长度，小于等于 51； </param>
/// <param name="pid">[out]产生的产品标识, 为固定长度 8 个字节的字符串； </param>
/// <returns>ET_SUCCESS：表示成功； ET_HARD_ERROR：硬件错误 ET_INVALID_PARAMETER：无效的参数； ET_ACCESS_DENY：权限不够，需要先验证 SOPIN。 ET_COMMUNICATIONS_ERROR：没有打开设备。 </returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_GenPID(IntPtr hHandle, int seedlen, byte[] pucseed, StringBuilder pid);
/// <summary>
/// 产生 16 字节的随机数，放到参数指定的 BUF中。调用者需要保护 BUF至少16 字节，否则会产生系统的存取异常。该函数在匿名状态不可用，且在函数调用以后，安全状态不变。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="pucRandBuf">[out]等写入的数据缓存区指针 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_GenRandom(IntPtr hHandle, ref byte[] pucRandBuf);
/// <summary>
/// 产生超级用户 PIN 码
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="seedlen">[in]产生超级用户密码需要的种子。 </param>
/// <param name="pucseed">[in]种子长度，小于等于 51 </param>
/// <param name="pucNewSoPin">：[out]用于存放产生的超级用户密码的缓冲区指针，至少可容纳 16 字节。 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_GenSOPIN(IntPtr hHandle, int seedlen, byte[] pucseed, StringBuilder pucNewSoPin);
/// <summary>
/// 重新设置普通用户密码为 16 个‘F’，相当于解锁。命令执行成功后，当前安全状态变成超级用户状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="pucSoPin">[in]超级用户密码，16 字节。</param>
/// <returns>如果验证超级PIN码错误，并且错误值在0xF0和ET_PIN_ERR_MAX （0xFF）之间,我们可以通过错误码&ET_PIN_ERR_MASK(0x0F)得到剩余重试次数。如果还回 0xF0 表示已经被锁死，如果还回 0xFF 表示验证出错，且 pin 永远不被锁死</returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_ResetPIN(IntPtr hHandle, byte[] pucSoPin);
/// <summary>
/// 更新参数指定的密钥，此密钥是用于计算 HMAC－MD5 的。其中 KEY的获得，是通过一个纯软件接口 HMAC_MD5（），参见相应说明。匿名状态不可用，且在普通用户状态时还需要检查设备配置。不改变安全状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="Keyid">[in]密钥指示，取值范围（1—8） </param>
/// <param name="pucKeyBuf">[in]KEY缓存区指针, KEY固定为 32 字节。 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_SetKey(IntPtr hHandle, int Keyid, byte[] pucKeyBuf);
/// <summary>
/// 标准 HMAC_MD5 的软件实现，参照 RFC2104 标准。
/// </summary>
/// <param name="pucText">[in]等处理的数据缓存区指针，大于 0 小于等于 51 个字节 </param>
/// <param name="ulText_Len">[in]数据长度，大于 0 小于等于 51 </param>
/// <param name="pucKey">[in]密钥，按标准 RFC2104，长度可以任意 </param>
/// <param name="ulKey_Len">[in]密钥长度 </param>
/// <param name="pucToenKey">[out]硬件计算需要的 KEY，固定 32 字节。 </param>
/// <param name="pucDigest">[out]计算结果，固定 16 字节。 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint MD5_HMAC(byte[] pucText, byte ulText_Len, byte[] pucKey, byte ulKey_Len, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 32)]byte[] pucToenKey, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 16)]byte[] pucDigest);
/// <summary>
/// 利用硬件计算 HMAC-MD5 ，pid 为出厂时，还回错误。权限等同于 KEY的读权限。不改变安全状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="Keyid">[in]密钥指示，范围（1—8）</param>
/// <param name="textLen">[in]待计算的数据，大于 0 小于等于 51 个字节 </param>
/// <param name="pucText">[in]数据长度，大于 0 小于等于 51 </param>
/// <param name="digest">[out]散列结果的数据指针，固定长度 16 个字节。 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_HMAC_MD5(IntPtr hHandle, int Keyid, int textLen, byte[] pucText, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 16)]byte[] digest);
/// <summary>
/// 验证密码，以获得相应的安全状态，不受安全状态限制，验证成功以后，进入相应的安全状态。ET_VERIFY_USER_PIN = 验证的是普通用户PIN码，如果验证通过，则进入普通用户状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄；</param>
/// <param name="Flags">[in]验证 PIN的类型，见下表； </param>
/// <param name="pucPIN">[in] PIN 码，固定长度 16 个字节。 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_Verify(IntPtr hHandle, int Flags, byte[] pucPIN);
/// <summary>
/// 修改普通用户密码，从 pucOldPIN，改为 pucNewPIN。普通用户密码长度固定为 16 字节。此命令可以在匿名状态下进行，命令执行成功后，进入普通用户状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄</param>
/// <param name="pucOldPIN">[in]原来的密码，长度固定为 16 字节 </param>
/// <param name="pucNewPIN">[in]新密码，长度固定为 16 字节 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_ChangeUserPIN(IntPtr hHandle, byte[] pucOldPIN, byte[] pucNewPIN);
/// <summary>
/// 重置安全状态，回到匿名用户状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_ResetSecurityState(IntPtr hHandle);
/// <summary>
/// 获得硬件序列号。可以在匿名状态下进行。不改变安全状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="pucSN">[out]用于存放获得的序列号，长度固定为 8 字节 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_GetSN(IntPtr hHandle, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 32)]byte[] pucSN);
/// <summary>
/// 对硬件进行配置。必须在超级用户状态下进行。不改变安全状态。
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <param name="bSoPINRetries">[in]超级 PIN 码的重试次数，范围 0—15，0 表示永远不被锁死；</param>
/// <param name="bUserPINRetries">：[in]用户 PIN 码的重试次数，范围 0—15，0 表示永远不被锁死； </param>
/// <param name="bUserReadOnly">[in]读写/只读标注，如下表； </param>
/// <param name="bBack">[in]保留字，必须为 0。</param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_SetupToken(IntPtr hHandle, byte bSoPINRetries, byte bUserPINRetries, byte bUserReadOnly, byte bBack);
/// <summary>
/// 打开 LED灯，使其变亮。匿名状态不可用，不改变安全状态。设备加电后，LED灯是常亮的
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_TurnOnLED(IntPtr hHandle);
/// <summary>
/// 关闭 LED灯，使其变亮。匿名状态不可用，不改变安全状态。设备加电后，LED灯是常亮的
/// </summary>
/// <param name="hHandle">[in]设备句柄 </param>
/// <returns></returns>
[DllImport("FT_ET99_API.dll")]
public static extern uint et_TurnOffLED(IntPtr hHandle);
internal static void et_Write()
{
throw new Exception("The method or operation is not implemented.");
}
}
}using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
namespace Helper
{
public class ViKeyAPI
{
public const string DefaultUserPassword = "11111111";
public const string DefaultAdminPassword = "00000000";
// 错误代码
public const long VIKEY_SUCCESS = 0x00000000; //成功
public const long VIKEY_ERROR_NO_VIKEY = 0x80000001; //没有找到ViKey加密锁
public const long VIKEY_ERROR_INVALID_PASSWORD = 0x80000002; //密码错误
public const long VIKEY_ERROR_NEED_FIND = 0x80000003; //请先查找加密锁
public const long VIKEY_ERROR_INVALID_INDEX = 0x80000004; //无效的句柄
public const long VIKEY_ERROR_INVALID_VALUE = 0x80000005; //数值错误
public const long VIKEY_ERROR_INVALID_KEY = 0x80000006; //秘钥无效
public const long VIKEY_ERROR_GET_VALUE = 0x80000007; //读取信息错误
public const long VIKEY_ERROR_SET_VALUE = 0x80000008; //设置信息错误
public const long VIKEY_ERROR_NO_CHANCE = 0x80000009; //没有机会
public const long VIKEY_ERROR_NO_TAUTHORITY = 0x8000000A; //权限不足
public const long VIKEY_ERROR_INVALID_ADDR_OR_SIZE = 0x8000000B; //地址或长度错误
public const long VIKEY_ERROR_RANDOM = 0x8000000C; //获取随机数错误
public const long VIKEY_ERROR_SEED = 0x8000000D; //获取种子错误
public const long VIKEY_ERROR_CONNECTION = 0x8000000E; //通信错误
public const long VIKEY_ERROR_CALCULATE = 0x8000000F; //算法或计算错误
public const long VIKEY_ERROR_MODULE = 0x80000010; //计数器错误
public const long VIKEY_ERROR_GENERATE_NEW_PASSWORD = 0x80000011; //产生密码错误
public const long VIKEY_ERROR_ENCRYPT_FAILED = 0x80000012; //加密数据错误
public const long VIKEY_ERROR_DECRYPT_FAILED = 0x80000013; //解密数据错误
public const long VIKEY_ERROR_ALREADY_LOCKED = 0x80000014; //ViKey加密锁已经被锁定
public const long VIKEY_ERROR_UNKNOWN_COMMAND = 0x80000015; //无效的命令
public const long VIKEY_ERROR_UNKNOWN_ERROR = 0xFFFFFFFF; //未知错误
//ViKey加密狗类型 VikeyGetType返回值代表的类型
public const uint ViKeyAPP = 0; //实用型加密狗ViKeyAPP
public const uint ViKeySTD = 1; //标准型加密狗ViKeySTD
public const uint ViKeyNET = 2; //网络型加密狗ViKeyNET
public const uint ViKeyPRO = 3; //专业型加密狗ViKeyPRO
public const uint ViKeyWEB = 4; //身份认证型加密狗ViKeyWEB
public const uint ViKeyTIME = 5; //时间型加密狗ViKeyTIME
#region 翻译
/// <summary>
/// 返回加密狗类型
/// </summary>
/// <param name="res"></param>
/// <returns></returns>
public static string GetTypeName(uint res)
{
if (res == ViKeyAPP)
return "ViKeyApp";
else if (res == ViKeySTD)
return "ViKeySTD";
else if (res == ViKeyNET)
return "ViKeyNET";
else if (res == ViKeyPRO)
return "ViKeyPRO";
else if (res == ViKeyWEB)
return "VikeyWEB";
else if (res == ViKeyTIME)
return "VikeyTIME";
else
return "未知";
}
/// <summary>
/// 获取错误信息
/// </summary>
/// <param name="res"></param>
/// <returns></returns>
public static string GetErrorMsg(uint res)
{
if (res == VIKEY_SUCCESS)
return "成功！";
else if (res == VIKEY_ERROR_NO_VIKEY)
return "没有找到ViKey加密锁";
else if (res == VIKEY_ERROR_INVALID_PASSWORD)
return "密码错误";
else if (res == VIKEY_ERROR_NEED_FIND)
return "请先查找加密锁";
else if (res == VIKEY_ERROR_INVALID_INDEX)
return "无效的句柄";
else if (res == VIKEY_ERROR_INVALID_VALUE)
return "数值错误";
else if (res == VIKEY_ERROR_INVALID_KEY)
return "秘钥无效";
else if (res == VIKEY_ERROR_GET_VALUE)
return "读取信息错误";
else if (res == VIKEY_ERROR_SET_VALUE)
return "设置信息错误";
else if (res == VIKEY_ERROR_NO_CHANCE)
return "没有机会";
else if (res == VIKEY_ERROR_NO_TAUTHORITY)
return "权限不足";
else if (res == VIKEY_ERROR_INVALID_ADDR_OR_SIZE)
return "地址或长度错误";
else if (res == VIKEY_ERROR_RANDOM)
return "获取随机数错误";
else if (res == VIKEY_ERROR_SEED)
return "获取种子错误";
else if (res == VIKEY_ERROR_CONNECTION)
return "通信错误";
else if (res == VIKEY_ERROR_CALCULATE)
return "算法或计算错误";
else if (res == VIKEY_ERROR_MODULE)
return "计数器错误";
else if (res == VIKEY_ERROR_GENERATE_NEW_PASSWORD)
return "产生密码错误";
else if (res == VIKEY_ERROR_ENCRYPT_FAILED)
return "加密数据错误";
else if (res == VIKEY_ERROR_DECRYPT_FAILED)
return "解密数据错误";
else if (res == VIKEY_ERROR_ALREADY_LOCKED)
return "加密锁已经被锁定";
else if (res == VIKEY_ERROR_UNKNOWN_COMMAND)
return "无效的命令";
else if (res == VIKEY_ERROR_UNKNOWN_ERROR)
return "未知错误";
else
return "未知！";
}
#endregion
#region 查找加密狗
// 函数引用声明
/// <summary>
/// 查找系统中的ViKey加密狗
/// 【注意】：程序访问ViKey加密狗前，必须先调用此函数，调用一次就可以。
/// </summary>
/// <param name="pdwCount">如果查找到系统中存在加密狗，返回查找到加密狗的个数</param>
/// <returns>0：表示系统中存在ViKey加密狗 非0：表示系统中没有找到ViKey加密狗</returns>
[DllImport("ViKey")]
public static extern uint VikeyFind(ref uint pdwCount);
#endregion
#region 登录注销加密狗
/// <summary>
/// 用户登陆加密狗，登陆成功后，加密狗的当前权限为用户权限。可以调用VikeyGetLevel获取加密狗的当前权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗 </param>
/// <param name="pUserPassword">【返回】加密狗的用户密码， 8个字母或数字</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义 </returns>
[DllImport("ViKey")]
public static extern uint VikeyUserLogin(ushort Index, Byte[] pUserPassword);
/// <summary>
/// 管理员登陆加密狗，登陆成功后，加密狗的当前权限为管理员权限。可以调用VikeyGetLevel获取加密狗的当前权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗</param>
/// <param name="pAdminPassword">【返回】加密狗的管理员密码， 8个字母或数字</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义 </returns>
[DllImport("ViKey")]
public static extern uint VikeyAdminLogin(ushort Index, Byte[] pAdminPassword);
/// <summary>
/// 登出(关闭)加密狗，调用该函数过后，加密狗的当前权限将变为匿名权限。
/// 当程序不需要对加密狗进行操作时候，调用此函数关闭加密狗，以免其他误操作或者恶意程序对加密狗内部信息进行窃取。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyLogoff(ushort Index);
#endregion
#region 读写加密狗的基本信息
/// <summary>
/// 获取ViKey加密狗的硬件ID
/// 长度为4个字节
/// 一个DWORD
/// 该硬件ID为ViKey加密狗的唯一标识，类似于人的身份证号码.
/// 全球唯一，每个加密狗的都有一个全球唯一的硬件ID.
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗 </param>
/// <param name="pdwHID">【返回】返回ViKey加密狗的硬件ID</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetHID(ushort Index, ref uint pdwHID);
/// <summary>
/// 获取ViKey加密狗的类型。ViKey系列加密狗有很多种类型，可以调用此函数获取当前加密狗的类型。
/// 0 - ViKeyAPP 实用狗
/// 1 - ViKeySTD 标准狗
/// 2 - ViKeyNET 网络狗
/// 3 - ViKeyPRO 专业狗
/// 4 - ViKeyWEB 身份认证狗
/// 5 - ViKeyTIME 时间狗
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗 </param>
/// <param name="pType">【返回】返回加密狗的产品类型 </param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义 </returns>
[DllImport("ViKey")]
public static extern uint VikeyGetType(ushort Index, ref uint pType);
/// <summary>
/// 获取ViKey加密狗的当前权限，ViKey加密狗有三级权限，匿名权限、用户权限、管理员权限
/// 用户登陆(VikeyUserLogin)成功后加密狗的权限自动变为用户权限。
/// 管理员登陆(VikeyAdminLogin)成功后加密狗的权限自动变为管理员权限。
/// 每种权限可以对加密狗的操作均有限制，比如说用户权限，只能对数据区进行读取，不可写入，管理员权限对所有数据均有读写权限。
/// 0 - 匿名权限
/// 1 - 用户权限
/// 2 - 管理员权限
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗 </param>
/// <param name="pLevel">【返回】返回雄狮加密狗的当前权限</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetLevel(ushort Index, ref Byte pLevel);
/// <summary>
/// 设置ViKey加密狗的设备名称，长度为16个字符或8个汉字，字母或数字
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗</param>
/// <param name="szName">【返回】ViKey加密狗的设备名称</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetPtroductName(ushort Index, Byte[] szName);
/// <summary>
/// 获取ViKey加密狗的设备名称，长度为16个字符或8个汉字，字母或数字
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗</param>
/// <param name="szName">【返回】ViKey加密狗的设备名称</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetPtroductName(ushort Index, Byte[] szName);
/// <summary>
/// 设置加密狗的用户密码错误尝试次数，例如设置用户密码错误尝试次数为5，当执行用户登陆时候，如果连续
/// 输入5次错误的密码，加密狗将被锁定，以后将不能登陆。该机制类似于银行卡密码，连续输入3次错误密码，银行卡将被
/// 锁定。有效防止暴力破解、穷举密码的方式破解密码。
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗</param>
/// <param name="cAttempt">【输入】错误密码尝试次数 0：不做限制 非0：限制为指定次数 </param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetUserPassWordAttempt(ushort Index, Byte cAttempt);
/// <summary>
/// 设置加密狗的管理员密码错误尝试次数，例如设置管理员密码错误尝试次数为5，当执行管理员登陆时候，如果连续
/// 输入5次错误的密码，加密狗将被锁定，以后将不能登陆。该机制类似于银行卡密码，连续输入3次错误密码，银行卡将被
/// 锁定。有效防止暴力破解、穷举密码的方式破解密码。
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 比如，一共插了2个加密狗，Index=0表示操作第一个加密狗，Index=1表示操作第二个加密狗</param>
/// <param name="cAttempt">【输入】错误密码尝试次数 0：不做限制 非0：限制为指定次数 </param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetAdminPassWordAttempt(ushort Index, Byte cAttempt);
/// <summary>
/// 获取加密狗的用户密码错误尝试次数，例如设置用户密码错误尝试次数为5，当执行用户登陆时候，如果连续
/// 输入5次错误的密码，加密狗将被锁定，不能登陆。该机制类似于银行卡密码，连续输入3次错误密码，银行卡将被
/// 锁定。有效防止暴力破解。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pcCurrentAttempt">【返回】当前剩余的密码尝试次数</param>
/// <param name="pcMaxAttempt">【返回】最大密码尝试次数，该次数为通过VikeySetUserPassWordAttempt设置的次数</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetUserPassWordAttempt(ushort Index, Byte pcCurrentAttempt, Byte pcMaxAttempt);
/// <summary>
/// 获取加密狗的管理员密码错误尝试次数，例如设置管理员密码错误尝试次数为5，当执行管理员登陆时候，如果连续
/// 输入5次错误的密码，加密狗将被锁定，不能登陆。该机制类似于银行卡密码，连续输入3次错误密码，银行卡将被
/// 锁定。有效防止暴力破解。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pcCurrentAttempt">【返回】当前剩余的密码尝试次数</param>
/// <param name="pcMaxAttempt">【返回】最大密码尝试次数，该次数为通过VikeySetAdminPassWordAttempt设置的次数</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetAdminPassWordAttempt(ushort Index, Byte pcCurrentAttempt, Byte pcMaxAttempt);
#endregion
#region 重置加密狗密码
/// <summary>
/// 修改ViKey加密狗的用户密码和管理员
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限，才能修改成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pNewUserPassword">【输入】加密狗新的用户密码</param>
/// <param name="pNewAdminPassword">【输入】加密狗新的管理员密码</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyResetPassword(ushort Index, Byte[] pNewUserPassword, Byte[] pNewAdminPassword);
#endregion
#region 获取随机数
/// <summary>
/// 获取4个随机数，在程序中程序员可能需要到随机数，可以调用加密狗的该函数获取加密狗中的随机数，更为安全。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pReturn1">【返回】获取随机数1（0~65535）</param>
/// <param name="pReturn2">【返回】获取随机数2（0~65535）</param>
/// <param name="pReturn3">【返回】获取随机数3（0~65535）</param>
/// <param name="pReturn4">【返回】获取随机数4（0~65535）</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint ViKeyRandom(ushort Index, ref ushort pReturn1, ref ushort pReturn2, ref ushort pReturn3, ref ushort pReturn4);
#endregion
#region 数据读写
/// <summary>
/// 设置加密狗的软件ID
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="SoftIDString">【输入】加密狗的软件ID标识， 8个字母或数字</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetSoftIDString(ushort Index, Byte[] SoftIDString);
/// <summary>
/// 获取加密狗的软件ID
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="SoftIDString">【返回】加密狗的软件ID标识， 8个字母或数字</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetSoftIDString(ushort Index, Byte[] SoftIDString);
/// <summary>
/// 读取加密狗的数据，加密狗有数据存储区，可供读写
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限要大于用户权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="pStartAddress">【输入】读取数据的起始地址</param>
/// <param name="pBufferLength">【输入】读取数据的长度</param>
/// <param name="pBuffer">【返回】读取到的数据</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyReadData(ushort Index, ushort pStartAddress, ushort pBufferLength, Byte[] pBuffer);
/// <summary>
/// 写入数据到加密狗，加密狗有数据存储区，可供读写
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="pStartAddress">【输入】写入数据的起始地址</param>
/// <param name="pBufferLength">【输入】写入数据的长度</param>
/// <param name="pBuffer">【返回】写入数据的指针</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyWriteData(ushort Index, ushort pStartAddress, ushort pBufferLength, Byte[] pBuffer);
#endregion
#region 计数器模块
/// <summary>
/// 将指定计数器中的数值减一
/// ViKey加密狗为程序员提供一组计数器，该计数器只能递减，也就是递减计数器，可以设置初始值，调用该函数来实现减一。
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限为用户权限，方可调用成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="ModelueIndex">【输入】计数器的序号</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint ViKeyDecraseModule(ushort Index, ushort ModelueIndex);
/// <summary>
/// 获取加密狗中计数器的值
/// ViKey加密狗为程序员提供一组计数器，该计数器只能递减，也就是递减计数器，可以设置初始值，调用该函数来获取计数器中的数值。
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限为用户权限，方可调用成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="wModuleIndex">【输入】计数器的序号</param>
/// <param name="pwValue">【返回】计数器中的值</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint ViKeyGetModule(ushort Index, ushort wModuleIndex, ushort pwValue);
/// <summary>
/// 设置递减计数器的初始值和模式
/// ViKey加密狗为程序员提供一组计数器，该计数器只能递减，也就是递减计数器，调用该函数来设置计数值的初始状态。
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="ModelueIndex">【输入】计数器的序号</param>
/// <param name="pValue">【输入】计数器的值</param>
/// <param name="pDecrease">【输入】计数器的模式 1：允许递减 0：不允许递减</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint ViKeySetModule(ushort Index, ushort ModelueIndex, ushort pValue, ushort pDecrease);
/// <summary>
/// 检查计数器的数值是否为零 模式是否允许可以递减
/// ViKey加密狗为程序员提供一组计数器，该计数器只能递减，也就是递减计数器，调用该函数来检查计数器中的数值是否为0。
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限为用户权限，方可调用成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="ModelueIndex">【输入】计数器的序号</param>
/// <param name="pIsZero">【输入】是否为零</param>
/// <param name="pCanDecrase">【输入】是否允许递减</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint ViKeyCheckModule(ushort Index, ushort ModelueIndex, ref ushort pIsZero, ref ushort pCanDecrase);
#endregion
#region 加解密算法
/// <summary>
/// 设置DES算法用到的秘钥Key，Des加解密算法是一种国际标准的加解密算法，安全性高，破解难度大.
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pMD5key">【输入】秘钥地址，秘钥长度固定为8个字节</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyDesSetKey(ushort Index, Byte[] pMD5key);
/// <summary>
/// DES加密数据，加密长度必须为8的倍数
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="length">【输入】要加密的数据长度，明文当长度必须为8的倍数</param>
/// <param name="pText">【输入】明文地址</param>
/// <param name="pResult">【返回】加密返回密文地址</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyDesEncrypt(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
/// <summary>
/// DES解密数据，解密长度必须为8的倍数
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="length">【输入】要解密的数据长度，明文当长度必须为8的倍数</param>
/// <param name="pText">【输入】密文地址</param>
/// <param name="pResult">【返回】解密返回明文地址</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyDesDecrypt(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
/// <summary>
/// 设置3DES算法用到的秘钥Key，3Des加解密算法是一种国际标准的加解密算法，安全性高，破解难度大.
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pMD5key">【输入】秘钥地址</param>
/// <param name="keyType">【输入】0表示密钥长度为16字节 1表示密钥长度为24字节</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint Vikey3DesSetKey(ushort Index, Byte[] pMD5key, ushort keyType);
/// <summary>
/// 3DES加密数据，向量为0，ECB模式 ，加密长度必须为8的倍数
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="length">【输入】要加密的数据长度，明文当长度必须为8的倍数</param>
/// <param name="pText">【输入】明文地址</param>
/// <param name="pResult">【返回】加密返回密文地址</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint Vikey3DesEncrypt(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
/// <summary>
/// 3DES解密数据，向量为0，ECB模式 ，解密长度必须为8的倍数
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="length">【输入】要解密的数据长度，明文当长度必须为8的倍数</param>
/// <param name="pText">【输入】密文地址</param>
/// <param name="pResult">【返回】解密返回明文地址</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint Vikey3DesDecrypt(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
#endregion
#region 哈希认证算法
/// <summary>
/// 进行MD5哈希运算
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="length">【输入】数据长度</param>
/// <param name="pText">【输入】数据内容</param>
/// <param name="pResult">【返回】哈希运算结果</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyMD5(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
/// <summary>
/// 设置MD5算法秘钥
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pMD5key">【输入】秘钥内容</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetMD5Key(ushort Index, Byte[] pMD5key);
/// <summary>
/// 进行HMAC_MD5哈希运算
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限为用户权限，方可调用成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号 </param>
/// <param name="length">【输入】输入内容长度</param>
/// <param name="pText">【输入】输入内容</param>
/// <param name="pResult">【返回】计算结果</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyHmacMD5(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
/// <summary>
/// 进行SHA1哈希运算
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="length">【输入】数据长度</param>
/// <param name="pText">【输入】数据内容</param>
/// <param name="pResult">【返回】哈希运算结果</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySHA1(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
/// <summary>
/// 设置SHA1算法秘钥
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pSHA1key">【输入】秘钥内容</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetSHA1Key(ushort Index, Byte[] pSHA1key);
/// <summary>
/// 进行HMAC_SHA1哈希运算
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限为用户权限，方可调用成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="length">【输入】输入内容长度</param>
/// <param name="pText">【输入】输入内容</param>
/// <param name="pResult">【返回】计算结果</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyHmacSHA1(ushort Index, ushort length, Byte[] pText, Byte[] pResult);
#endregion
#region 时钟功能
/// <summary>
/// ViKeyTime时钟型加密狗，内部有独立的电子时钟，可以简单的理解为内部有个和人们带的电子表一样，可以实时获取当前
/// 日期、时间，但是这个日期、时间无法被篡改。该函数就是获取加密狗内部时钟的时间。
/// typedef struct _VIKEY_TIME
///{
/// BYTE cYear;
/// BYTE cMonth;
/// BYTE cDay;
/// BYTE cHour;
/// BYTE cMinute;
/// BYTE cSecond;
///} SVikeyTime, *PVIKEYTIME;
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pTime">【返回】当前日期、时间，6个字节内容分别是年月日时分秒</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetTime(ushort Index, Byte[] pTime);
#endregion
#region 网络功能
/// <summary>
/// 设置网络狗允许连接的最大客户端数，该函数只针对ViKeyNET网络狗有效
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="dwCount">【输入】网络狗允许连接的最大客户端数</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetMaxClientCount(ushort Index, ushort dwCount);
/// <summary>
/// 获取网络狗允许连接的最大客户端数，该函数只针对ViKeyNET网络狗有效
/// 【注意】：此函数需要用户权限，也就是说调用该函数前必须保证加密狗当前权限为用户权限，方可调用成功。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pdwCount">【返回】网络狗允许连接的最大客户端数</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetMaxClientCount(ushort Index, ushort pdwCount);
#endregion
#region 自动打开网页
/// <summary>
/// 在网页应用中，安装加密狗控件后，通过此接口设置自动打开网页的网址
/// 【注意】：此函数需要管理员权限，也就是说调用该函数前必须保证加密狗当前权限为管理员权限。
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pUrl">【输入】自动打开网页的网址，以零结尾的字符串</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeySetAutoRunUrl(ushort Index, Byte[] pUrl);
/// <summary>
/// 通过此接口获取自动打开网页的网址
/// </summary>
/// <param name="Index">【输入】指定加密狗的序号</param>
/// <param name="pUrl">【返回】自动打开网页的网址</param>
/// <returns>0：表示函数执行成功 非0：则表示函数失败，错误原因可以参见错误码含义</returns>
[DllImport("ViKey")]
public static extern uint VikeyGetAutoRunUrl(ushort Index, Byte[] pUrl);
#endregion
[DllImport("ViKey")]
public static extern uint VikeySeed(ushort Index, ref uint pSeed, ref ushort pReturn1, ref ushort pReturn2, ref ushort pReturn3, ref ushort pReturn4);
public static byte[] intToBytes(int value)
{
byte[] src = new byte[4];
src[0] = (byte)((value >> 24) & 0xFF);
src[1] = (byte)((value >> 16) & 0xFF);
src[2] = (byte)((value >> 8) & 0xFF);
src[3] = (byte)(value & 0xFF);
return src;
}
public static int bytesToInt(byte[] src, int offset)
{
int value;
value = (int)(((src[offset] & 0xFF) << 24)
| ((src[offset + 1] & 0xFF) << 16)
| ((src[offset + 2] & 0xFF) << 8)
| (src[offset + 3] & 0xFF));
return value;
}
}
}using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Net;
using System.Net.Mail;
using System.Text;
namespace Helper
{
/// <summary>
/// Author : yenange
/// Date : 2014-02-26
/// Description : 邮件发送辅助类
/// </summary>
public class EmailHelper
{
#region [ 属性(发送Email相关) ]
private string _SmtpHost = string.Empty;
private int _SmtpPort = -1;
private string _FromEmailAddress = string.Empty;
private string _FormEmailPassword = string.Empty;
/// <summary>
/// smtp 服务器
/// </summary>
public string SmtpHost
{
get
{
if (string.IsNullOrEmpty(_SmtpHost))
{
_SmtpHost = ConfigurationManager.AppSettings["SmtpHost"];
}
return _SmtpHost;
}
}
/// <summary>
/// smtp 服务器端口 默认为25
/// </summary>
public int SmtpPort
{
get
{
if (_SmtpPort == -1)
{
if (!int.TryParse(ConfigurationManager.AppSettings["SmtpPort"], out _SmtpPort))
{
_SmtpPort = 25;
}
}
return _SmtpPort;
}
}
/// <summary>
/// 发送者 Eamil 地址
/// </summary>
public string FromEmailAddress
{
get
{
if (string.IsNullOrEmpty(_FromEmailAddress))
{
_FromEmailAddress = ConfigurationManager.AppSettings["FromEmailAddress"];
}
return _FromEmailAddress;
}
}
/// <summary>
/// 发送者 Eamil 密码
/// </summary>
public string FormEmailPassword
{
get
{
if (string.IsNullOrEmpty(_FormEmailPassword))
{
_FormEmailPassword = ConfigurationManager.AppSettings["FormEmailPassword"];
}
return _FormEmailPassword;
}
}
#endregion
#region [ 属性(邮件相关) ]
/// <summary>
/// 收件人 Email 列表，多个邮件地址之间用 半角逗号 分开
/// </summary>
public string ToList { get; set; }
/// <summary>
/// 邮件的抄送者，支持群发，多个邮件地址之间用 半角逗号 分开
/// </summary>
public string CCList { get; set; }
/// <summary>
/// 邮件的密送者，支持群发，多个邮件地址之间用 半角逗号 分开
/// </summary>
public string BccList { get; set; }
/// <summary>
/// 邮件标题
/// </summary>
public string Subject { get; set; }
/// <summary>
/// 邮件正文
/// </summary>
public string Body { get; set; }
private bool _IsBodyHtml = true;
/// <summary>
/// 邮件正文是否为Html格式
/// </summary>
public bool IsBodyHtml
{
get { return _IsBodyHtml; }
set { _IsBodyHtml = value; }
}
/// <summary>
/// 附件列表
/// </summary>
public List<Attachment> AttachmentList { get; set; }
#endregion
#region [ 构造函数 ]
/// <summary>
/// 构造函数 (body默认为html格式)
/// </summary>
/// <param name="toList">收件人列表</param>
/// <param name="subject">邮件标题</param>
/// <param name="body">邮件正文</param>
public EmailHelper(string toList, string subject, string body)
{
this.ToList = toList;
this.Subject = subject;
this.Body = body;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="toList">收件人列表</param>
/// <param name="subject">邮件标题</param>
/// <param name="isBodyHtml">邮件正文是否为Html格式</param>
/// <param name="body">邮件正文</param>
public EmailHelper(string toList, string subject, bool isBodyHtml, string body)
{
this.ToList = toList;
this.Subject = subject;
this.IsBodyHtml = isBodyHtml;
this.Body = body;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="toList">收件人列表</param>
/// <param name="ccList">抄送人列表</param>
/// <param name="bccList">密送人列表</param>
/// <param name="subject">邮件标题</param>
/// <param name="isBodyHtml">邮件正文是否为Html格式</param>
/// <param name="body">邮件正文</param>
public EmailHelper(string toList, string ccList, string bccList, string subject, bool isBodyHtml, string body)
{
this.ToList = toList;
this.CCList = ccList;
this.BccList = bccList;
this.Subject = subject;
this.IsBodyHtml = isBodyHtml;
this.Body = body;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="toList">收件人列表</param>
/// <param name="ccList">抄送人列表</param>
/// <param name="bccList">密送人列表</param>
/// <param name="subject">邮件标题</param>
/// <param name="isBodyHtml">邮件正文是否为Html格式</param>
/// <param name="body">邮件正文</param>
/// <param name="attachmentList">附件列表</param>
public EmailHelper(string toList, string ccList, string bccList, string subject, bool isBodyHtml, string body, List<Attachment> attachmentList)
{
this.ToList = toList;
this.CCList = ccList;
this.BccList = bccList;
this.Subject = subject;
this.IsBodyHtml = isBodyHtml;
this.Body = body;
this.AttachmentList = attachmentList;
}
#endregion
#region [ 发送邮件 ]
/// <summary>
/// 发送邮件
/// </summary>
/// <returns></returns>
public void Send()
{
SmtpClient smtp = new SmtpClient(); //实例化一个SmtpClient
smtp.DeliveryMethod = SmtpDeliveryMethod.Network; //将smtp的出站方式设为 Network
smtp.EnableSsl = false; //smtp服务器是否启用SSL加密
smtp.Host = this.SmtpHost; //指定 smtp 服务器地址
smtp.Port = this.SmtpPort; //指定 smtp 服务器的端口，默认是25，如果采用默认端口，可省去
smtp.UseDefaultCredentials = true; //如果你的SMTP服务器不需要身份认证，则使用下面的方式，不过，目前基本没有不需要认证的了
smtp.Credentials = new NetworkCredential(this.FromEmailAddress, this.FormEmailPassword); //如果需要认证，则用下面的方式
MailMessage mm = new MailMessage(); //实例化一个邮件类
mm.Priority = MailPriority.Normal; //邮件的优先级，分为 Low, Normal, High，通常用 Normal即可
mm.From = new MailAddress(this.FromEmailAddress, "管理员", Encoding.GetEncoding(936));
//收件人
if (!string.IsNullOrEmpty(this.ToList))
mm.To.Add(this.ToList);
//抄送人
if (!string.IsNullOrEmpty(this.CCList))
mm.CC.Add(this.CCList);
//密送人
if (!string.IsNullOrEmpty(this.BccList))
mm.Bcc.Add(this.BccList);
mm.Subject = this.Subject; //邮件标题
mm.SubjectEncoding = Encoding.GetEncoding(936); //这里非常重要，如果你的邮件标题包含中文，这里一定要指定，否则对方收到的极有可能是乱码。
mm.IsBodyHtml = this.IsBodyHtml; //邮件正文是否是HTML格式
mm.BodyEncoding = Encoding.GetEncoding(936); //邮件正文的编码， 设置不正确， 接收者会收到乱码
mm.Body = this.Body; //邮件正文
//邮件附件
if (this.AttachmentList != null && this.AttachmentList.Count > 0)
{
foreach (Attachment attachment in this.AttachmentList)
{
mm.Attachments.Add(attachment);
}
}
//发送邮件，如果不返回异常， 则大功告成了。
smtp.Send(mm);
}
#endregion
}
}using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;
namespace Helper
{
public class FTPHelper
{
/// <summary>
/// FTP请求对象
/// </summary>
FtpWebRequest request = null;
/// <summary>
/// FTP响应对象
/// </summary>
FtpWebResponse response = null;
/// <summary>
/// FTP服务器地址
/// </summary>
public string ftpURI { get; private set; }
/// <summary>
/// FTP服务器IP
/// </summary>
public string ftpServerIP { get; private set; }
/// <summary>
/// FTP服务器默认目录
/// </summary>
public string ftpRemotePath { get; private set; }
/// <summary>
/// FTP服务器登录用户名
/// </summary>
public string ftpUserID { get; private set; }
/// <summary>
/// FTP服务器登录密码
/// </summary>
public string ftpPassword { get; private set; }
/// <summary>
/// 初始化
/// </summary>
/// <param name="FtpServerIP">FTP连接地址</param>
/// <param name="FtpRemotePath">指定FTP连接成功后的当前目录, 如果不指定即默认为根目录</param>
/// <param name="FtpUserID">用户名</param>
/// <param name="FtpPassword">密码</param>
public FTPHelper(string ftpServerIP, string ftpRemotePath, string ftpUserID, string ftpPassword)
{
this.ftpServerIP = ftpServerIP;
this.ftpRemotePath = ftpRemotePath;
this.ftpUserID = ftpUserID;
this.ftpPassword = ftpPassword;
this.ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";
}
~FTPHelper()
{
if (response != null)
{
response.Close();
response = null;
}
if (request != null)
{
request.Abort();
request = null;
}
}
/// <summary>
/// 建立FTP链接,返回响应对象
/// </summary>
/// <param name="uri">FTP地址</param>
/// <param name="ftpMethod">操作命令</param>
/// <returns></returns>
private FtpWebResponse Open(Uri uri, string ftpMethod)
{
request = (FtpWebRequest)FtpWebRequest.Create(uri);
request.Method = ftpMethod;
request.UseBinary = true;
request.KeepAlive = false;
request.Credentials = new NetworkCredential(this.ftpUserID, this.ftpPassword);
return (FtpWebResponse)request.GetResponse();
}
/// <summary>
/// 建立FTP链接,返回请求对象
/// </summary>
/// <param name="uri">FTP地址</param>
/// <param name="ftpMethod">操作命令</param>
private FtpWebRequest OpenRequest(Uri uri, string ftpMethod)
{
request = (FtpWebRequest)WebRequest.Create(uri);
request.Method = ftpMethod;
request.UseBinary = true;
request.KeepAlive = false;
request.Credentials = new NetworkCredential(this.ftpUserID, this.ftpPassword);
return request;
}
/// <summary>
/// 验证登录用户是否合法
/// </summary>
/// <param name="ftpAddress">ftp路径</param>
/// <param name="ftpUserName">ftp用户名</param>
/// <param name="ftpUserPwd">ftp密码</param>
/// <returns></returns>
public bool CheckFtp()
{
bool res = false;
try
{
request = (FtpWebRequest)FtpWebRequest.Create(this.ftpURI);
request.Method = WebRequestMethods.Ftp.ListDirectory;//发送一个请求命令
request.UseBinary = true;
request.KeepAlive = false;
request.Credentials = new NetworkCredential(this.ftpUserID, this.ftpPassword);
FtpWebResponse ftpResponse = (FtpWebResponse)request.GetResponse();//响应一个请求
ftpResponse.Close();
res = true;
}
catch
{
res = false;
}
return res;
}
/// <summary>
/// 验证登录用户是否合法
/// </summary>
/// <param name="ftpAddress">ftp路径</param>
/// <param name="ftpUserName">ftp用户名</param>
/// <param name="ftpUserPwd">ftp密码</param>
/// <returns></returns>
public static bool CheckFtp(string ftpAddress, string ftpUserName, string ftpUserPwd)
{
bool res = false;
try
{
FtpWebRequest ftpWebRequest = (FtpWebRequest)WebRequest.Create("ftp://" + ftpAddress);//创建FtpWebRequest对象
ftpWebRequest.Credentials = new NetworkCredential(ftpUserName, ftpUserPwd);//设置FTP登陆信息
ftpWebRequest.Method = WebRequestMethods.Ftp.ListDirectory;//发送一个请求命令
FtpWebResponse ftpResponse = (FtpWebResponse)ftpWebRequest.GetResponse();//响应一个请求
ftpResponse.Close();//关闭请求
res = true;
}
catch
{
res = false;
}
return res;
}
/// <summary>
/// 创建目录
/// </summary>
/// <param name="remoteDirectoryName">目录名</param>
public void CreateDirectory(string remoteDirectoryName)
{
response = Open(new Uri(ftpURI + remoteDirectoryName), WebRequestMethods.Ftp.MakeDirectory);
}
/// <summary>
/// 更改目录或文件名
/// </summary>
/// <param name="currentName">当前名称</param>
/// <param name="newName">修改后新名称</param>
public void ReName(string currentName, string newName)
{
request = OpenRequest(new Uri(ftpURI + currentName), WebRequestMethods.Ftp.Rename);
request.RenameTo = newName;
response = (FtpWebResponse)request.GetResponse();
}
/// <summary>
/// 切换当前目录
/// </summary>
/// <param name="IsRoot">true:绝对路径 false:相对路径</param>
public void GotoDirectory(string DirectoryName, bool IsRoot)
{
if (IsRoot)
ftpRemotePath = DirectoryName;
else
ftpRemotePath += "/" + DirectoryName;
ftpURI = "ftp://" + ftpServerIP + "/" + ftpRemotePath + "/";
}
/// <summary>
/// 删除目录(包括下面所有子目录和子文件)
/// </summary>
/// <param name="remoteDirectoryName">要删除的带路径目录名：如web/test</param>
/*
* 例：删除test目录
FTPHelper helper = new FTPHelper("x.x.x.x", "web", "user", "password");
helper.RemoveDirectory("web/test");
*/
public void RemoveDirectory(string remoteDirectoryName)
{
GotoDirectory(remoteDirectoryName, true);
var listAll = ListFilesAndDirectories();
foreach (var m in listAll)
{
if (m.IsDirectory)
RemoveDirectory(m.Path);
else
{
GotoDirectory(remoteDirectoryName, true);
DeleteFile(m.Name);
}
}
GotoDirectory(remoteDirectoryName, true);
response = Open(new Uri(ftpURI), WebRequestMethods.Ftp.RemoveDirectory);
}
/// <summary>
/// 删除文件
/// </summary>
/// <param name="remoteFilePatch"></param>
public void RemoveFile(string remoteFilePatch)
{
string directoryName = remoteFilePatch.Substring(0, remoteFilePatch.LastIndexOf('/'));
string fileName = remoteFilePatch.Replace(directoryName, "").Substring(1);
GotoDirectory(directoryName, true);
var listAll = ListFilesAndDirectories();
foreach (var m in listAll)
{
if (m.Name == fileName)
DeleteFile(m.Name);
}
}
/// <summary>
/// 删除所有文件
/// </summary>
/// <param name="remoteFilePatch"></param>
public void RemoveAllFile(string remoteFilePatch)
{
try
{
string directoryName = remoteFilePatch.Substring(0, remoteFilePatch.LastIndexOf('/')) + '/';
if (System.IO.Directory.Exists(directoryName))//判断文件夹是否存在
{
string[] strFiles = System.IO.Directory.GetFiles(remoteFilePatch);//获取文件数组
foreach (var item in strFiles)
{
System.IO.File.Delete(item);
}
}
}
catch (Exception e)
{
System.Diagnostics.Debug.Write(e.Message.ToString());
}
}
/// <summary>
/// 文件上传
/// </summary>
/// <param name="localFilePath">本地文件路径</param>
public void Upload(string localFilePath)
{
FileInfo fileInf = new FileInfo(localFilePath);
request = OpenRequest(new Uri(ftpURI + fileInf.Name), WebRequestMethods.Ftp.UploadFile);
request.ContentLength = fileInf.Length;
int buffLength = 2048;
byte[] buff = new byte[buffLength];
int contentLen;
using (var fs = fileInf.OpenRead())
{
using (var strm = request.GetRequestStream())
{
contentLen = fs.Read(buff, 0, buffLength);
while (contentLen != 0)
{
strm.Write(buff, 0, contentLen);
contentLen = fs.Read(buff, 0, buffLength);
}
}
}
}
/// <summary>
/// 上传图片并压缩
/// </summary>
/// <param name="img"></param>
/// <param name="fileFullName"></param>
public void UploadImg(System.Drawing.Image img, string fileFullName)
{
MemoryStream stream = new MemoryStream();
System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(img);
stream = ImageHelper.CompressImages(bmp, 30);
request = OpenRequest(new Uri(ftpURI + fileFullName), WebRequestMethods.Ftp.UploadFile);
request.ContentLength = stream.Length;
int buffLength = 2048;
byte[] buff = new byte[buffLength];
int contentLen;
stream.Position = 0;
using (var strm = request.GetRequestStream())
{
contentLen = stream.Read(buff, 0, buffLength);
while (contentLen != 0)
{
strm.Write(buff, 0, contentLen);
contentLen = stream.Read(buff, 0, buffLength);
}
}
}
/// <summary>
/// 删除文件
/// </summary>
/// <param name="remoteFileName">要删除的文件名</param>
public void DeleteFile(string remoteFileName)
{
response = Open(new Uri(ftpURI + remoteFileName), WebRequestMethods.Ftp.DeleteFile);
}
/// <summary>
/// 获取当前目录的文件和一级子目录信息
/// </summary>
/// <returns></returns>
public List<FTPFileStruct> ListFilesAndDirectories()
{
var fileList = new List<FTPFileStruct>();
response = Open(new Uri(ftpURI), WebRequestMethods.Ftp.ListDirectoryDetails);
using (var stream = response.GetResponseStream())
{
using (var sr = new StreamReader(stream))
{
string line = null;
while ((line = sr.ReadLine()) != null)
{
//line的格式如下：
//08-18-13 11:05PM <DIR> aspnet_client
//09-22-13 11:39PM 2946 Default.aspx
DateTime dtDate = DateTime.ParseExact(line.Substring(0, 8), "MM-dd-yy", null);
DateTime dtDateTime = DateTime.Parse(dtDate.ToString("yyyy-MM-dd") + line.Substring(8, 9));
string[] arrs = line.Split(' ');
var model = new FTPFileStruct()
{
IsDirectory = line.IndexOf("<DIR>") > 0 ? true : false,
CreateTime = dtDateTime,
Name = arrs[arrs.Length - 1],
Path = ftpRemotePath + "/" + arrs[arrs.Length - 1]
};
fileList.Add(model);
}
}
}
return fileList;
}
/// <summary>
/// 列出当前目录的所有文件
/// </summary>
public List<FTPFileStruct> ListFiles()
{
var listAll = ListFilesAndDirectories();
var listFile = listAll.Where(m => m.IsDirectory == false).ToList();
return listFile;
}
/// <summary>
/// 列出当前目录的所有一级子目录
/// </summary>
public List<FTPFileStruct> ListDirectories()
{
var listAll = ListFilesAndDirectories();
var listFile = listAll.Where(m => m.IsDirectory == true).ToList();
return listFile;
}
/// <summary>
/// 判断当前目录下指定的子目录或文件是否存在
/// </summary>
/// <param name="remoteName">指定的目录或文件名</param>
public bool IsExist(string remoteName)
{
var list = ListFilesAndDirectories();
if (list.Count(m => m.Name == remoteName) > 0)
return true;
return false;
}
/// <summary>
/// 判断当前目录下指定的一级子目录是否存在
/// </summary>
/// <param name="RemoteDirectoryName">指定的目录名</param>
public bool IsDirectoryExist(string remoteDirectoryName)
{
var listDir = ListDirectories();
if (listDir.Count(m => m.Name == remoteDirectoryName) > 0)
return true;
return false;
}
/// <summary>
/// 判断当前目录下指定的子文件是否存在
/// </summary>
/// <param name="RemoteFileName">远程文件名</param>
public bool IsFileExist(string remoteFileName)
{
var listFile = ListFiles();
if (listFile.Count(m => m.Name == remoteFileName) > 0)
return true;
return false;
}
/// <summary>
/// 下载
/// </summary>
/// <param name="saveFilePath">下载后的保存路径</param>
/// <param name="downloadFileName">要下载的文件名</param>
public void Download(string saveFilePath, string downloadFileName)
{
using (FileStream outputStream = new FileStream(saveFilePath + "\\" + downloadFileName, FileMode.Create))
{
response = Open(new Uri(ftpURI + downloadFileName), WebRequestMethods.Ftp.DownloadFile);
using (Stream ftpStream = response.GetResponseStream())
{
long cl = response.ContentLength;
int bufferSize = 2048;
int readCount;
byte[] buffer = new byte[bufferSize];
readCount = ftpStream.Read(buffer, 0, bufferSize);
while (readCount > 0)
{
outputStream.Write(buffer, 0, readCount);
readCount = ftpStream.Read(buffer, 0, bufferSize);
}
}
}
}
/// <summary>
/// 下载文件流
/// </summary>
/// <param name="downloadFileName">要下载的文件名</param>
/// <returns></returns>
public Stream LoadStream(string downloadFileName)
{
response = Open(new Uri(ftpURI + downloadFileName), WebRequestMethods.Ftp.DownloadFile);
using (Stream ftpStream = response.GetResponseStream())
{
return ftpStream;
}
}
/// <summary>
/// 载入远程图片
/// </summary>
/// <param name="downloadFileName">要下载的文件名</param>
/// <returns></returns>
public System.Drawing.Image LoadImg(string downloadFileName)
{
response = Open(new Uri(ftpURI + downloadFileName), WebRequestMethods.Ftp.DownloadFile);
using (Stream ftpStream = response.GetResponseStream())
{
return System.Drawing.Image.FromStream(ftpStream);
}
}
}
public class FTPFileStruct
{
/// <summary>
/// 是否为目录
/// </summary>
public bool IsDirectory { get; set; }
/// <summary>
/// 创建时间
/// </summary>
public DateTime CreateTime { get; set; }
/// <summary>
/// 文件或目录名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 路径
/// </summary>
public string Path { get; set; }
}
}Install-Package System.Data.SQLite.EF6<connectionStrings>
<add name="DB_HES" connectionString="Data Source=|DataDirectory|App_Data\DB_HES.db;Version=3;UseUnicode=true;characterEncoding=UTF-8;" providerName="System.Data.SQLite.EF6" />
</connectionStrings>using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SQLite;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml;
namespace HES.AddAdmin
{
/// <summary>
/// 对SQLite操作的类
/// 引用：System.Data.SQLite.dll【版本：3.6.23.1（原始文件名：SQlite3.DLL）】
/// </summary>
public class SQLiteHelper
{
/// <summary>
/// 所有成员函数都是静态的，构造函数定义为私有
/// </summary>
private SQLiteHelper()
{
}
/// <summary>
/// 连接字符串
/// </summary>
public static string ConnectionString
{//"Data Source=Test.db3;Pooling=true;FailIfMissing=false";
get
{
////(AppSettings节点下的"SQLiteConnectionString")
string text = ConfigurationManager.ConnectionStrings["SQLiteConnectionString"].ConnectionString;
//string str2 = ConfigurationManager.AppSettings["IsEncrypt"];
//if (str2 == "true")
//{
// text = DesEncrypt.Decrypt(text);
//}
return text;
}
}
private static SQLiteConnection _Conn = null;
/// <summary>
/// 连接对象
/// </summary>
public static SQLiteConnection Conn
{
get
{
if (_Conn == null) _Conn = new SQLiteConnection(ConnectionString);
return SQLiteHelper._Conn;
}
set { SQLiteHelper._Conn = value; }
}
#region CreateCommand(commandText,SQLiteParameter[])
/// <summary>
/// 创建命令
/// </summary>
/// <param name="connection">连接</param>
/// <param name="commandText">语句</param>
/// <param name="commandParameters">语句参数.</param>
/// <returns>SQLite Command</returns>
public static SQLiteCommand CreateCommand(string commandText, params SQLiteParameter[] commandParameters)
{
SQLiteCommand cmd = new SQLiteCommand(commandText, Conn);
if (commandParameters.Length > 0)
{
foreach (SQLiteParameter parm in commandParameters)
cmd.Parameters.Add(parm);
}
return cmd;
}
#endregion
#region CreateParameter(parameterName,parameterType,parameterValue)
/// <summary>
/// 创建参数
/// </summary>
/// <param name="parameterName">参数名</param>
/// <param name="parameterType">参数类型</param>
/// <param name="parameterValue">参数值</param>
/// <returns>返回创建的参数</returns>
public static SQLiteParameter CreateParameter(string parameterName, System.Data.DbType parameterType, object parameterValue)
{
SQLiteParameter parameter = new SQLiteParameter();
parameter.DbType = parameterType;
parameter.ParameterName = parameterName;
parameter.Value = parameterValue;
return parameter;
}
#endregion
#region ExecuteDataSet(commandText,paramList[])
/// <summary>
/// 查询数据集
/// </summary>
/// <param name="cn">连接.</param>
/// <param name="commandText">查询语句.</param>
/// <param name="paramList">object参数列表.</param>
/// <returns></returns>
public static DataSet ExecuteDataSet(string commandText, params object[] paramList)
{
SQLiteCommand cmd = Conn.CreateCommand();
cmd.CommandText = commandText;
if (paramList != null)
{
AttachParameters(cmd, commandText, paramList);
}
DataSet ds = new DataSet();
if (Conn.State == ConnectionState.Closed)
Conn.Open();
SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
da.Fill(ds);
da.Dispose();
cmd.Dispose();
Conn.Close();
return ds;
}
#endregion
#region ExecuteDataSet(SQLiteCommand)
/// <summary>
/// 查询数据集
/// </summary>
/// <param name="cmd">SQLiteCommand对象</param>
/// <returns>返回数据集</returns>
public static DataSet ExecuteDataSet(SQLiteCommand cmd)
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
DataSet ds = new DataSet();
SQLiteDataAdapter da = new SQLiteDataAdapter(cmd);
da.Fill(ds);
da.Dispose();
cmd.Connection.Close();
cmd.Dispose();
return ds;
}
#endregion
#region ExecuteDataSet(SQLiteTransaction,commandText,params SQLiteParameter[])
/// <summary>
/// 查询数据集
/// </summary>
/// <param name="transaction">SQLiteTransaction对象. </param>
/// <param name="commandText">查询语句.</param>
/// <param name="commandParameters">命令的参数列表.</param>
/// <returns>DataSet</returns>
/// <remarks>必须手动执行关闭连接transaction.connection.Close</remarks>
public static DataSet ExecuteDataSet(SQLiteTransaction transaction, string commandText, params SQLiteParameter[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed, please provide an open transaction.", "transaction");
IDbCommand cmd = transaction.Connection.CreateCommand();
cmd.CommandText = commandText;
foreach (SQLiteParameter parm in commandParameters)
{
cmd.Parameters.Add(parm);
}
if (transaction.Connection.State == ConnectionState.Closed)
transaction.Connection.Open();
DataSet ds = ExecuteDataSet((SQLiteCommand)cmd);
return ds;
}
#endregion
#region ExecuteDataSet(SQLiteTransaction,commandText,object[] commandParameters)
/// <summary>
/// 查询数据集
/// </summary>
/// <param name="transaction">SQLiteTransaction对象 </param>
/// <param name="commandText">查询语句.</param>
/// <param name="commandParameters">命令参数列表</param>
/// <returns>返回数据集</returns>
/// <remarks>必须手动执行关闭连接transaction.connection.Close</remarks>
public static DataSet ExecuteDataSet(SQLiteTransaction transaction, string commandText, object[] commandParameters)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed, please provide an open transaction.", "transaction");
IDbCommand cmd = transaction.Connection.CreateCommand();
cmd.CommandText = commandText;
AttachParameters((SQLiteCommand)cmd, cmd.CommandText, commandParameters);
if (transaction.Connection.State == ConnectionState.Closed)
transaction.Connection.Open();
DataSet ds = ExecuteDataSet((SQLiteCommand)cmd);
return ds;
}
#endregion
#region UpdateDataset(insertCommand,deleteCommand,updateCommand,dataSet,tableName)
/// <summary>
/// 更新数据集中数据到数据库
/// </summary>
/// <param name="insertCommand">insert语句</param>
/// <param name="deleteCommand">delete语句</param>
/// <param name="updateCommand">update语句</param>
/// <param name="dataSet">要更新的DataSet</param>
/// <param name="tableName">数据集中要更新的table名</param>
public static void UpdateDataset(SQLiteCommand insertCommand, SQLiteCommand deleteCommand, SQLiteCommand updateCommand, DataSet dataSet, string tableName)
{
if (insertCommand == null) throw new ArgumentNullException("insertCommand");
if (deleteCommand == null) throw new ArgumentNullException("deleteCommand");
if (updateCommand == null) throw new ArgumentNullException("updateCommand");
if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
// Create a SQLiteDataAdapter, and dispose of it after we are done
using (SQLiteDataAdapter dataAdapter = new SQLiteDataAdapter())
{
// Set the data adapter commands
dataAdapter.UpdateCommand = updateCommand;
dataAdapter.InsertCommand = insertCommand;
dataAdapter.DeleteCommand = deleteCommand;
// Update the dataset changes in the data source
dataAdapter.Update(dataSet, tableName);
// Commit all the changes made to the DataSet
dataSet.AcceptChanges();
}
}
#endregion
#region ExecuteReader(SQLiteCommand,commandText, object[] paramList)
/// <summary>
/// ExecuteReader方法
/// </summary>
/// <param name="cmd">查询命令</param>
/// <param name="commandText">含有类似@colume参数的sql语句</param>
/// <param name="paramList">语句参数列表</param>
/// <returns>IDataReader</returns>
public static IDataReader ExecuteReader(SQLiteCommand cmd, string commandText, object[] paramList)
{
if (cmd.Connection == null)
throw new ArgumentException("没有为命令指定活动的连接.", "cmd");
cmd.CommandText = commandText;
AttachParameters(cmd, commandText, paramList);
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
IDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
return rdr;
}
#endregion
#region ExecuteNonQuery(commandText,paramList)
/// <summary>
/// 执行ExecuteNonQuery方法
/// </summary>
/// <param name="cn">连接</param>
/// <param name="commandText">语句</param>
/// <param name="paramList">参数</param>
/// <returns></returns>
public static int ExecuteNonQuery(string commandText, params object[] paramList)
{
SQLiteCommand cmd = Conn.CreateCommand();
cmd.CommandText = commandText;
AttachParameters(cmd, commandText, paramList);
if (Conn.State == ConnectionState.Closed)
Conn.Open();
int result = cmd.ExecuteNonQuery();
cmd.Dispose();
Conn.Close();
return result;
}
#endregion
#region ExecuteNonQuery(SQLiteTransaction,commandText,paramList)
/// <summary>
/// 执行ExecuteNonQuery方法,带事务
/// </summary>
/// <param name="transaction">之前创建好的SQLiteTransaction对象</param>
/// <param name="commandText">语句.</param>
/// <param name="paramList">参数.</param>
/// <returns>返回影响的行数</returns>
/// <remarks>
/// 定义事务 DbTransaction trans = conn.BeginTransaction();
/// 或者：SQLiteTransaction trans = Conn.BeginTransaction();
/// 操作代码示例：
/// try
///{
/// // 连续操作记录
/// for (int i = 0; i < 1000; i++)
/// {
/// ExecuteNonQuery(trans,commandText,[] paramList);
/// }
/// trans.Commit();
///}
///catch
///{
/// trans.Rollback();
/// throw;
///}
///trans.Connection.Close();//关闭事务连接
///transaction.Dispose();//释放事务对象
/// </remarks>
public static int ExecuteNonQuery(SQLiteTransaction transaction, string commandText, params object[] paramList)
{
if (transaction == null) throw new ArgumentNullException("transaction is null");
if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rolled back or committed,please provide an open transaction.", "transaction");
using (IDbCommand cmd = transaction.Connection.CreateCommand())
{
cmd.CommandText = commandText;
AttachParameters((SQLiteCommand)cmd, cmd.CommandText, paramList);
if (transaction.Connection.State == ConnectionState.Closed)
transaction.Connection.Open();
int result = cmd.ExecuteNonQuery();
return result;
}
}
#endregion
#region ExecuteNonQuery(IDbCommand)
/// <summary>
/// 执行ExecuteNonQuery方法
/// </summary>
/// <param name="cmd">创建好的命令.</param>
/// <returns></returns>
public static int ExecuteNonQuery(IDbCommand cmd)
{
if (cmd.Connection.State == ConnectionState.Closed)
cmd.Connection.Open();
int result = cmd.ExecuteNonQuery();
cmd.Connection.Close();
cmd.Dispose();
return result;
}
#endregion
#region ExecuteScalar(commandText,paramList)
/// <summary>
/// 执行ExecuteScalar
/// </summary>
/// <param name="commandText">语句s</param>
/// <param name="paramList">参数</param>
/// <returns></returns>
public static object ExecuteScalar(string commandText, params object[] paramList)
{
SQLiteConnection cn = new SQLiteConnection(ConnectionString);
SQLiteCommand cmd = cn.CreateCommand();
cmd.CommandText = commandText;
AttachParameters(cmd, commandText, paramList);
if (cn.State == ConnectionState.Closed)
cn.Open();
object result = cmd.ExecuteScalar();
cmd.Dispose();
cn.Close();
return result;
}
#endregion
#region ExecuteXmlReader(IDbCommand)
/// <summary>
/// ExecuteXmlReader返回xml格式
/// </summary>
/// <param name="command">语句</param>
/// <returns>返回XmlTextReader对象</returns>
public static XmlReader ExecuteXmlReader(IDbCommand command)
{ // open the connection if necessary, but make sure we
// know to close it when we�1�7re done.
if (command.Connection.State != ConnectionState.Open)
{
command.Connection.Open();
}
// get a data adapter
SQLiteDataAdapter da = new SQLiteDataAdapter((SQLiteCommand)command);
DataSet ds = new DataSet();
// fill the data set, and return the schema information
da.MissingSchemaAction = MissingSchemaAction.AddWithKey;
da.Fill(ds);
// convert our dataset to XML
StringReader stream = new StringReader(ds.GetXml());
command.Connection.Close();
// convert our stream of text to an XmlReader
return new XmlTextReader(stream);
}
#endregion
#region AttachParameters(SQLiteCommand,commandText,object[] paramList)
/// <summary>
/// 增加参数到命令（自动判断类型）
/// </summary>
/// <param name="commandText">命令语句</param>
/// <param name="paramList">object参数列表</param>
/// <returns>返回SQLiteParameterCollection参数列表</returns>
/// <remarks>Status experimental. Regex appears to be handling most issues. Note that parameter object array must be in same ///order as parameter names appear in SQL statement.</remarks>
private static SQLiteParameterCollection AttachParameters(SQLiteCommand cmd, string commandText, params object[] paramList)
{
if (paramList == null || paramList.Length == 0) return null;
SQLiteParameterCollection coll = cmd.Parameters;
string parmString = commandText.Substring(commandText.IndexOf("@"));
// pre-process the string so always at least 1 space after a comma.
parmString = parmString.Replace(",", " ,");
// get the named parameters into a match collection
string pattern = @"(@)\S*(.*?)\b";
Regex ex = new Regex(pattern, RegexOptions.IgnoreCase);
MatchCollection mc = ex.Matches(parmString);
string[] paramNames = new string[mc.Count];
int i = 0;
foreach (Match m in mc)
{
paramNames[i] = m.Value;
i++;
}
// now let's type the parameters
int j = 0;
Type t = null;
foreach (object o in paramList)
{
t = o.GetType();
SQLiteParameter parm = new SQLiteParameter();
switch (t.ToString())
{
case ("DBNull"):
case ("Char"):
case ("SByte"):
case ("UInt16"):
case ("UInt32"):
case ("UInt64"):
throw new SystemException("Invalid data type");
case ("System.String"):
parm.DbType = DbType.String;
parm.ParameterName = paramNames[j];
parm.Value = (string)paramList[j];
coll.Add(parm);
break;
case ("System.Byte[]"):
parm.DbType = DbType.Binary;
parm.ParameterName = paramNames[j];
parm.Value = (byte[])paramList[j];
coll.Add(parm);
break;
case ("System.Int32"):
parm.DbType = DbType.Int32;
parm.ParameterName = paramNames[j];
parm.Value = (int)paramList[j];
coll.Add(parm);
break;
case ("System.Boolean"):
parm.DbType = DbType.Boolean;
parm.ParameterName = paramNames[j];
parm.Value = (bool)paramList[j];
coll.Add(parm);
break;
case ("System.DateTime"):
parm.DbType = DbType.DateTime;
parm.ParameterName = paramNames[j];
parm.Value = Convert.ToDateTime(paramList[j]);
coll.Add(parm);
break;
case ("System.Double"):
parm.DbType = DbType.Double;
parm.ParameterName = paramNames[j];
parm.Value = Convert.ToDouble(paramList[j]);
coll.Add(parm);
break;
case ("System.Decimal"):
parm.DbType = DbType.Decimal;
parm.ParameterName = paramNames[j];
parm.Value = Convert.ToDecimal(paramList[j]);
break;
case ("System.Guid"):
parm.DbType = DbType.Guid;
parm.ParameterName = paramNames[j];
parm.Value = (System.Guid)(paramList[j]);
break;
case ("System.Object"):
parm.DbType = DbType.Object;
parm.ParameterName = paramNames[j];
parm.Value = paramList[j];
coll.Add(parm);
break;
default:
throw new SystemException("Value is of unknown data type");
} // end switch
j++;
}
return coll;
}
#endregion
#region ExecuteNonQueryTypedParams(IDbCommand, DataRow)
/// <summary>
/// Executes non query typed params from a DataRow
/// </summary>
/// <param name="command">Command.</param>
/// <param name="dataRow">Data row.</param>
/// <returns>Integer result code</returns>
public static int ExecuteNonQueryTypedParams(IDbCommand command, DataRow dataRow)
{
int retVal = 0;
// If the row has values, the store procedure parameters must be initialized
if (dataRow != null && dataRow.ItemArray.Length > 0)
{
// Set the parameters values
AssignParameterValues(command.Parameters, dataRow);
retVal = ExecuteNonQuery(command);
}
else
{
retVal = ExecuteNonQuery(command);
}
return retVal;
}
#endregion
#region AssignParameterValues
/// <summary>
/// This method assigns dataRow column values to an IDataParameterCollection
/// </summary>
/// <param name="commandParameters">The IDataParameterCollection to be assigned values</param>
/// <param name="dataRow">The dataRow used to hold the command's parameter values</param>
/// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
protected internal static void AssignParameterValues(IDataParameterCollection commandParameters, DataRow dataRow)
{
if (commandParameters == null || dataRow == null)
{
// Do nothing if we get no data
return;
}
DataColumnCollection columns = dataRow.Table.Columns;
int i = 0;
// Set the parameters values
foreach (IDataParameter commandParameter in commandParameters)
{
// Check the parameter name
if (commandParameter.ParameterName == null ||
commandParameter.ParameterName.Length <= 1)
throw new InvalidOperationException(string.Format(
"Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.",
i, commandParameter.ParameterName));
if (columns.Contains(commandParameter.ParameterName))
commandParameter.Value = dataRow[commandParameter.ParameterName];
else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
i++;
}
}
#endregion
#region AssignParameterValues
/// <summary>
/// This method assigns dataRow column values to an array of IDataParameters
/// </summary>
/// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
/// <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
/// <exception cref="System.InvalidOperationException">Thrown if any of the parameter names are invalid.</exception>
protected void AssignParameterValues(IDataParameter[] commandParameters, DataRow dataRow)
{
if ((commandParameters == null) || (dataRow == null))
{
// Do nothing if we get no data
return;
}
DataColumnCollection columns = dataRow.Table.Columns;
int i = 0;
// Set the parameters values
foreach (IDataParameter commandParameter in commandParameters)
{
// Check the parameter name
if (commandParameter.ParameterName == null ||
commandParameter.ParameterName.Length <= 1)
throw new InvalidOperationException(string.Format(
"Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'.",
i, commandParameter.ParameterName));
if (columns.Contains(commandParameter.ParameterName))
commandParameter.Value = dataRow[commandParameter.ParameterName];
else if (columns.Contains(commandParameter.ParameterName.Substring(1)))
commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
i++;
}
}
#endregion
#region AssignParameterValues
/// <summary>
/// This method assigns an array of values to an array of IDataParameters
/// </summary>
/// <param name="commandParameters">Array of IDataParameters to be assigned values</param>
/// <param name="parameterValues">Array of objects holding the values to be assigned</param>
/// <exception cref="System.ArgumentException">Thrown if an incorrect number of parameters are passed.</exception>
protected void AssignParameterValues(IDataParameter[] commandParameters, params object[] parameterValues)
{
if ((commandParameters == null) || (parameterValues == null))
{
// Do nothing if we get no data
return;
}
// We must have the same number of values as we pave parameters to put them in
if (commandParameters.Length != parameterValues.Length)
{
throw new ArgumentException("Parameter count does not match Parameter Value count.");
}
// Iterate through the IDataParameters, assigning the values from the corresponding position in the
// value array
for (int i = 0, j = commandParameters.Length, k = 0; i < j; i++)
{
if (commandParameters[i].Direction != ParameterDirection.ReturnValue)
{
// If the current array value derives from IDataParameter, then assign its Value property
if (parameterValues[k] is IDataParameter)
{
IDataParameter paramInstance;
paramInstance = (IDataParameter)parameterValues[k];
if (paramInstance.Direction == ParameterDirection.ReturnValue)
{
paramInstance = (IDataParameter)parameterValues[++k];
}
if (paramInstance.Value == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = paramInstance.Value;
}
}
else if (parameterValues[k] == null)
{
commandParameters[i].Value = DBNull.Value;
}
else
{
commandParameters[i].Value = parameterValues[k];
}
k++;
}
}
}
#endregion
}
}