标签：return string C# static new 工具 null public

using System;
using System.Collections.Specialized;
using System.IO;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Security.Cryptography.X509Certificates;
using System.Net.Security;
using System.Reflection;
using System.ComponentModel;

namespace DBUtility
{
public class DButility
{
private static Random ran = new Random();
private static readonly int TIMEOUT = 5000;
#region DBNull类型转换
public static long ToInt64(object value)
{
return (Convert.IsDBNull(value)) ? 0 : Convert.ToInt64(value);
}

public static int ToInt32(object value)
{
return (Convert.IsDBNull(value)) ? 0 : Convert.ToInt32(value);
}

public static short ToInt16(object value)
{
return (Convert.IsDBNull(value)) ? (short)0 : Convert.ToInt16(value);
}

public static string ToString(object value)
{
return value.ToString();
}

public static decimal ToDecimal(object value)
{
return (Convert.IsDBNull(value)) ? 0 : Convert.ToDecimal(value);
}

public static DateTime ToDateTime(object value)
{
return (Convert.IsDBNull(value)) ? DateTime.MinValue : Convert.ToDateTime(value);
}
#endregion

#region AES 加密/解密
/// <summary>
/// AES 加密
/// </summary>
/// <param name="str">明文（待加密）</param>
/// <param name="key">密文</param>
/// <returns></returns>
public static string AesEncryptToHex(string str, string key)
{
if (string.IsNullOrEmpty(str)) return null;
Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str); //命名空间： using System.Text;

System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};

System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

var hex = BitConverter.ToString(resultArray, 0).Replace("-", string.Empty).ToLower();
return hex;
}

/// <summary>
/// AES 解密
/// </summary>
/// <param name="str">明文（待解密）</param>
/// <param name="key">密文</param>
/// <returns></returns>
public static string AesDecryptFromHex(string str, string key)
{
if (string.IsNullOrEmpty(str)) return null;
var toEncryptArray = new byte[str.Length / 2];
for (var x = 0; x < toEncryptArray.Length; x++)
{
var i = Convert.ToInt32(str.Substring(x * 2, 2), 16);
toEncryptArray[x] = (byte)i;
}

//Byte[] toEncryptArray = Convert.FromBase64String(str);

System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(key),
Mode = System.Security.Cryptography.CipherMode.ECB,
Padding = System.Security.Cryptography.PaddingMode.PKCS7
};

System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);

return Encoding.UTF8.GetString(resultArray);
}
#endregion

#region 获取时间戳，取随机数
/// <summary>
/// 获取时间戳
/// </summary>
/// <returns></returns>
public static long GetTimeStamp()
{
TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
return Convert.ToInt64(ts.TotalSeconds);
}

/// <summary>
/// 取随机数
/// </summary>
/// <param name="min"></param>
/// <param name="max"></param>
/// <returns></returns>
public static int GetRandom(int min, int max)
{
return ran.Next(min, max);
}

/// <summary>
/// 获取当前本地时间戳
/// </summary>
/// <returns></returns>
public static long GetCurrentTimeUnix()
{
TimeSpan cha = (DateTime.Now - TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)));
long t = (long)cha.TotalSeconds;
return t;
}

/// <summary>
/// 时间戳转换为本地时间对象
/// </summary>
/// <returns></returns>
public static DateTime GetUnixDateTime(long unix)
{
//long unix = 1500863191;
DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
DateTime newTime = dtStart.AddSeconds(unix);
return newTime;
}

/// <summary>
/// Unicode转字符串
/// </summary>
/// <param name="source">经过Unicode编码的字符串</param>
/// <returns>正常字符串</returns>
public static string UnicodeToString(string source)
{
return new Regex(@"\\u([0-9A-F]{4})", RegexOptions.IgnoreCase | RegexOptions.Compiled).Replace(
source, x => string.Empty + Convert.ToChar(Convert.ToUInt16(x.Result("$1"), 16)));
}

/// <summary>
/// Stream流转化为字符串
/// </summary>
/// <returns></returns>
public static string StreamToString(Stream stream)
{
if (stream == null || stream.Length == 0)
{
return string.Empty;
}
StreamReader sr = new StreamReader(stream);
return sr.ReadToEnd();
}

/// <summary>
/// RequestForm转换成String, key=value格式
/// </summary>
/// <returns></returns>
public static string RequestFormToString(NameValueCollection form)
{
if (form == null)
{
return null;
}

string strTemp = string.Empty;

String[] requestItem = form.AllKeys;
for (int i = 0; i < requestItem.Length; i++)
{
strTemp += requestItem[i] + "=" + form[requestItem[i]] + "&";
}

strTemp = strTemp.TrimEnd('&');
return strTemp;
}
#endregion

#region HttpUtils

public static string HttpPost(string Url, string mobiles, string content)
{
string postData = string.Format("mobiles={0}&content={1}", mobiles, content);

HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
System.Net.ServicePointManager.DefaultConnectionLimit = 200;
request.Method = "POST";
request.KeepAlive = false;
request.ContentType = "application/x-www-form-urlencoded";
request.ContentLength = Encoding.UTF8.GetByteCount(postData);
Stream myRequestStream = request.GetRequestStream();
StreamWriter myStreamWriter = new StreamWriter(myRequestStream, Encoding.GetEncoding("gb2312"));
myStreamWriter.Write(postData, 0, postData.Length);
myStreamWriter.Close();
HttpWebResponse response = (HttpWebResponse)request.GetResponse();

Stream myResponseStream = response.GetResponseStream();
StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
string retString = myStreamReader.ReadToEnd();
myStreamReader.Close();

myResponseStream.Close();

response = null;
request = null;
return retString;
}

 

