C# 常用公共方法

2024-03-15 04:35:05 273

C#常用公共方法，具体内容如下

1.后台调用weburl

stringhostUrl="http://www.a.com?id=123";
HttpWebRequestmyReq=(HttpWebRequest)WebRequest.Create(hostUrl);
myReq.Method="GET";

HttpWebResponseHttpWResp=(HttpWebResponse)myReq.GetResponse();
StreammyStream=HttpWResp.GetResponseStream();
StreamReadersr=newStreamReader(myStream,Encoding.UTF8);
StringBuilderstrBuilder=newStringBuilder();
while(-1!=sr.Peek())
{
strBuilder.Append(sr.ReadLine());
}
sr.Close();
myStream.Close();
HttpWResp.Close();

Newtonsoft.Json.Linq.JObjectjo=(Newtonsoft.Json.Linq.JObject)Newtonsoft.Json.JsonConvert.DeserializeObject(strBuilder.ToString());
stringresCode=jo["ReturnCode"].ToString();

2.检测输入URL是否合法

///<summary>
///判断网址是否可以访问
///</summary>
///<paramname="Url"></param>
///<returns></returns>
protectedboolChkPageUrl(stringurl)
{
boolresult=false;
try
{
HttpWebRequestmyHttpWebRequest=(HttpWebRequest)WebRequest.Create(url);
myHttpWebRequest.UserAgent="Mozilla/5.0(WindowsNT6.1;WOW64;Trident/7.0;rv:11.0)likeGecko";
myHttpWebRequest.Method="GET";
HttpWebResponsemyHttpWebResponse=(HttpWebResponse)myHttpWebRequest.GetResponse();
if(myHttpWebResponse.StatusCode==HttpStatusCode.OK)
{
result=true;
}
myHttpWebResponse.Close();
}
catch
{
result=false;
}

returnresult;
}

3.批量导出

///<summary>
///批量导出
///</summary>
///<returns></returns>
publicFileResultExportStu()
{
//创建Excel文件的对象
NPOI.HSSF.UserModel.HSSFWorkbookbook=newNPOI.HSSF.UserModel.HSSFWorkbook();
//添加一个sheet
NPOI.SS.UserModel.ISheetsheet1=book.CreateSheet("Sheet1");
intpager_totalcount=(int)Session["pager_totalcount"];
inttotalCount=0;
//获取list数据
List<ArticleEntity>infoList=newAchieveDAL.MyTestDAL().GetArticleList("",pager_totalcount,1,outtotalCount);

//给sheet1添加第一行的头部标题
NPOI.SS.UserModel.IRowrow1=sheet1.CreateRow(0);
//创建时间名称商户订单号|交易号对方金额(元)状态
row1.CreateCell(0).SetCellValue("编号");
row1.CreateCell(1).SetCellValue("标题");
row1.CreateCell(2).SetCellValue("内容");
intWidth=256;
sheet1.SetColumnWidth(0,10*Width);
sheet1.SetColumnWidth(1,25*Width);
sheet1.SetColumnWidth(2,60*Width);
if(infoList!=null)
{
varlist=infoList.OrderByDescending(p=>p.ID);

if(list!=null)
{
inti=0;
//将数据逐步写入sheet1各个行
foreach(variteminlist)
{
i=i+1;
NPOI.SS.UserModel.IRowrowtemp=sheet1.CreateRow(i);
rowtemp.CreateCell(0).SetCellValue(item.ID.ToString());
rowtemp.CreateCell(1).SetCellValue(item.Title==null?"":item.Title.ToString());
rowtemp.CreateCell(2).SetCellValue(item.Content==null?"":item.Content.ToString());
}
}
}
//写入到客户端
System.IO.MemoryStreamms=newSystem.IO.MemoryStream();
book.Write(ms);
ms.Seek(0,System.IO.SeekOrigin.Begin);
returnFile(ms,"application/vnd.ms-excel",HttpUtility.UrlEncode("导出",Encoding.UTF8).ToString()+DateTime.Now.ToString("yyyyMMddHHmmss")+".xls");

}

4.批量导入

<inputname="file"type="file"id="file"/>
<inputtype="submit"name="Upload"value="上传"/>

///<summary>
///批量导入
///</summary>
///<returns></returns>
[HttpPost]
publicActionResultImportStu()
{
HttpPostedFileBasefile=Request.Files["file"];
stringFileName;
stringsavePath;
if(file==null||file.ContentLength<=0)
{
returnContent("<script>alert('上传失败,请选择上传文件!');location.href='/MyTest/MVCPager';</script>");
}
else
{
stringfilename=Path.GetFileName(file.FileName);
intfilesize=file.ContentLength;//获取上传文件的大小单位为字节byte
stringfileEx=System.IO.Path.GetExtension(filename);//获取上传文件的扩展名
stringNoFileName=System.IO.Path.GetFileNameWithoutExtension(filename);//获取无扩展名的文件名
stringFileType=".xls,.xlsx";//定义上传文件的类型字符串
if(FileType.Contains(".exe"))//EXCEL
{
returnContent("<script>alert('上传文件类型格式错误,不允许导入exe格式的文件!');location.href='/MyTest/MVCPager';</script>");
}
FileName=NoFileName+DateTime.Now.ToString("yyyyMMddhhmmss")+fileEx;
stringpath=AppDomain.CurrentDomain.BaseDirectory+"uploads/";
savePath=Path.Combine(path,FileName);
file.SaveAs(savePath);

if(FileType.Contains(fileEx))//EXCEL
{
stringstrConn="Provider=Microsoft.Jet.OLEDB.4.0;DataSource="+savePath+";"+"ExtendedProperties=Excel8.0";
OleDbConnectionconn=newOleDbConnection(strConn);
conn.Open();
OleDbDataAdaptermyCommand=newOleDbDataAdapter("select*from[Sheet1$]",strConn);
DataSetmyDataSet=newDataSet();
try
{
myCommand.Fill(myDataSet,"ExcelInfo");
}
catch(Exceptionex)
{
returnContent("<script>alert('上传失败,"+ex.Message+"!');location.href='/MyTest/MVCPager';</script>");
}
//列顺序标题内容
DataTabletable=myDataSet.Tables["ExcelInfo"].DefaultView.ToTable();

//事物异常回滚
using(TransactionScopetransaction=newTransactionScope())
{
for(inti=0;i<table.Rows.Count;i++)
{
ArticleEntitymodel=newArticleEntity();
model.Title=table.Rows[i][0].ToString();
model.Content=table.Rows[i][1].ToString();
newAchieveDAL.MyTestDAL().AddArticle(model);
}
transaction.Complete();
}
}

returnRedirectToAction("MVCPager","MyTest");
}
}