/// <summary>
/// 指定Post地址使用Get 方式获取全部字符串
/// </summary>
/// <param name="url">请求后台地址</param>
/// <returns></returns>
public static string Post(string url, Dictionary<string, string> dic)
{
string result = "";
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
string mobiles = dic["mobiles"];
string content = dic["content"];
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
#region 添加Post 参数
StringBuilder builder = new StringBuilder();
int i = 0;
foreach (var item in dic)
{
if (i > 0)
builder.Append("&");
builder.AppendFormat("{0}={1}", item.Key, item.Value);
i++;
}
byte[] data = Encoding.UTF8.GetBytes(builder.ToString());
req.ContentLength = data.Length;
using (Stream reqStream = req.GetRequestStream())
{
reqStream.Write(data, 0, data.Length);
reqStream.Close();
}
#endregion
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
Stream stream = resp.GetResponseStream();
//获取响应内容
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
{
result = reader.ReadToEnd();
}
return result;
}

/// <summary>
/// 指定地址使用Get 方式获取全部字符串
/// </summary>
/// <param name="url">请求后台地址</param>
/// <returns></returns>
public static string Get(string url, Dictionary<string, string> dic)
{
string result = "";
HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
string uname = dic["username"];
string pwd = dic["password"];
req.Method = "GET";
req.ContentType = "application/x-www-form-urlencoded";
HttpWebResponse resp = (HttpWebResponse)req.GetResponse();
Stream stream = resp.GetResponseStream();
//获取响应内容
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
{
result = reader.ReadToEnd();
}
return result;
}

public static string PostSend(string url, string param)
{
return PostSend(url, "UTF-8", param);
}

public static string PostSend(string url, string encoding, string param, string contentType = "application/x-www-form-urlencoded")
{
try
{
byte[] postData = Encoding.UTF8.GetBytes(param);

HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
Encoding myEncoding = Encoding.UTF8;
request.Method = "POST";
request.KeepAlive = false;
request.AllowAutoRedirect = true;
request.ContentType = contentType;
request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";
request.ContentLength = postData.Length;
request.Timeout = TIMEOUT;

System.IO.Stream outputStream = request.GetRequestStream();
outputStream.Write(postData, 0, postData.Length);
outputStream.Close();

HttpWebResponse response = request.GetResponse() as HttpWebResponse;

Stream responseStream = response.GetResponseStream();

StreamReader reader = new System.IO.StreamReader(responseStream, Encoding.GetEncoding("UTF-8"));

string retVal = reader.ReadToEnd();

reader.Close();

return retVal;
}
catch (Exception ex)
{
LogHelper.Error("PostSend [url:]" + url + " [params:]" + param + " [error:]" + ex.Message);
return ex.Message;
}
}

public static string PostSendWithCert(string url, string param)
{
return PostSendWithCert(url, "UTF-8", param);
}

public static string PostSendWithCert(string url, string encoding, string param, string contentType = "application/x-www-form-urlencoded")
{
try
{
string cert = System.Configuration.ConfigurationManager.AppSettings["CertPath"];
string password = System.Configuration.ConfigurationManager.AppSettings["xcxMchId"];
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
X509Certificate2 cer = new X509Certificate2(cert, password, X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.MachineKeySet);

byte[] postData = Encoding.UTF8.GetBytes(param);

HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
Encoding myEncoding = Encoding.UTF8;
request.ClientCertificates.Add(cer);
request.Method = "POST";
request.KeepAlive = false;
request.AllowAutoRedirect = true;
request.ContentType = contentType;
request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";
request.ContentLength = postData.Length;
request.Timeout = TIMEOUT;

System.IO.Stream outputStream = request.GetRequestStream();
outputStream.Write(postData, 0, postData.Length);
outputStream.Close();

HttpWebResponse response = request.GetResponse() as HttpWebResponse;

Stream responseStream = response.GetResponseStream();

StreamReader reader = new System.IO.StreamReader(responseStream, Encoding.GetEncoding("UTF-8"));

string retVal = reader.ReadToEnd();

reader.Close();

return retVal;
}
catch (Exception ex)
{
LogHelper.Error("PostSend [url:]" + url + " [params:]" + param + " [error:]" + ex.Message);
return ex.Message;
}
}

/// <summary>
/// 发请求获取图片到本地路径
/// </summary>
/// <param name="url"></param>
/// <param name="param"></param>
/// <param name="pathName"></param>
/// <param name="contentType"></param>
public static void PostSaveToFile(string url, string param, string pathName, string contentType = "application/x-www-form-urlencoded")
{
try
{
byte[] postData = Encoding.UTF8.GetBytes(param);

HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
Encoding myEncoding = Encoding.UTF8;
request.Method = "POST";
request.KeepAlive = false;
request.AllowAutoRedirect = true;
request.ContentType = contentType;
request.UserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)";
request.ContentLength = postData.Length;
request.Timeout = TIMEOUT;

System.IO.Stream outputStream = request.GetRequestStream();
outputStream.Write(postData, 0, postData.Length);
outputStream.Close();

HttpWebResponse response = request.GetResponse() as HttpWebResponse;

Stream responseStream = response.GetResponseStream();

System.Drawing.Image.FromStream(responseStream).Save(pathName);
}
catch (Exception ex)
{
LogHelper.Error("PostSend [url:]" + url + " [params:]" + param + " [error:]" + ex.Message);
}
}

public static string HttpGet(string Url, string postDataStr = "")
{
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url + (postDataStr == "" ? "" : "?") + postDataStr);
// https
if (Url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
{
ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
request.ProtocolVersion = HttpVersion.Version10;
}

request.Method = "GET";
request.ContentType = "text/html;charset=UTF-8";
request.Timeout = 3000;

HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream myResponseStream = response.GetResponseStream();
StreamReader myStreamReader = new StreamReader(myResponseStream, Encoding.GetEncoding("utf-8"));
string retString = myStreamReader.ReadToEnd();
myStreamReader.Close();
myResponseStream.Close();

return retString;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return null;
}
}

private static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
{
return true; //总是接受
}
#endregion

#region MD5加密

/// <summary>
///
/// </summary>
/// <param name="sDataIn"></param>
/// <param name="move">给空即可</param>
/// <returns></returns>
public static string GetMD532(string sDataIn, string move)
{
System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
byte[] bytValue, bytHash;
bytValue = System.Text.Encoding.UTF8.GetBytes(move + sDataIn);
bytHash = md5.ComputeHash(bytValue);
md5.Clear();
string sTemp = "";
for (int i = 0; i < bytHash.Length; i++)
{
sTemp += bytHash[i].ToString("x").PadLeft(2, '0');
}
return sTemp;
}

public static string GetMD516(string ConvertString)
{
System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
t2 = t2.Replace("-", "");

t2 = t2.ToLower();

return t2;
}
#endregion
}
#region log4net 日志类
public class LogHelper
{
//在 <configuration></configuration>里面添加下面配置

// <configSections>
// <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler,log4net"/>
//</configSections>

// <log4net>
// <logger name="logerror">
// <level value="ERROR"/>
// <appender-ref ref="ErrorAppender"/>
// </logger>
// <logger name="loginfo">
// <level value="INFO"/>
// <appender-ref ref="InfoAppender"/>
// </logger>
// <appender name="ErrorAppender" type="log4net.Appender.RollingFileAppender">
// <param name="File" value="Log\Error\"/>
// <param name="AppendToFile" value="true"/>
// <param name="CountDirection" value="-1"/>
// <param name="MaxSizeRollBackups" value="15"/>
// <param name="MaximumFileSize" value="5MB"/>
// <param name="lockingModel" type="log4net.Appender.FileAppender+MinimalLock"/>
// <rollingStyle value="Date"/>
// <datePattern value="yyyyMMdd'.txt'"/>
// <staticLogFileName value="false"/>
// <layout type="log4net.Layout.PatternLayout">
// <conversionPattern value="%d [%t]%c %m%n"/>
// </layout>
// </appender>
// <appender name="InfoAppender" type="log4net.Appender.RollingFileAppender">
// <param name="File" value="Log\Info\"/>
// <param name="AppendToFile" value="true"/>
// <param name="CountDirection" value="-1"/>
// <param name="MaxSizeRollBackups" value="15"/>
// <param name="MaximumFileSize" value="5MB"/>
// <param name="lockingModel" type="log4net.Appender.FileAppender+MinimalLock"/>
// <rollingStyle value="Date"/>
// <datePattern value="yyyyMMdd'.txt'"/>
// <staticLogFileName value="false"/>
// <layout type="log4net.Layout.PatternLayout">
// <conversionPattern value="%d [%t]%c %m%n"/>
// </layout>
// </appender>
//</log4net>

private static readonly log4net.ILog ILogInfo = log4net.LogManager.GetLogger("loginfo"); //添加log4net 引用

public static readonly log4net.ILog ILogError = log4net.LogManager.GetLogger("logerror");

public static void Info(string msg)
{
ILogInfo.Info(msg);
}

public static void Error(string msg)
{
ILogError.Error(msg);
}

/// <summary>
/// 废弃 改用FileNameError
/// </summary>
/// <param name="type"></param>
/// <param name="msg"></param>
public static void TypeError(string type, string msg)
{
// eg: type=Order, msg=数据库更新失败, OrderId:111222333
// msg:[Order] 数据库更新失败, OrderId:111222333
ILogError.Error("[" + type + "] " + msg);
}

public static void FileNameInfo(string fileName, string msg)
{
ILogInfo.Info(fileName + " " + msg);
}

public static void FileNameError(string fileName, string msg)
{
ILogError.Error(fileName + " " + msg);
}
}
#endregion