5.获取客户端的IP地址

///<summary>
///获取客户端的IP地址
///</summary>
///<returns>客户端IP地址</returns>
publicstaticstringGet_ClientIP()
{
stringresult=string.Empty;
result=HttpContext.Current.Request.Headers["X-Real-IP"];//Nginx为前端时获取IP地址的方法
if(result!=null)
returnresult;

if(HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"]!=null)//发出请求的远程主机的IP地址
{
result=HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"].ToString();
}
elseif(HttpContext.Current.Request.ServerVariables["HTTP_VIA"]!=null)//判断是否设置代理，若使用了代理
{
if(HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"]!=null)//获取代理服务器的IP
{
result=HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"].ToString();
}
else
{
result=HttpContext.Current.Request.UserHostAddress;
}
}
else
{
result=HttpContext.Current.Request.UserHostAddress;
}
if(result=="::1")
result=string.Empty;
returnresult;
}

6.AES对称加密

///<summary>
///对称加密类
///</summary>
publicclassAES
{
///<summary>
///解密
///</summary>
///<paramname="strDecrypt"></param>
///<paramname="strKey"></param>
///<returns></returns>
publicstaticstringDecrypt(stringstrDecrypt,stringstrKey)
{
try
{
byte[]bytes=Encoding.UTF8.GetBytes(FormsAuthentication.HashPasswordForStoringInConfigFile(strKey,"md5"));
byte[]inputBuffer=Convert.FromBase64String(strDecrypt);
byte[]buffer3=null;
using(RijndaelManagedmanaged=newRijndaelManaged())
{
managed.Key=bytes;
managed.Mode=CipherMode.ECB;
managed.Padding=PaddingMode.PKCS7;
buffer3=managed.CreateDecryptor().TransformFinalBlock(inputBuffer,0,inputBuffer.Length);
}
returnEncoding.UTF8.GetString(buffer3);
}
catch
{
returnnull;
}
}

///<summary>
///解密
///</summary>
///<paramname="strDecrypt"></param>
///<paramname="strKey"></param>
///<returns></returns>
publicstaticstringDecrypt(stringtoDecrypt,stringkey,stringiv)
{
byte[]bytes=Encoding.UTF8.GetBytes(key);
byte[]buffer2=Encoding.UTF8.GetBytes(iv);
byte[]inputBuffer=Convert.FromBase64String(toDecrypt);
RijndaelManagedmanaged=newRijndaelManaged
{
Key=bytes,
IV=buffer2,
Mode=CipherMode.CBC,
Padding=PaddingMode.Zeros
};
byte[]buffer4=managed.CreateDecryptor().TransformFinalBlock(inputBuffer,0,inputBuffer.Length);
returnEncoding.UTF8.GetString(buffer4);
}

publicstaticstringDecryptStr(stringEncryptString)
{
stringstr="";
if(!string.IsNullOrEmpty(EncryptString))
{
stringsSource=Decrypt(EncryptString,"cn.solefu");
if(Utility.Left(sSource,3)=="gk_")
{
str=sSource.Substring(3);
}
}
returnstr;
}

publicstaticstringDecryptStrByCBC(stringEncryptString)
{
stringstr="";
if(!string.IsNullOrEmpty(EncryptString))
{
stringsSource=Decrypt(EncryptString,"cn.solefu","cn.solefu");
if(Utility.Left(sSource,3)=="gk_")
{
str=sSource.Substring(3);
}
}
returnstr;
}

///<summary>
///加密
///</summary>
///<paramname="strEncrypt"></param>
///<paramname="strKey"></param>
///<returns></returns>
publicstaticstringEncrypt(stringstrEncrypt,stringstrKey)
{
try
{
byte[]bytes=Encoding.UTF8.GetBytes(FormsAuthentication.HashPasswordForStoringInConfigFile(strKey,"md5"));
byte[]inputBuffer=Encoding.UTF8.GetBytes(strEncrypt);
byte[]inArray=null;
using(RijndaelManagedmanaged=newRijndaelManaged())
{
managed.Key=bytes;
managed.Mode=CipherMode.ECB;
managed.Padding=PaddingMode.PKCS7;
inArray=managed.CreateEncryptor().TransformFinalBlock(inputBuffer,0,inputBuffer.Length);
}
returnConvert.ToBase64String(inArray,0,inArray.Length);
}
catch
{
returnnull;
}
}

///<summary>
///加密
///</summary>
///<paramname="strEncrypt"></param>
///<paramname="strKey"></param>
///<returns></returns>
publicstaticstringEncrypt(stringtoEncrypt,stringkey,stringiv)
{
byte[]bytes=Encoding.UTF8.GetBytes(key);
byte[]buffer2=Encoding.UTF8.GetBytes(iv);
byte[]inputBuffer=Encoding.UTF8.GetBytes(toEncrypt);
RijndaelManagedmanaged=newRijndaelManaged
{
Key=bytes,
IV=buffer2,
Mode=CipherMode.CBC,
Padding=PaddingMode.Zeros
};
byte[]inArray=managed.CreateEncryptor().TransformFinalBlock(inputBuffer,0,inputBuffer.Length);
returnConvert.ToBase64String(inArray,0,inArray.Length);
}

publicstaticstringEncryptStr(stringSourceString)
{
returnEncrypt("gk_"+SourceString,"cn.solefu");
}

publicstaticstringEncryptStr(stringSourceString,boolUseInUrl)
{
returnHttpUtility.UrlEncode(EncryptStr(SourceString));
}

publicstaticstringEncryptStrByCBC(stringSourceString)
{
returnEncrypt("gk_"+SourceString,"cn.solefu","cn.solefu");
}

publicstaticstringEncryptStrByCBC(stringSourceString,boolUseInUrl)
{
returnHttpUtility.UrlEncode(EncryptStrByCBC(SourceString));
}
}

7.Cookies帮助类

publicclassCookiesHelper
{
publicstaticvoidAddCookie(stringcookieName,DateTimeexpires)
{
HttpCookiecookie=newHttpCookie(cookieName)
{
Expires=expires
};
AddCookie(cookie,null);
}

publicstaticvoidAddCookie(stringkey,stringvalue)
{
AddCookie(newHttpCookie(key,value),null);
}

publicstaticvoidAddCookie(HttpCookiecookie,stringDomain)
{
HttpResponseresponse=HttpContext.Current.Response;
if(response!=null)
{
cookie.HttpOnly=true;
cookie.Path="/";
if(!string.IsNullOrEmpty(Domain))
{
cookie.Domain=Domain;
}
response.AppendCookie(cookie);
}
}

publicstaticvoidAddCookie(stringcookieName,DateTimeexpires,stringDomain)
{
HttpCookiecookie=newHttpCookie(cookieName)
{
Expires=expires
};
AddCookie(cookie,Domain);
}

publicstaticvoidAddCookie(stringkey,stringvalue,DateTimeexpires)
{
HttpCookiecookie=newHttpCookie(key,value)
{
Expires=expires
};
AddCookie(cookie,null);
}

publicstaticvoidAddCookie(stringcookieName,stringkey,stringvalue)
{
HttpCookiecookie=newHttpCookie(cookieName);
cookie.Values.Add(key,value);
AddCookie(cookie,null);
}

publicstaticvoidAddCookie(stringkey,stringvalue,boolwithDomain,stringDomain)
{
if(withDomain)
{
AddCookie(newHttpCookie(key,value),Domain);
}
else
{
AddCookie(newHttpCookie(key,value),null);
}
}

publicstaticvoidAddCookie(stringkey,stringvalue,DateTimeexpires,stringDomain)
{
HttpCookiecookie=newHttpCookie(key,value)
{
Expires=expires
};
AddCookie(cookie,Domain);
}

publicstaticvoidAddCookie(stringcookieName,stringkey,stringvalue,DateTimeexpires)
{
HttpCookiecookie=newHttpCookie(cookieName)
{
Expires=expires
};
cookie.Values.Add(key,value);
AddCookie(cookie,null);
}

publicstaticvoidAddCookie(stringcookieName,stringkey,stringvalue,stringDomain)
{
HttpCookiecookie=newHttpCookie(cookieName);
cookie.Values.Add(key,value);
AddCookie(cookie,Domain);
}

publicstaticvoidAddCookie(stringcookieName,stringkey,stringvalue,DateTimeexpires,stringDomain)
{
HttpCookiecookie=newHttpCookie(cookieName)
{
Expires=expires
};
cookie.Values.Add(key,value);
AddCookie(cookie,Domain);
}

publicstaticvoidAddDomainCookie(stringkey,stringvalue,stringDomain)
{
AddCookie(newHttpCookie(key,value),Domain);
}

publicstaticHttpCookieGetCookie(stringcookieName)
{
HttpRequestrequest=HttpContext.Current.Request;
if(request!=null)
{
if(request.Cookies[cookieName]!=null)
{
returnrequest.Cookies[cookieName];
}
if(request.Cookies[","+cookieName]!=null)
{
returnrequest.Cookies[","+cookieName];
}
}
returnnull;
}

publicstaticstringGetCookieValue(stringcookieName)
{
returnGetCookieValue(cookieName,null);
}

publicstaticstringGetCookieValue(stringcookieName,stringkey)
{
HttpRequestrequest=HttpContext.Current.Request;
if(request==null)
{
return"";
}
if(request.Cookies[cookieName]!=null)
{
if(!string.IsNullOrEmpty(key)&&request.Cookies[cookieName].HasKeys)
{
returnrequest.Cookies[cookieName].Values[key];
}
returnrequest.Cookies[cookieName].Value;
}
stringstr=","+cookieName;
if(request.Cookies[str]==null)
{
return"";
}
if(!string.IsNullOrEmpty(key)&&request.Cookies[str].HasKeys)
{
returnrequest.Cookies[str].Values[key];
}
returnrequest.Cookies[str].Value;
}

publicstaticstringGetCookieValue(HttpCookiecookie,stringkey)
{
if(cookie==null)
{
return"";
}
if(!string.IsNullOrEmpty(key)&&cookie.HasKeys)
{
returncookie.Values[key];
}
returncookie.Value;
}

publicstaticvoidRemoveCookie(stringcookieName)
{
RemoveCookie(cookieName,null);
}

publicstaticvoidRemoveCookie(stringcookieName,stringkey)
{
HttpResponseresponse=HttpContext.Current.Response;
if(response!=null)
{
HttpCookiecookie=response.Cookies[cookieName];
if(cookie!=null)
{
if(!string.IsNullOrEmpty(key)&&cookie.HasKeys)
{
cookie.Values.Remove(key);
}
else
{
response.Cookies.Remove(cookieName);
}
}
}
}

publicstaticvoidSetCookie(stringcookieName,DateTimeexpires)
{
SetCookie(cookieName,null,null,newDateTime?(expires),null);
}

publicstaticvoidSetCookie(stringkey,stringvalue)
{
SetCookie(key,null,value,null,null);
}

publicstaticvoidSetCookie(stringcookieName,DateTimeexpires,stringDomain)
{
SetCookie(cookieName,null,null,newDateTime?(expires),Domain);
}

publicstaticvoidSetCookie(stringkey,stringvalue,DateTimeexpires)
{
SetCookie(key,null,value,newDateTime?(expires),null);
}

publicstaticvoidSetCookie(stringcookieName,stringkey,stringvalue)
{
SetCookie(cookieName,key,value,null,null);
}

publicstaticvoidSetCookie(stringkey,stringvalue,boolwithDomain,stringDomain)
{
if(withDomain)
{
SetCookie(key,null,value,null,Domain);
}
else
{
SetCookie(key,null,value,null,null);
}
}

publicstaticvoidSetCookie(stringkey,stringvalue,DateTimeexpires,stringDomain)
{
SetCookie(key,null,value,newDateTime?(expires),Domain);
}

publicstaticvoidSetCookie(stringcookieName,stringkey,stringvalue,stringDomain)
{
SetCookie(cookieName,key,value,null,Domain);
}

publicstaticvoidSetCookie(stringcookieName,stringkey,stringvalue,DateTime?expires,stringDomain)
{
HttpResponseresponse=HttpContext.Current.Response;
if(response!=null)
{
HttpCookiecookie=response.Cookies[cookieName];
if(cookie!=null)
{
cookie.Path="/";
if(!string.IsNullOrEmpty(Domain))
{
cookie.Domain=Domain;
}
if(!string.IsNullOrEmpty(key)&&cookie.HasKeys)
{
cookie.Values.Set(key,value);
}
elseif(!string.IsNullOrEmpty(value))
{
cookie.Value=value;
}
if(expires.HasValue)
{
cookie.Expires=expires.Value;
}
response.SetCookie(cookie);
}
}
}
///<summary>
///设置域的cookie
///</summary>
///<paramname="key"></param>
///<paramname="value"></param>
///<paramname="Domain"></param>
publicstaticvoidSetDomainCookie(stringkey,stringvalue,stringDomain)
{
SetCookie(key,null,value,null,Domain);
}
}

8.DataTable转换成实体类

///<summary>
///#regionDataTable转换成实体类
///</summary>
///<typeparamname="T"></typeparam>
publicclassModelUtil<T>whereT:new()
{

///<summary>
///填充对象列表：用DataSet的第一个表填充实体类
///</summary>
///<paramname="ds">DataSet</param>
///<returns></returns>
publicstaticList<T>FillModel(DataSetds)
{
if(ds==null||ds.Tables[0]==null||ds.Tables[0].Rows.Count==0)
{
returnnull;
}
else
{
returnFillModel(ds.Tables[0]);
}
}

///<summary>
///填充对象列表：用DataSet的第index个表填充实体类
///</summary>
publicstaticList<T>FillModel(DataSetds,intindex)
{
if(ds==null||ds.Tables.Count<=index||ds.Tables[index].Rows.Count==0)
{
returnnull;
}
else
{
returnFillModel(ds.Tables[index]);
}
}

///<summary>
///填充对象列表：用DataTable填充实体类
///</summary>
publicstaticList<T>FillModel(DataTabledt)
{
if(dt==null||dt.Rows.Count==0)
{
returnnull;
}
List<T>modelList=newList<T>();
foreach(DataRowdrindt.Rows)
{
//Tmodel=(T)Activator.CreateInstance(typeof(T));
Tmodel=newT();
for(inti=0;i<dr.Table.Columns.Count;i++)
{
List<PropertyInfo>propertyInfos=model.GetType().GetProperties().ToList();

PropertyInfoitem=propertyInfos.FirstOrDefault(p=>string.Compare(p.Name,dr.Table.Columns[i].ColumnName,true)==0);
if(item!=null&&dr[i]!=DBNull.Value)
try
{
item.SetValue(model,dr[i],null);
}
catch
{
}
}

modelList.Add(model);
}
returnmodelList;
}

///<summary>
///填充对象：用DataRow填充实体类
///</summary>
publicstaticTFillModel(DataRowdr)
{
if(dr==null)
{
returndefault(T);
}

//Tmodel=(T)Activator.CreateInstance(typeof(T));
Tmodel=newT();

for(inti=0;i<dr.Table.Columns.Count;i++)
{
List<PropertyInfo>propertyInfos=model.GetType().GetProperties().ToList();

PropertyInfoitem=propertyInfos.FirstOrDefault(p=>string.Compare(p.Name,dr.Table.Columns[i].ColumnName,true)==0);
if(item!=null&&dr[i]!=DBNull.Value)
try
{
item.SetValue(model,dr[i],null);
}
catch
{
}
}
returnmodel;
}


///<summary>
///实体类转换成DataSet
///</summary>
///<paramname="modelList">实体类列表</param>
///<returns></returns>
publicstaticDataSetFillDataSet(List<T>modelList)
{
if(modelList==null||modelList.Count==0)
{
returnnull;
}
else
{
DataSetds=newDataSet();
ds.Tables.Add(FillDataTable(modelList));
returnds;
}
}

///<summary>
///实体类转换成DataTable
///</summary>
///<paramname="modelList">实体类列表</param>
///<returns></returns>
publicstaticDataTableFillDataTable(List<T>modelList)
{
if(modelList==null||modelList.Count==0)
{
returnnull;
}
DataTabledt=CreateData(modelList[0]);

foreach(TmodelinmodelList)
{
DataRowdataRow=dt.NewRow();
foreach(PropertyInfopropertyInfointypeof(T).GetProperties())
{
dataRow[propertyInfo.Name]=propertyInfo.GetValue(model,null);
}
dt.Rows.Add(dataRow);
}
returndt;
}

///<summary>
///根据实体类得到表结构
///</summary>
///<paramname="model">实体类</param>
///<returns></returns>
privatestaticDataTableCreateData(Tmodel)
{
DataTabledataTable=newDataTable(typeof(T).Name);
foreach(PropertyInfopropertyInfointypeof(T).GetProperties())
{
dataTable.Columns.Add(newDataColumn(propertyInfo.Name,propertyInfo.PropertyType));
}
returndataTable;
}

///<summary>
///将DataTable以转为List与Dictionary嵌套集合保存
///</summary>
///<paramname="dt"></param>
///<returns></returns>
publicstaticList<Dictionary<string,string>>ToListDictionary(DataTabledt)
{
List<Dictionary<string,string>>list=null;
if(dt!=null&&dt.Rows.Count>0)
{
list=newList<Dictionary<string,string>>();
Dictionary<string,string>dic=null;
foreach(DataRowdrindt.Rows)
{
dic=newDictionary<string,string>();
foreach(DataColumndcindt.Columns)
{
dic.Add(dc.ColumnName,dr[dc.ColumnName].ToString());
}
list.Add(dic);
}
}
returnlist;
}

///<summary>
///请求的request的内容转换为model
///cza
///2016-5-3019:06:21
///</summary>
///<paramname="context"></param>
///<returns></returns>
publicstaticTConvertToModel(HttpContextcontext)
{
Tt=newT();
PropertyInfo[]propertys=t.GetType().GetProperties();
foreach(PropertyInfopiinpropertys)
{
if(!pi.CanWrite)
continue;
objectvalue=context.Request[pi.Name];
if(value!=null&&value!=DBNull.Value)
{
try
{
if(value.ToString()!="")
pi.SetValue(t,Convert.ChangeType(value,pi.PropertyType),null);//这一步很重要，用于类型转换
else
pi.SetValue(t,value,null);
}
catch
{}
}
}

returnt;
}


}

9.SQLServer数据库访问类

///<summary>
///SQLServer数据库访问类
///</summary>
publicabstractclassSqlHelper
{
//读取配置文件里的数据库连接字符串
publicstaticreadonlystringconnStr=ConfigurationManager.ConnectionStrings["Conn"].ConnectionString;

//空构造
publicSqlHelper(){}

//Hashtabletostorecachedparameters
privatestaticHashtableparmCache=Hashtable.Synchronized(newHashtable());

///<summary>
///执行增删改【常用】
///</summary>
publicstaticintExecuteNonQuery(stringconnectionString,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();
using(SqlConnectionconn=newSqlConnection(connectionString))
{
PrepareCommand(cmd,conn,null,commandType,commandText,paras);
intval=cmd.ExecuteNonQuery();
cmd.Parameters.Clear();//清空参数
returnval;
}
}

///<summary>
///执行增删改（对现有的数据库连接）【不常用】
///</summary>
publicstaticintExecuteNonQuery(SqlConnectionconnection,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();
PrepareCommand(cmd,connection,null,commandType,commandText,paras);
intval=cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
returnval;
}

///<summary>
///执行多条sql语句（List泛型集合）【事务】（无参数）
///</summary>
///<paramname="connectionString">数据库连接字符串</param>
///<paramname="listSql">包含多条sql语句的泛型集合</param>
///<returns>受影响行数</returns>
publicstaticintExecuteNonQuery(stringconnectionString,List<string>listSql)
{
SqlCommandcmd=newSqlCommand();
SqlConnectionconn=newSqlConnection(connectionString);
conn.Open();
SqlTransactiontrans=conn.BeginTransaction();
PrepareCommand(cmd,conn,trans,CommandType.Text,null,null);
try
{
intcount=0;
for(intn=0;n<listSql.Count;n++)
{
stringstrSql=listSql[n];
if(strSql.Trim().Length>1)
{
cmd.CommandText=strSql;
count+=cmd.ExecuteNonQuery();
}
}
trans.Commit();
cmd.Parameters.Clear();
returncount;
}
catch
{
trans.Rollback();
cmd.Parameters.Clear();
return0;
}
finally
{
conn.Close();
}
}

///<summary>
///执行多条sql语句（Hashtable）【事务】（带一组参数，一个参数也得封装成组)
///</summary>
///<paramname="connectionString">数据库连接字符串</param>
///<paramname="sqlStringList">Hashtable表，键值对形式</param>
publicstaticvoidExecuteNonQuery(stringconnectionString,HashtablesqlStringList)
{
using(SqlConnectionconn=newSqlConnection(connectionString))
{
conn.Open();
using(SqlTransactiontrans=conn.BeginTransaction())
{
SqlCommandcmd=newSqlCommand();
try
{
foreach(DictionaryEntryiteminsqlStringList)
{
stringcmdText=item.Key.ToString();//要执行的sql语句
SqlParameter[]cmdParas=(SqlParameter[])item.Value;//sql语句对应的参数
PrepareCommand(cmd,conn,trans,CommandType.Text,cmdText,cmdParas);
intval=cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
if(sqlStringList.Count>0)
trans.Commit();
}
catch
{
trans.Rollback();
throw;
}
}
}

}

///<summary>
///返回DataReader对象
///</summary>
publicstaticSqlDataReaderExecuteReader(stringconnectionString,CommandTypecommandType,stringcmdText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();
SqlConnectionconn=newSqlConnection(connectionString);
try
{
PrepareCommand(cmd,conn,null,commandType,cmdText,paras);
SqlDataReaderreader=cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
returnreader;
}
catch
{
conn.Close();
throw;
}
}

///<summary>
///返回第一行第一列信息（可能是字符串所以返回类型是object）【常用】
///</summary>
publicstaticobjectExecuteScalar(stringconnectionString,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();
using(SqlConnectionconnection=newSqlConnection(connectionString))
{
PrepareCommand(cmd,connection,null,commandType,commandText,paras);
objectval=cmd.ExecuteScalar();
cmd.Parameters.Clear();
returnval;
}
}

///<summary>
///返回第一行第一列信息（针对现有的数据库连接）【不常用】
///</summary>
publicstaticobjectExecuteScalar(SqlConnectionconnection,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();

PrepareCommand(cmd,connection,null,commandType,commandText,paras);
objectval=cmd.ExecuteScalar();
cmd.Parameters.Clear();
returnval;
}

///<summary>
///返回DataTable
///</summary>
publicstaticDataTableGetDataTable(stringconnectionString,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();
using(SqlConnectionconn=newSqlConnection(connectionString))
{
PrepareCommand(cmd,conn,null,commandType,commandText,paras);
using(SqlDataAdapterda=newSqlDataAdapter(cmd))
{
DataTabledt=newDataTable();
da.Fill(dt);
returndt;
}
}
}

///<summary>
///返回DataSet
///</summary>
publicstaticDataSetGetDataset(stringconnectionString,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
SqlCommandcmd=newSqlCommand();
using(SqlConnectionconn=newSqlConnection(connectionString))
{
PrepareCommand(cmd,conn,null,commandType,commandText,paras);
using(SqlDataAdapterda=newSqlDataAdapter(cmd))
{
DataSetds=newDataSet();
da.Fill(ds);
returnds;
}
}
}

///<summary>
///addparameterarraytothecache
///</summary>
///<paramname="cacheKey">Keytotheparametercache</param>
///<paramname="cmdParms">anarrayofSqlParamterstobecached</param>
publicstaticvoidCacheParameters(stringcacheKey,paramsSqlParameter[]commandParameters)
{
parmCache[cacheKey]=commandParameters;
}

///<summary>
///Retrievecachedparameters
///</summary>
///<paramname="cacheKey">keyusedtolookupparameters</param>
///<returns>CachedSqlParamtersarray</returns>
publicstaticSqlParameter[]GetCachedParameters(stringcacheKey)
{
SqlParameter[]cachedParms=(SqlParameter[])parmCache[cacheKey];

if(cachedParms==null)
returnnull;

SqlParameter[]clonedParms=newSqlParameter[cachedParms.Length];

for(inti=0,j=cachedParms.Length;i<j;i++)
clonedParms[i]=(SqlParameter)((ICloneable)cachedParms[i]).Clone();

returnclonedParms;
}

///<summary>
///准备一个待执行的SqlCommand
///</summary>
privatestaticvoidPrepareCommand(SqlCommandcmd,SqlConnectionconn,SqlTransactiontrans,CommandTypecommandType,stringcommandText,paramsSqlParameter[]paras)
{
try
{
if(conn.State!=ConnectionState.Open)
{
conn.Close();
conn.Open();
}
cmd.Connection=conn;
if(commandText!=null)
cmd.CommandText=commandText;
cmd.CommandType=commandType;//这里设置执行的是T-Sql语句还是存储过程

if(trans!=null)
cmd.Transaction=trans;

if(paras!=null&&paras.Length>0)
{
//cmd.Parameters.AddRange(paras);
for(inti=0;i<paras.Length;i++)
{
if(paras[i].Value==null||paras[i].Value.ToString()=="")
paras[i].Value=DBNull.Value;//插入或修改时，如果有参数是空字符串，那么以NULL的形式插入数据库
cmd.Parameters.Add(paras[i]);
}
}
}
catch(Exceptionex)
{
thrownewException(ex.Message);
}
}

///<summary>
///通用分页存储过程，有条件查询，有排序字段，按照排序字段的降序排列
///</summary>
///<paramname="PageSize">每页记录数</param>
///<paramname="CurrentCount">当前记录数量（页码*每页记录数）</param>
///<paramname="TableName">表名称</param>
///<paramname="Where">查询条件，例："ID>1000ANDNamelike'%LiLinFeng%'"排序条件，直接在后面加，例："ORDERBYIDDESC,NAMEASC"</param>
///<paramname="TotalCount">记录总数</param>
///<returns></returns>
publicstaticDataSetGetList(stringconnectionString,stringOrder,intPageSize,intCurrentCount,stringTableName,stringWhere,outintTotalCount)
{
SqlParameter[]parmList=
{
newSqlParameter("@PageSize",PageSize),
newSqlParameter("@CurrentCount",CurrentCount),
newSqlParameter("@TableName",TableName),
newSqlParameter("@Where",Where),
newSqlParameter("@Order",Order),
newSqlParameter("@TotalCount",SqlDbType.Int,4)
};
parmList[5].Direction=ParameterDirection.Output;
DataSetds=GetDataset(connectionString,CommandType.StoredProcedure,"sp_MvcPager",parmList);
TotalCount=Convert.ToInt32(parmList[5].Value);
returnds;
}
}

10.日志文件记录

publicclassWriteLog
{
///<summary>
///
///</summary>
///<paramname="fileName">文件名</param>
///<paramname="ex"></param>
publicstaticvoidWriteErorrLog(stringfileName,Exceptionex)
{
if(ex==null)return;//ex=null返回
DateTimedt=DateTime.Now;//设置日志时间
stringtime=dt.ToString("yyyy-MM-ddHH:mm:ss");//年-月-日时：分：秒
stringlogName=dt.ToString("yyyy-MM-dd");//日志名称
stringlogPath=Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory,Path.Combine("log",fileName));//日志存放路径
stringlog=Path.Combine(logPath,string.Format("{0}.log",logName));//路径+名称
try
{
FileInfoinfo=newFileInfo(log);
if(info.Directory!=null&&!info.Directory.Exists)
{
info.Directory.Create();
}
using(StreamWriterwrite=newStreamWriter(log,true,Encoding.GetEncoding("utf-8")))
{
write.WriteLine(time);
write.WriteLine(ex.Message);
write.WriteLine("异常信息："+ex);
write.WriteLine("异常堆栈："+ex.StackTrace);
write.WriteLine("异常简述："+ex.Message);
write.WriteLine("\r\n----------------------------------\r\n");
write.Flush();
write.Close();
write.Dispose();
}
}
catch{}
}

///<summary>
///
///</summary>
///<paramname="fileName">文件名</param>
///<paramname="message"></param>
publicstaticvoidWriteMessage(stringfileName,stringmessage)
{
//ex=null返回
DateTimedt=DateTime.Now;//设置日志时间
stringtime=dt.ToString("yyyy-MM-ddHH:mm:ss");//年-月-日时：分：秒
stringlogName=dt.ToString("yyyy-MM-dd");//日志名称
stringlogPath=Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory,Path.Combine("log",fileName));//日志存放路径
stringlog=Path.Combine(logPath,string.Format("{0}.log",logName));//路径+名称
try
{
FileInfoinfo=newFileInfo(log);
if(info.Directory!=null&&!info.Directory.Exists)
{
info.Directory.Create();
}
using(StreamWriterwrite=newStreamWriter(log,true,Encoding.GetEncoding("utf-8")))
{
write.WriteLine(time);
write.WriteLine("信息："+message);
write.WriteLine("\r\n----------------------------------\r\n");
write.Flush();
write.Close();
write.Dispose();
}
}
catch{}
}


publicstaticvoidWriteErorrLog(Exceptionex,stringmessage)
{
if(ex==null)return;//ex=null返回
DateTimedt=DateTime.Now;//设置日志时间
stringtime=dt.ToString("yyyy-MM-ddHH:mm:ss");//年-月-日时：分：秒
stringlogName=dt.ToString("yyyy-MM-dd");//日志名称
stringlogPath=System.AppDomain.CurrentDomain.BaseDirectory;//日志存放路径
stringlog=Path.Combine(Path.Combine(logPath,"log"),string.Format("{0}.log",logName));//路径+名称
try
{
FileInfoinfo=newFileInfo(log);
if(info.Directory!=null&&!info.Directory.Exists)
{
info.Directory.Create();
}
using(StreamWriterwrite=newStreamWriter(log,true,Encoding.GetEncoding("utf-8")))
{
write.WriteLine(time);
write.WriteLine(ex.Message);
write.WriteLine("异常信息："+ex);
write.WriteLine("异常堆栈："+ex.StackTrace);
write.WriteLine("异常简述："+message);
write.WriteLine("\r\n----------------------------------\r\n");
write.Flush();
write.Close();
write.Dispose();
}
}
catch{}
}

publicstaticvoidWriteMessage(stringmessage)
{
//ex=null返回
DateTimedt=DateTime.Now;//设置日志时间
stringtime=dt.ToString("yyyy-MM-ddHH:mm:ss");//年-月-日时：分：秒
stringlogName=dt.ToString("yyyy-MM-dd");//日志名称
stringlogPath=System.AppDomain.CurrentDomain.BaseDirectory;//日志存放路径
stringlog=Path.Combine(Path.Combine(logPath,"log"),string.Format("{0}.log",logName));//路径+名称
try
{
FileInfoinfo=newFileInfo(log);
if(info.Directory!=null&&!info.Directory.Exists)
{
info.Directory.Create();
}
using(StreamWriterwrite=newStreamWriter(log,true,Encoding.GetEncoding("utf-8")))
{
write.WriteLine(time);
write.WriteLine("信息："+message);
write.WriteLine("\r\n----------------------------------\r\n");
write.Flush();
write.Close();
write.Dispose();
}
}
catch{}
}
}

11.JSON帮助类

///<summary>
///JSON帮助类
///</summary>
publicclassJsonHelper
{
#region通用方法
///<summary>
///格式化字符型、日期型、布尔型
///</summary>
publicstaticstringStringFormat(stringstr,Typetype)
{
if(type==typeof(string))
{
str=StringFilter(str);
str="\""+str+"\"";
}
elseif(type==typeof(DateTime)||type==typeof(DateTime?))
{
str="\""+str+"\"";
}
elseif(type==typeof(bool))
{
str=str.ToLower();
}
elseif(type==typeof(Guid))
{
str="\""+str+"\"";
}
elseif(type!=typeof(string)&&string.IsNullOrEmpty(str))
{
str="\""+str+"\"";
}
returnstr;
}

///<summary>
///过滤字符串
///</summary>
publicstaticstringStringFilter(stringstr)
{
StringBuildersb=newStringBuilder();
for(inti=0;i<str.Length;i++)
{
charc=str.ToCharArray()[i];
switch(c)
{
case'\"':
sb.Append("\\\"");break;
case'\\':
sb.Append("\\\\");break;
case'/':
sb.Append("\\/");break;
case'\b':
sb.Append("\\b");break;
case'\f':
sb.Append("\\f");break;
case'\n':
sb.Append("\\n");break;
case'\r':
sb.Append("\\r");break;
case'\t':
sb.Append("\\t");break;
default:
sb.Append(c);break;
}
}
returnsb.ToString();
}
#endregion

#region列转json
///<summary>
///列转json
///</summary>
///<paramname="dt">表</param>
///<paramname="r">列</param>
publicstaticstringColumnToJson(DataTabledt,intr)
{
StringBuilderstrSql=newStringBuilder();
for(inti=0;i<dt.Rows.Count;i++)
{
strSql.Append(dt.Rows[i][r]);
strSql.Append(",");
}
returnstrSql.ToString().Trim(',');
}
#endregion

#region对象转json
///<summary>
///对象转json
///</summary>
publicstaticstringToJson(objectjsonObject)
{
StringBuildersb=newStringBuilder();
sb.Append("{");
PropertyInfo[]propertyInfo=jsonObject.GetType().GetProperties();
for(inti=0;i<propertyInfo.Length;i++)
{
objectobjectValue=propertyInfo[i].GetGetMethod().Invoke(jsonObject,null);
Typetype=propertyInfo[i].PropertyType;
stringstrValue=objectValue.ToString();
strValue=StringFormat(strValue,type);
sb.Append("\""+propertyInfo[i].Name+"\":");
sb.Append(strValue+",");
}
sb.Remove(sb.Length-1,1);
sb.Append("}");
returnsb.ToString();
}
#endregion

#regionlist转json
///<summary>
///list转json
///</summary>
publicstaticstringListToJson<T>(IList<T>list)
{
objectobj=list[0];
returnListToJson<T>(list,obj.GetType().Name);
}

privatestaticstringListToJson<T>(IList<T>list,stringJsonName)
{
StringBuilderJson=newStringBuilder();
if(string.IsNullOrEmpty(JsonName))
JsonName=list[0].GetType().Name;
Json.Append("{\""+JsonName+"\":[");
if(list.Count>0)
{
for(inti=0;i<list.Count;i++)
{
Tobj=Activator.CreateInstance<T>();
PropertyInfo[]pi=obj.GetType().GetProperties();
Json.Append("{");
for(intj=0;j<pi.Length;j++)
{
Typetype=pi[j].GetValue(list[i],null).GetType();
Json.Append("\""+pi[j].Name.ToString()+"\":"+StringFormat(pi[j].GetValue(list[i],null).ToString(),type));
if(j<pi.Length-1)
{
Json.Append(",");
}
}
Json.Append("}");
if(i<list.Count-1)
{
Json.Append(",");
}
}
}
Json.Append("]}");
returnJson.ToString();
}
#endregion

#region对象集合转换为json
///<summary>
///对象集合转换为json
///</summary>
///<paramname="array">对象集合</param>
///<returns>json字符串</returns>
publicstaticstringToJson(IEnumerablearray)
{
stringjsonString="[";
foreach(objectiteminarray)
{
jsonString+=ToJson(item)+",";
}
jsonString=jsonString.Substring(0,jsonString.Length-1);
returnjsonString+"]";
}
#endregion

#region普通集合转换Json
///<summary>
///普通集合转换Json
///</summary>
///<paramname="array">集合对象</param>
///<returns>Json字符串</returns>
publicstaticstringToArrayString(IEnumerablearray)
{
stringjsonString="[";
foreach(objectiteminarray)
{
jsonString=ToJson(item.ToString())+",";
}
jsonString.Remove(jsonString.Length-1,jsonString.Length);
returnjsonString+"]";
}
#endregion

#regionDataSet转换为Json
///<summary>
///DataSet转换为Json
///</summary>
///<paramname="dataSet">DataSet对象</param>
///<returns>Json字符串</returns>
publicstaticstringToJson(DataSetdataSet)
{
stringjsonString="{";
foreach(DataTabletableindataSet.Tables)
{
jsonString+="\""+table.TableName+"\":"+ToJson(table)+",";
}
jsonString=jsonString.TrimEnd(',');
returnjsonString+"}";
}
#endregion

#regionDatatable转换为Json
///<summary>
///Datatable转换为Json
///</summary>
publicstaticstringToJson(DataTabledt)
{
if(dt.Rows.Count>0)
{
StringBuilderjsonString=newStringBuilder();
jsonString.Append("[");
DataRowCollectiondrc=dt.Rows;
for(inti=0;i<drc.Count;i++)
{
jsonString.Append("{");
for(intj=0;j<dt.Columns.Count;j++)
{
stringstrKey=dt.Columns[j].ColumnName;
stringstrValue=drc[i][j].ToString();

Typetype=dt.Columns[j].DataType;
jsonString.Append("\""+strKey+"\":");
strValue=StringFormat(strValue,type);
if(j<dt.Columns.Count-1)
jsonString.Append(strValue+",");
else
jsonString.Append(strValue);
}
jsonString.Append("},");
}
jsonString.Remove(jsonString.Length-1,1);
jsonString.Append("]");
returnjsonString.ToString();
}
else
return"[]";
}

///<summary>
///DataTable转换为Json
///</summary>
publicstaticstringToJson(DataTabledt,stringjsonName)
{
StringBuilderJson=newStringBuilder();
if(string.IsNullOrEmpty(jsonName))
jsonName=dt.TableName;
Json.Append("{\""+jsonName+"\":[");
if(dt.Rows.Count>0)
{
for(inti=0;i<dt.Rows.Count;i++)
{
Json.Append("{");
for(intj=0;j<dt.Columns.Count;j++)
{
Typetype=dt.Rows[i][j].GetType();
Json.Append("\""+dt.Columns[j].ColumnName.ToString()+"\":"+StringFormat(dt.Rows[i][j].ToString(),type));
if(j<dt.Columns.Count-1)
Json.Append(",");
}
Json.Append("}");
if(i<dt.Rows.Count-1)
Json.Append(",");
}
}
Json.Append("]}");
returnJson.ToString();
}
#endregion

#regionDataReader转换为Json
///<summary>
///DataReader转换为Json
///</summary>
///<paramname="dataReader">DataReader对象</param>
///<returns>Json字符串</returns>
publicstaticstringToJson(DbDataReaderdataReader)
{
StringBuilderjsonString=newStringBuilder();
jsonString.Append("[");
while(dataReader.Read())
{
jsonString.Append("{");
for(inti=0;i<dataReader.FieldCount;i++)
{
Typetype=dataReader.GetFieldType(i);
stringstrKey=dataReader.GetName(i);
stringstrValue=dataReader[i].ToString();
jsonString.Append("\""+strKey+"\":");
strValue=StringFormat(strValue,type);
if(i<dataReader.FieldCount-1)
jsonString.Append(strValue+",");
else
jsonString.Append(strValue);
}
jsonString.Append("},");
}
dataReader.Close();
jsonString.Remove(jsonString.Length-1,1);
jsonString.Append("]");
returnjsonString.ToString();
}
#endregion


#region返回错误
publicstaticstringerror()
{
DataTabledt=newDataTable();
dt.Columns.Add("error",typeof(int));
DataRowdr=dt.NewRow();
dr["error"]=1;
dt.Rows.Add(dr);
returnToJson(dt);
}
#endregion

}


11.转换帮助类



publicclassConvertHelper
{
publicstaticintDateTimeToUnixInt(DateTimetime)
{
DateTimetime2=TimeZone.CurrentTimeZone.ToLocalTime(newDateTime(0x7b2,1,1));
TimeSpanspan=(TimeSpan)(time-time2);
return(int)span.TotalSeconds;
}

publicstaticdecimalMoneyRound(decimalvalue,intdecimals)
{
if(value<0M)
{
returnMath.Round((decimal)(value+(5M/((decimal)Math.Pow(10.0,(double)(decimals+1))))),decimals,MidpointRounding.AwayFromZero);
}
returnMath.Round(value,decimals,MidpointRounding.AwayFromZero);
}

publicstaticdoubleMoneyRound(doublevalue,intdecimals)
{
if(value<0.0)
{
returnMath.Round((double)(value+(5.0/Math.Pow(10.0,(double)(decimals+1)))),decimals,MidpointRounding.AwayFromZero);
}
returnMath.Round(value,decimals,MidpointRounding.AwayFromZero);
}

publicstaticdecimalMoneyToDecimal(stringstr)
{
try
{
str=str.Replace(",","");
returndecimal.Parse(str);
}
catch
{
return0M;
}
}

publicstaticdecimalRound(decimald,inti)
{
if(d>=0M)
{
d+=5M*((decimal)Math.Pow(10.0,(double)-(i+1)));
}
else
{
d+=-5M*((decimal)Math.Pow(10.0,(double)-(i+1)));
}
stringstr=d.ToString();
string[]strArray=str.Split(newchar[]{'.'});
intindex=str.IndexOf('.');
stringstr2=strArray[0];
stringstr3=strArray[1];
if(str3.Length>i)
{
str3=str.Substring(index+1,i);
}
d=decimal.Parse(str2+"."+str3);
returnd;
}

publicstaticdoubleRound(doubled,inti)
{
if(d>=0.0)
{
d+=5.0*Math.Pow(10.0,(double)-(i+1));
}
else
{
d+=-5.0*Math.Pow(10.0,(double)-(i+1));
}
stringstr=d.ToString();
string[]strArray=str.Split(newchar[]{'.'});
intindex=str.IndexOf('.');
stringstr2=strArray[0];
stringstr3=strArray[1];
if(str3.Length>i)
{
str3=str.Substring(index+1,i);
}
d=double.Parse(str2+"."+str3);
returnd;
}

publicstaticboolToBool(objecto)
{
returnToBool(o,false);
}

publicstaticboolToBool(objecto,boolDefaultValue)
{
boolflag;
if(bool.TryParse(ToString(o,true),outflag))
{
returnflag;
}
returnDefaultValue;
}

publicstaticDateTimeToDateTime(objecto)
{
returnToDateTime(o,DateTime.Now);
}

publicstaticDateTimeToDateTime(objecto,DateTimeDefaultValue)
{
DateTimetime;
if(DateTime.TryParse(ToString(o,true),outtime))
{
returntime;
}
returnDefaultValue;
}

publicstaticdecimalToDecimal(objecto)
{
returnToDecimal(o,0M);
}

publicstaticdecimalToDecimal(objecto,decimalDefaultValue)
{
decimalnum;
if(decimal.TryParse(ToString(o,true),outnum))
{
returnnum;
}
returnDefaultValue;
}

publicstaticdoubleToDouble(objecto)
{
returnToDouble(o,0.0);
}

publicstaticdoubleToDouble(objecto,doubleDefaultValue)
{
doublenum;
if(double.TryParse(ToString(o,true),outnum))
{
returnnum;
}
returnDefaultValue;
}

publicstaticfloatToFloat(objecto)
{
returnToFloat(o,0f);
}

publicstaticfloatToFloat(objecto,floatDefaultValue)
{
floatnum;
if(float.TryParse(ToString(o,true),outnum))
{
returnnum;
}
returnDefaultValue;
}

publicstaticintToInt(objecto)
{
returnToInt(o,0);
}

publicstaticintToInt(objecto,intDefaultValue)
{
intnum;
if(int.TryParse(ToString(o,true),outnum))
{
returnnum;
}
returnDefaultValue;
}

publicstaticlongToLong(objecto)
{
returnToLong(o,0L);
}

publicstaticlongToLong(objecto,longDefaultValue)
{
longnum;
if(long.TryParse(ToString(o,true),outnum))
{
returnnum;
}
returnDefaultValue;
}

publicstaticstringToMoney(objecto)
{
returnToDecimal(o).ToString("###,###,###,###,###,##0.##");
}

publicstaticstringToMoney(stringstr)
{
try
{
returndecimal.Parse(str).ToString("###,###,###,###,###,##0.##");
}
catch
{
return"0";
}
}

publicstaticstringToString(objecto)
{
returnToString(o,"",false);
}

publicstaticstringToString(objecto,boolbTrim)
{
returnToString(o,"",bTrim);
}

publicstaticstringToString(objecto,stringDefaultValue)
{
returnToString(o,DefaultValue,false);
}

publicstaticstringToString(objecto,stringDefaultValue,boolbTrim)
{
if(object.Equals(o,null)||Convert.IsDBNull(o))
{
returnDefaultValue;
}
if(bTrim)
{
returno.ToString().Trim();
}
returno.ToString();
}

publicstaticDateTimeUnixIntToDateTime(stringtimeStamp)
{
DateTimetime=TimeZone.CurrentTimeZone.ToLocalTime(newDateTime(0x7b2,1,1));
longticks=long.Parse(timeStamp+"0000000");
TimeSpanspan=newTimeSpan(ticks);
returntime.Add(span);
}
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

C# 常用公共方法

热门推荐

随机推荐