#region DataTable,DataSet,list集合 互转
public class ModelHandler<T> where T : new()
{
#region DataSet=>List
/// <summary>
/// 填充对象列表：用DataSet的第一个表填充实体类
/// </summary>
/// <param name="ds">DataSet</param>
/// <returns></returns>
public List<T> FillModelByDataSet(DataSet ds)
{
if (ds == null || ds.Tables[0] == null || ds.Tables[0].Rows.Count == 0)
{
return null;
}
else
{
return FillModelByDataTable(ds.Tables[0]);
}
}
#endregion

#region DataTable=>List

#region

/// <summary>
/// 类型枚举
/// </summary>
private enum ModelType
{
//值类型
Struct,

Enum,

//引用类型
String,

Object,
Else
}

private static ModelType GetModelType(Type modelType)
{
//值类型
if (modelType.IsEnum)
{
return ModelType.Enum;
}
//值类型
if (modelType.IsValueType)
{
return ModelType.Struct;
}
//引用类型 特殊类型处理
if (modelType == typeof(string))
{
return ModelType.String;
}
//引用类型 特殊类型处理
return modelType == typeof(object) ? ModelType.Object : ModelType.Else;
}

#endregion

/// <summary>
/// 填充对象列表：用DataTable填充实体类
/// </summary>
public List<T> FillModelByDataTable(DataTable dt)
{
if (dt == null || dt.Rows.Count == 0)
{
return null;
}
List<T> modelList = new List<T>();
foreach (DataRow dr in dt.Rows)
{
//T model = (T)Activator.CreateInstance(typeof(T));
T model = new T();
for (int i = 0; i < dr.Table.Columns.Count; i++)
{
PropertyInfo propertyInfo = model.GetType().GetProperty(dr.Table.Columns[i].ColumnName);
if (propertyInfo != null && dr[i] != DBNull.Value)
propertyInfo.SetValue(model, dr[i], null);
}

modelList.Add(model);
}
return modelList;
}

 

/// <summary>
/// datatable转换为List<T>集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="table"></param>
/// <returns></returns>
public static List<T> DataTableToList<T>(DataTable table)
{
var list = new List<T>();
foreach (DataRow item in table.Rows)
{
list.Add(DataRowToModel<T>(item));
}
return list;
}
#endregion

 

#region DataRow=>Model
/// <summary>
/// 填充对象：用DataRow填充实体类
/// </summary>
public T FillModelByDataRow(DataRow dr)
{
if (dr == null)
{
return default(T);
}

//T model = (T)Activator.CreateInstance(typeof(T));
T model = new T();

for (int i = 0; i < dr.Table.Columns.Count; i++)
{
PropertyInfo propertyInfo = model.GetType().GetProperty(dr.Table.Columns[i].ColumnName);
if (propertyInfo != null && dr[i] != DBNull.Value)
propertyInfo.SetValue(model, dr[i], null);
}
return model;
}

public static T DataRowToModel<T>(DataRow row)
{
T model;
var type = typeof(T);
var modelType = GetModelType(type);
switch (modelType)
{
//值类型
case ModelType.Struct:
{
model = default(T);
if (row[0] != null)
model = (T)row[0];
}
break;
//值类型
case ModelType.Enum:
{
model = default(T);
if (row[0] != null)
{
var fiType = row[0].GetType();
if (fiType == typeof(int))
{
model = (T)row[0];
}
else if (fiType == typeof(string))
{
model = (T)Enum.Parse(typeof(T), row[0].ToString());
}
}
}
break;
//引用类型 c#对string也当做值类型处理
case ModelType.String:
{
model = default(T);
if (row[0] != null)
model = (T)row[0];
}
break;
//引用类型 直接返回第一行第一列的值
case ModelType.Object:
{
model = default(T);
if (row[0] != null)
model = (T)row[0];
}
break;
//引用类型
case ModelType.Else:
{
//引用类型 必须对泛型实例化
model = Activator.CreateInstance<T>();
//获取model中的属性
var modelPropertyInfos = type.GetProperties();
//遍历model每一个属性并赋值DataRow对应的列
foreach (var pi in modelPropertyInfos)
{
//获取属性名称
var name = pi.Name;
if (!row.Table.Columns.Contains(name) || row[name] == null || row[name] == DBNull.Value) continue;
var piType = GetModelType(pi.PropertyType);
switch (piType)
{
case ModelType.Struct:
{
object value;
if (!pi.PropertyType.Name.ToLower().Contains("nullable"))
value = Convert.ChangeType(row[name], pi.PropertyType);
else
value = new NullableConverter(pi.PropertyType).ConvertFromString(row[name].ToString());
pi.SetValue(model, value, null);
}
break;

case ModelType.Enum:
{
var fiType = row[0].GetType();
if (fiType == typeof(int))
{
pi.SetValue(model, row[name], null);
}
else if (fiType == typeof(string))
{
var value = (T)Enum.Parse(typeof(T), row[name].ToString());
if (value != null)
pi.SetValue(model, value, null);
}
}
break;

case ModelType.String:
{
var value = Convert.ChangeType(row[name], pi.PropertyType);
pi.SetValue(model, value, null);
}
break;

case ModelType.Object:
{
pi.SetValue(model, row[name], null);
}
break;

case ModelType.Else:
throw new Exception("不支持该类型转换");
default:
throw new Exception("未知类型");
}
}
}
break;

default:
model = default(T);
break;
}
return model;
}

#endregion
}
#endregion

#region SqlHelper
public class SqlHelper
{
/// <summary>
/// 从配置文件中读取数据库连接字符串
/// </summary>
public static string ConnectionString = ConfigurationManager.ConnectionStrings["constr"].ConnectionString;

private static SqlConnection conn;

#region 公共静态方法

/// <summary>
/// 填充DataTable
/// </summary>
/// <param name="spname">存储过程名</param>
/// <param name="sqlParams">参数集</param>
/// <returns>结果datatable</returns>
public static DataTable FillDataTable(string spname, params SqlParameter[] sqlParams)
{
conn = new SqlConnection(ConnectionString);
using (SqlDataAdapter adapter = new SqlDataAdapter(spname, conn))
{
adapter.SelectCommand.CommandType = CommandType.StoredProcedure;
if (sqlParams != null && sqlParams.Length > 0)
{
for (int i = 0; i < sqlParams.Length; i++)
{
adapter.SelectCommand.Parameters.Add(sqlParams[i]);
}
}
DataTable table = new DataTable();
adapter.Fill(table);
return table;
}
}

/// <summary>
/// 执行一条SQL的select语句，用返回的结果填充DataTable
/// </summary>
/// <param name="sql">要执行的SQL语句</param>
/// <param name="oParams">SQL语句中的参数</param>
/// <returns>已填充数据的DataTable</returns>
public static DataTable FillSqlDataTable(string sql, params SqlParameter[] oParams)
{
using (conn = new SqlConnection(ConnectionString))
{
SqlDataAdapter adapter = new SqlDataAdapter(sql, conn);
if (oParams != null && oParams.Length > 0)
{
foreach (SqlParameter prm in oParams)
{
adapter.SelectCommand.Parameters.Add(prm);
}
}
DataTable table = new DataTable();
adapter.Fill(table);
return table;
}
}

/// <summary>
/// 执行一条存储过程，返回SqlDataReader
/// </summary>
/// <param name="spname">存储过程名称</param>
/// <param name="sqlParams">存储过程参数集合</param>
/// <returns>SqlDataReader</returns>
public static SqlDataReader ExecuteReader(string spname, params SqlParameter[] sqlParams)
{
return ExecuteReader(CommandType.StoredProcedure, spname, sqlParams);
}

/// <summary>
/// 执行一条存储过程或SQL语句，返回SqlDataReader
/// </summary>
/// <param name="cmdText">SQL语句或存储过程名称</param>
/// <param name="sqlParams">SQL参数集合</param>
/// <returns>SqlDataReader</returns>
public static SqlDataReader ExecuteReader(CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
{
conn = new SqlConnection(ConnectionString);
using (SqlCommand cmd = new SqlCommand(cmdText, conn))
{
cmd.CommandType = cmdType;
if (sqlParams != null && sqlParams.Length > 0)
{
for (int i = 0; i < sqlParams.Length; i++)
{
cmd.Parameters.Add(sqlParams[i]);
}
}
try
{
cmd.Connection.Open();
return cmd.ExecuteReader(CommandBehavior.CloseConnection);
}
catch
{
cmd.Connection.Close();
throw;
}
}
}

/// <summary>
/// 执行存储过程
/// </summary>
/// <param name="spname">存储过程名称</param>
/// <param name="sqlParams">存储过程参数集合</param>
/// <returns>受影响的记录行数</returns>
public static int ExecuteNonQuery(string spname, params SqlParameter[] sqlParams)
{
return ExecuteNonQuery(CommandType.StoredProcedure, spname, sqlParams);
}

/// <summary>
/// 执行一条SQL语句，获取受SQL语句中delete、update和insert语句影响的行数
/// </summary>
/// <param name="sql">要执行的SQL语句</param>
/// <param name="oParams">SQL语句中的参数</param>
/// <returns>受SQL语句中delete、update和insert语句影响的行数</returns>
public static int ExecuteSqlNonQuery(string sql, params SqlParameter[] oParams)
{
using (conn = new SqlConnection(ConnectionString))
{
SqlCommand cmd = new SqlCommand(sql, conn);
conn.Open();
if (oParams != null && oParams.Length > 0)
{
foreach (SqlParameter prm in oParams)
{
cmd.Parameters.Add(prm);
}
}
int reslt = cmd.ExecuteNonQuery();
conn.Close();
return reslt;
}
}

/// <summary>
/// 执行SQL语句或存储过程
/// </summary>
/// <param name="cmdType">执行类型：SQL语句或存储过程</param>
/// <param name="cmdText">要执行的SQL语句或存储过程名</param>
/// <param name="sqlParams">SQL参数集合</param>
/// <returns>受影响的记录行数</returns>
public static int ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
{
conn = new SqlConnection(ConnectionString);

using (SqlCommand cmd = new SqlCommand(cmdText, conn))
{
cmd.CommandType = cmdType;
if (sqlParams != null && sqlParams.Length > 0)
{
for (int i = 0; i < sqlParams.Length; i++)
{
cmd.Parameters.Add(sqlParams[i]);
}
}
conn.Open();
int j = cmd.ExecuteNonQuery();
conn.Close();
return j;
}
}

/// <summary>
/// 执行SQL语句或存储过程返回第一行第一列的数据
/// </summary>
/// <param name="cmdType">执行类型：SQL语句或存储过程</param>
/// <param name="sqlParams">参数集</param>
/// <param name="cmdText">执行语句</param>
/// <returns>返回第一行第一列的数据</returns>
public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
{
conn = new SqlConnection(ConnectionString);
using (SqlCommand cmd = new SqlCommand(cmdText, conn))
{
cmd.CommandType = cmdType;
if (sqlParams != null && sqlParams.Length > 0)
{
for (int i = 0; i < sqlParams.Length; i++)
{
cmd.Parameters.Add(sqlParams[i]);
}
}
conn.Open();
object obj = null;
try
{
obj = cmd.ExecuteScalar();
}
catch
{
conn.Close();
conn.Open();
obj = cmd.ExecuteScalar();
}
conn.Close();
return obj;
}
}

/// <summary>
/// 执行存储过程，填充DataRow，若无数据则返回null
/// </summary>
/// <param name="spname">执行语句</param>
/// <param name="sqlParams">参数集</param>
/// <returns>返回DataRow</returns>
public static DataRow FillDataRow(string spname, params SqlParameter[] sqlParams)
{
DataTable table = FillDataTable(spname, sqlParams);
if (table.Rows.Count > 0)
return table.Rows[0];
return null;
}

/// <summary>
/// 向数据库中插入或更新数据时，设置存储过程参数
/// </summary>
/// <param name="pName">存储过程参数名</param>
/// <param name="pValue">参数值</param>
/// <returns>返回SqlParameter</returns>
public static SqlParameter SetParam(string pName, object pValue)
{
//如果pValue为null，则直接返回 2004-12-6
if (pValue == null)
return new SqlParameter(pName, pValue);
switch (Type.GetTypeCode(pValue.GetType()))
{
case TypeCode.String:
string tempStr = (string)pValue;
if (tempStr.Equals(null) || tempStr.Trim().Length.Equals(0))
{
return new SqlParameter(pName, DBNull.Value);
}
return new SqlParameter(pName, tempStr);

case TypeCode.DateTime:
DateTime tempdt = (DateTime)pValue;
if (tempdt.Equals(DateTime.MinValue))
{
return new SqlParameter(pName, DBNull.Value);
}
return new SqlParameter(pName, tempdt);

default:
return new SqlParameter(pName, pValue);
}
}

/// <summary>
/// 获取SqlDataReader中指定字符串字段的值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">字段名</param>
/// <returns>字段值，若字段为空则返回空字符串</returns>
public static string GetStringFieldValue(SqlDataReader reader, string fieldName)
{
if (Convert.IsDBNull(reader[fieldName]))
{
return String.Empty;
}
return reader[fieldName].ToString();
}

/// <summary>
/// 获取SqlDataReader中指定Int字段的值，若该字段为空则返回指定的替换值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">字段名</param>
/// <param name="replaceValue">要替换值为空的字段的值</param>
/// <returns>字段值，若该字段为空则返回replaceValue</returns>
public static int GetIntFieldValue(SqlDataReader reader, string fieldName, int replaceValue)
{
if (Convert.IsDBNull(reader[fieldName]))
{
return replaceValue;
}
object obj = reader[fieldName];
return Convert.ToInt32(reader[fieldName]);
}

/// <summary>
/// 获取SqlDataReader中指定Int字段的值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">字段名</param>
/// <returns>字段值，若该字段为空则返回0</returns>
public static int GetIntFieldValue(SqlDataReader reader, string fieldName)
{
return GetIntFieldValue(reader, fieldName, 0);
}

/// <summary>
/// 获取SqlDataReader中指定byte字段（SQL Server中为tinyint类型）的值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">要取值的字段名</param>
/// <returns>返回byte类型结果</returns>
public static byte GetByteFieldValue(SqlDataReader reader, string fieldName)
{
if (Convert.IsDBNull(reader[fieldName]))
return 0;
return (byte)reader[fieldName];
}

/// <summary>
/// 获取SqlDataReader中指定decimal字段的值，若该字段为空则返回指定的替换值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">要取值的字段名</param>
/// <param name="replaceValue">要替换值为空的字段的值</param>
/// <returns>返回double类型结果</returns>
public static Double GetDoubleFieldValue(SqlDataReader reader, string fieldName, Double replaceValue)
{
if (Convert.IsDBNull(reader[fieldName]))
return replaceValue;
return (Double)reader[fieldName];
}

/// <summary>
/// 获取SqlDataReader中指定Int字段的值，若该字段为空则返回0
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">要取值的字段名</param>
/// <returns>返回double类型结果</returns>
public static Double GetDoubleFieldValue(SqlDataReader reader, string fieldName)
{
return GetDoubleFieldValue(reader, fieldName, 0);
}

/// <summary>
/// 获取SqlDataReader中指定float字段的值，若该字段为空则返回0
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">要取值的字段名</param>
/// <returns>返回double类型结果</returns>
public static float GetFloatFieldValue(SqlDataReader reader, string fieldName)
{
return GetFloatFieldValue(reader, fieldName, 0);
}

/// <summary>
/// 获取SqlDataReader中指定decimal字段的值，若该字段为空则返回指定的替换值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">要取值的字段名</param>
/// <param name="replaceValue">要替换值为空的字段的值</param>
/// <returns>返回double类型结果</returns>
public static float GetFloatFieldValue(SqlDataReader reader, string fieldName, float replaceValue)
{
if (Convert.IsDBNull(reader[fieldName]))
return replaceValue;
return float.Parse(reader[fieldName].ToString());
}

/// <summary>
/// 获取SqlDataReader中指定Int字段的值，若该字段为空则返回DateTime的最小值
/// </summary>
/// <param name="reader">包含数据的SqlDataReader</param>
/// <param name="fieldName">要取值的字段名</param>
/// <returns>返回DateTime类型结果</returns>
public static DateTime GetDateTimeFieldValue(SqlDataReader reader, string fieldName)
{
if (Convert.IsDBNull(reader[fieldName]))
return DateTime.MinValue;
return (DateTime)reader[fieldName];
}

#region 仅用于综合查询

/// <summary>
/// 执行查询语句，返回DataSet(zhaibl 09-11-04添加此方法)
/// </summary>
/// <param name="SQLString">查询语句</param>
/// <returns>DataSet</returns>
public static DataSet Query(string SQLString)
{
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
DataSet ds = new DataSet();
try
{
connection.Open();
SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
command.Fill(ds, "ds");
}
catch (System.Data.SqlClient.SqlException ex)
{
throw new Exception(ex.Message);
}
return ds;
}
}

/// <summary>
/// 执行一条计算查询结果语句，返回查询结果（object）。
/// </summary>
/// <param name="SQLString">计算查询结果语句</param>
/// <returns>查询结果（object）</returns>
public static object GetSingle(string SQLString)
{
using (SqlConnection connection = new SqlConnection(ConnectionString))
{
using (SqlCommand cmd = new SqlCommand(SQLString, connection))
{
try
{
connection.Open();
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return null;
}
else
{
return obj;
}
}
catch (System.Data.SqlClient.SqlException e)
{
connection.Close();
throw new Exception(e.Message);
}
}
}
}

/// <summary>
/// 填充数据集(执行带参的sql),返回DataSet
/// </summary>
/// <param name="sql">sql语句</param>
/// <param name="oParams">参数集</param>
/// <returns>datasat</returns>
public static DataSet FillDataSet(string sql, params SqlParameter[] oParams)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
SqlDataAdapter adapter = new SqlDataAdapter(sql, conn);
if (oParams != null && oParams.Length > 0)
{
foreach (SqlParameter prm in oParams)
{
adapter.SelectCommand.Parameters.Add(prm);
}
}
DataSet ds = new DataSet();
adapter.Fill(ds);
return ds;
}
}

/// <summary>
/// 执行一条SQL语句，获取受SQL语句中delete、update和insert语句影响的行数
/// </summary>
/// <param name="sql">要执行的SQL语句</param>
/// <param name="oParams">SQL语句中的参数</param>
/// <returns>受SQL语句中delete、update和insert语句影响的行数</returns>
public static int ExecuteSqlNonQuery1(string sql, params SqlParameter[] oParams)
{
int reslt = 0;
try
{
using (conn = new SqlConnection(ConnectionString))
{
SqlCommand cmd = new SqlCommand(sql, conn);
conn.Open();
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddRange(oParams);
reslt = cmd.ExecuteNonQuery();
conn.Close();
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
return reslt;
}

/// <summary>
/// 获取查询结果
/// </summary>
/// <param name="sql">要执行的SQL语句</param>
/// <returns>DataTable</returns>
public static DataTable GetQueryResult(string sql)
{
DataTable tbl = new DataTable();
conn = new SqlConnection(ConnectionString);
using (SqlDataAdapter adapter = new SqlDataAdapter(sql, conn))
{
adapter.Fill(tbl);
}
conn.Close();
return tbl;
}

#endregion 仅用于综合查询

#endregion 公共静态方法

#region 事务--Bao--2017-08-17

/// <summary>
/// 创建一个事务
/// </summary>
/// <returns></returns>
public static SqlTransaction CreateTrans()
{
conn = new SqlConnection(ConnectionString);
conn.Open();
return conn.BeginTransaction();
}

/// <summary>
/// 关闭并释放与事务有关的资源
/// </summary>
/// <param name="trans"></param>
public static void CloseTrans(SqlTransaction trans)
{
if (trans == null) return;

trans.Dispose();

if (conn == null || conn.State != ConnectionState.Open) return;
conn.Close();
conn.Dispose();
}

/// <summary>
/// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理
/// 使用参数数组提供参数
/// </summary>
/// <param name="trans">一个存在的 sql 事物处理</param>
/// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="sqlParams">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
{
if (trans == null) return ExecuteNonQuery(cmdType, cmdText, sqlParams);

using (SqlCommand cmd = new SqlCommand())
{
PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, sqlParams);
int val = cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
return val;
}
}

/// <summary>
/// 执行SQL语句或存储过程返回第一行第一列的数据
/// </summary>
/// <param name="trans">一个存在的 sql 事物处理</param>
/// <param name="cmdType">执行类型：SQL语句或存储过程</param>
/// <param name="sqlParams">参数集</param>
/// <param name="cmdText">执行语句</param>
/// <returns>返回第一行第一列的数据</returns>
public static object ExecuteScalar(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] sqlParams)
{
if (trans == null) return ExecuteScalar(cmdType, cmdText, sqlParams);

using (SqlCommand cmd = new SqlCommand())
{
PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, sqlParams);
object val = cmd.ExecuteScalar();
cmd.Parameters.Clear();
return val;
}
}

/// <summary>
/// 为执行命令准备参数
/// </summary>
/// <param name="cmd">SqlCommand 命令</param>
/// <param name="conn">已经存在的数据库连接</param>
/// <param name="trans">数据库事物处理</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
/// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
/// <param name="cmdParms">返回带参数的命令</param>
private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
{
//判断数据库连接状态
if (conn.State != ConnectionState.Open)
conn.Open();

cmd.Connection = conn;
cmd.CommandText = cmdText;

//判断是否需要事物处理
if (trans != null)
cmd.Transaction = trans;

cmd.CommandType = cmdType;

if (cmdParms != null)
{
foreach (SqlParameter parm in cmdParms)
cmd.Parameters.Add(parm);
}
}

#endregion 事务--Bao--2017-08-17

public static void LogInfo(string msg)
{
string FilePath = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "log\\";
if (!System.IO.Directory.Exists(FilePath))
{
System.IO.Directory.CreateDirectory(FilePath);
}
try
{
string fileName = FilePath + DateTime.Now.ToString("yyyyMMdd") + ".log";
var logStreamWriter = new System.IO.StreamWriter(fileName, true, Encoding.GetEncoding("gb2312"));

logStreamWriter.WriteLine(msg);
logStreamWriter.Close();
}
catch
{ }
}

#region 标准MD5加密
/// <summary>
/// MD5加密字符串
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string Md5String(string str)
{
string pwd = String.Empty;
MD5 md5 = MD5.Create();
// 编码UTF8/Unicode　
byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(str));
// 转换成字符串
for (int i = 0; i < s.Length; i++)
{
//格式后的字符是小写的字母
//如果使用大写（X）则格式后的字符是大写字符
pwd = pwd + s[i].ToString("x2");
}
return pwd;
}
#endregion

#region 分页

/// <summary>
/// 获取分页数据
/// </summary>
/// <param name="tableName">表名</param>
/// <param name="primaryKey">主键字段名</param>
/// <param name="pageIndex">页码</param>
/// <param name="pageSize">页尺寸</param>
/// <param name="isReCount">返回记录总数, 非 0 值则返回</param>
/// <param name="orderType">设置排序类型, 非 0 值则降序</param>
/// <param name="where">查询条件 (注意: 不要加 where)</param>
/// <param name="recount">返回记录总数</param>
/// <param name="pageCount">返回总页数</param>
/// <returns></returns>
public static DataTable GetPage(string tableName, string primaryKey, int pageIndex, int pageSize, int isReCount, int orderType, string where, out int recount, out int pageCount)
{
string procName = "SP_Page";
SqlParameter[] paras = new SqlParameter[]{
new SqlParameter("@Recount",SqlDbType.Int),
new SqlParameter("@PageCount",SqlDbType.Int),
new SqlParameter("@tblName",tableName),
new SqlParameter("@fldName",primaryKey),
new SqlParameter("@PageSize",pageSize),
new SqlParameter("@PageIndex",pageIndex),
new SqlParameter("@IsReCount",isReCount),
new SqlParameter("@OrderType",orderType),
new SqlParameter("@strWhere",where)
};

paras[0].Direction = ParameterDirection.Output;
paras[1].Direction = ParameterDirection.Output;

DataTable dt = SqlHelper.FillDataTable(procName, paras);

recount = int.Parse(paras[0].Value.ToString());
pageCount = int.Parse(paras[1].Value.ToString());

return dt;
}

 

 

public static string newShowPageNavNew(int pageCurrent, int totalCount, int pageSize = 5, string methodName = "getlist")
{
var totalPage = Math.Max((totalCount + pageSize - 1) / pageSize, 1);
//if (totalPage >= 1)
//{
//要输出的超链接字符串
var pageNav = new StringBuilder();
//左边代码
//无数据
if (totalCount == 0)
{
pageNav.AppendFormat("<div class='col-sm-4'><div class='dataTables_info' id='editable_info' role='alert' aria-live='polite' aria-relevant='all'>显示 0 项，共 0 项</div></div>");
}
else
{
//最后一页文件数量
if (pageCurrent == totalPage)
{
pageNav.AppendFormat("<div class='col-sm-4'><div class='dataTables_info' id='editable_info' role='alert' aria-live='polite' aria-relevant='all'>显示 " + ((pageCurrent - 1) * pageSize + 1) + " 到 " + totalCount + " 项，共 " + totalCount + " 项</div></div>");
}
else
{
pageNav.AppendFormat("<div class='col-sm-4'><div class='dataTables_info' id='editable_info' role='alert' aria-live='polite' aria-relevant='all'>显示 " + ((pageCurrent - 1) * pageSize + 1) + " 到 " + (pageCurrent * pageSize) + " 项，共 " + totalCount + " 项</div></div>");
}
}

//右边代码
pageNav.AppendFormat("<div class='col-sm-8'><div class='dataTables_paginate paging_simple_numbers' id='editable_paginate'><ul class='pagination'>");

//如果当前是第一页，则“上一页”不可点
if (pageCurrent == 1)
{
pageNav.AppendFormat("<li class='paginate_button previous disabled' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)'>上一页</a></li>");
}
else
{
pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", pageCurrent - 1, pageSize, "上一页");
}

//中间页码
if (pageCurrent <= 3)
{
for (int i = 1; i < 8; i++)
{
if (i <= totalPage)
{
if (pageCurrent == i) //当前页处理
{
pageNav.AppendFormat("<li class='paginate_button active' aria-controls='editable' tabindex='0'><a href='javascript:void(0)'>{0}</a></li>", pageCurrent);
}
else //一般页处理
{
pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", i, pageSize, i);
}
}
}
}
else if (pageCurrent > 3 && pageCurrent < totalPage - 3)
{
int current = 4;
for (int i = 1; i < 8; i++)
{
if ((pageCurrent + i - current) >= 1 && (pageCurrent + i - current) <= totalPage)
{
if (current == i) //当前页处理
{
pageNav.AppendFormat("<li class='paginate_button active' aria-controls='editable' tabindex='0'><a href='javascript:void(0)'>{0}</a></li>", pageCurrent);
}
else //一般页处理
{
pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", pageCurrent + i - current, pageSize, pageCurrent + i - current);
}
}
}

}
else
{
for (int i = totalPage - 6; i <= totalPage; i++)
{
if (i <= totalPage && i > 0)
{
if (pageCurrent == i) //当前页处理
{
pageNav.AppendFormat("<li class='paginate_button active' aria-controls='editable' tabindex='0'><a href='javascript:void(0)'>{0}</a></li>", pageCurrent);
}
else //一般页处理
{
pageNav.AppendFormat("<li class='paginate_button previous' aria-controls='editable' tabindex='0' id='editable_previous'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", i, pageSize, i);
}
}
}
}

//如果当前是最后一页，则“下一页”不可点
if (pageCurrent == totalPage)
{
pageNav.AppendFormat("<li class='paginate_button next disabled' aria-controls='editable' tabindex='0' id='editable_next'><a href='javascript:void(0)'>下一页</a></li>");
}
else
{
pageNav.AppendFormat("<li class='paginate_button next' aria-controls='editable' tabindex='0' id='editable_next'><a href='javascript:void(0)' onclick='" + methodName + "({0},{1})'>{2}</a></li>", pageCurrent + 1, pageSize, "下一页");
}
pageNav.AppendFormat("</ul></div></div>");
return pageNav.ToString();
//}
//else
//{
// return string.Empty;
//}
}
#endregion
}
#endregion
}

标签：return,string,C#,static,new,工具,null,public
来源： https://www.cnblogs.com/zhangxiaobai88126/p/16287079.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。