/// <summary>
/// 调节图片亮度值
/// </summary>
/// <param name="image">需要处理的图片</param>
/// <param name="brightnessValue">亮度值【0~100，其中0表示最暗，100表示最亮】</param>
/// <returns>调节好后的图片</returns>
public static Bitmap AdjustBrightness(this Bitmap image, int brightnessValue)
{
/*
*参考：
* 1. http://www.nullskull.com/faq/528/c-net--change-brightness-of-image--jpg-gif-or-bmp.aspx
* 2. http://blog.csdn.net/jiangxinyu/article/details/6222302
* 3. http://www.smokycogs.com/blog/image-processing-in-c-sharp-adjusting-the-brightness/
*/
ValidateOperator.Begin().InRange(brightnessValue, 0, 100, "图片亮度值");
brightnessValue = 100 - brightnessValue;
Bitmap _tempBitmap = image;
float _finalValue = (float)brightnessValue / 255.0f;
Bitmap _newBitmap = new Bitmap(_tempBitmap.Width, _tempBitmap.Height);
Graphics _newGraphics = Graphics.FromImage(_newBitmap);
float[][] _floatColorMatrix =
{
new float[] { 1, 0, 0, 0, 0 },
new float[] { 0, 1, 0, 0, 0 },
new float[] { 0, 0, 1, 0, 0 },
new float[] { 0, 0, 0, 1, 0 },
new float[] { _finalValue, _finalValue, _finalValue, 1, 1 }
};
ColorMatrix _newColorMatrix = new ColorMatrix(_floatColorMatrix);
ImageAttributes _attributes = new ImageAttributes();
_attributes.SetColorMatrix(_newColorMatrix);
_newGraphics.DrawImage(_tempBitmap, new Rectangle(0, 0, _tempBitmap.Width, _tempBitmap.Height), 0, 0, _tempBitmap.Width, _tempBitmap.Height, GraphicsUnit.Pixel, _attributes);
_attributes.Dispose();
_newGraphics.Dispose();
return(_newBitmap);
}
/// <summary>
/// 检查请求签名合法性
/// </summary>
/// <param name="signature">加密签名字符串</param>
/// <param name="timestamp">时间戳</param>
/// <param name="nonce">随机数</param>
/// <param name="appConfig">应用接入配置信息</param>
/// <returns>CheckResult</returns>
public CheckResult CheckRequestSignature(string signature, string timestamp, string nonce, AppConfig appConfig)
{
ValidateOperator.Begin()
.NotNullOrEmpty(signature, "加密签名字符串")
.NotNullOrEmpty(timestamp, "时间戳")
.NotNullOrEmpty(nonce, "随机数")
.NotNull(appConfig, "AppConfig");
var appSecret = appConfig.AppSecret;
var signatureExpired = appConfig.SignatureExpiredMinutes;
string[] data = { appSecret, timestamp, nonce };
Array.Sort(data);
var signatureText = string.Join("", data);
signatureText = Md5Encryptor.Encrypt(signatureText);
if (!signature.CompareIgnoreCase(signatureText) && CheckHelper.IsNumber(timestamp))
{
return(CheckResult.Success());
}
var timestampMillis =
UnixEpochHelper.DateTimeFromUnixTimestampMillis(timestamp.ToDoubleOrDefault());
var minutes = DateTime.UtcNow.Subtract(timestampMillis).TotalMinutes;
return(minutes > signatureExpired?CheckResult.Fail("签名时间戳失效") : CheckResult.Success());
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="cacheMinutes">请求缓存时间分钟</param>
/// <param name="dependsOnIdentity">缓存取决于访问令牌</param>
/// <param name="cacheProvider">ICacheProvider</param>
protected ControllerCacheAttribute(int cacheMinutes, bool dependsOnIdentity, ICacheProvider cacheProvider)
{
ValidateOperator.Begin().NotNull(cacheProvider, "ICacheProvider");
DependsOnIdentity = dependsOnIdentity;
CacheProvider = cacheProvider;
CacheMinutes = cacheMinutes;
}
/// <summary>
/// 将InnerException.Data转换为Xml字符串
/// <para>不支持Data中Value是集合数组形式存储</para>
/// </summary>
/// <param name="frameworkException">FrameworkException</param>
/// <returns>Xml字符串</returns>
/// 时间：2016-02-26 13:19
/// 备注：
public static string ParseInnerDataToXmlString(this FrameworkException frameworkException)
{
ValidateOperator.Begin().NotNull(frameworkException, "FrameworkException");
string _xmlString = string.Empty;
if (frameworkException.InnerException != null)
{
if (frameworkException.InnerException.Data != null)
{
SerializableDictionary <string, string> _seriableDic = new SerializableDictionary <string, string>();
foreach (DictionaryEntry data in frameworkException.InnerException.Data)
{
_seriableDic.Add(data.Key.ToStringOrDefault(string.Empty), data.Value.ToStringOrDefault(string.Empty));
}
using (StringWriter sw = new StringWriter())
{
using (XmlTextWriter writer = new XmlTextWriter(sw))
{
writer.Formatting = Formatting.Indented;
_seriableDic.WriteXml(writer);
writer.Flush();
_xmlString = sw.ToString().Trim();
}
}
}
}
return(_xmlString);
}
public OperatedResult <string> CheckIdentityToken(string token, AppConfig appConfig)
{
ValidateOperator.Begin()
.NotNullOrEmpty(token, "Token")
.NotNull(appConfig, "AppConfig");
try
{
var tokenText = ParseTokens(token, appConfig.SharedKey);
if (string.IsNullOrEmpty(tokenText))
{
return(OperatedResult <string> .Fail("用户令牌Token为空"));
}
dynamic root = JObject.Parse(tokenText);
string userid = root.iss;
var iat = root.iat;
var validTokenExpired =
new TimeSpan((int)(UnixEpochHelper.GetCurrentUnixTimestamp().TotalSeconds - iat))
.TotalDays > appConfig.TokenExpiredDay;
return(validTokenExpired
? OperatedResult <string> .Fail($"用户ID{userid}令牌失效")
: OperatedResult <string> .Success(userid));
}
catch (FormatException)
{
return(OperatedResult <string> .Fail("用户令牌非法"));
}
catch (SignatureVerificationException)
{
return(OperatedResult <string> .Fail("用户令牌非法"));
}
}
/// <summary>
/// 反序列化二进制文件
/// </summary>
/// <param name="filePath">二进制文件</param>
/// <returns>对象</returns>
// ReSharper disable once UnusedMember.Global
public static T BinaryDeserialize <T>(string filePath)
{
ValidateOperator.Begin().CheckFileExists(filePath);
var buffer = FileHelper.ReadFile(filePath);
return(BinaryDeserialize <T>(buffer));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="serverHost">服务器IP</param>
/// <param name="userName">用户名</param>
/// <param name="userPassword">密码</param>
/// 时间：2016-04-26 9:01
/// 备注：
public FTPHelper(string serverHost, string userName, string userPassword)
{
ValidateOperator.Begin().NotNullOrEmpty(serverHost, "服务器IP").NotNullOrEmpty(UserName, "用户名").NotNullOrEmpty(userPassword, "用户密码");
UserName = userName;
UserPassword = userPassword;
ServerHost = serverHost;
}
/// <summary>
/// 创建记录
/// </summary>
/// <param name="entity">需要操作的实体类</param>
/// <returns>操作是否成功</returns>
public bool Create <T>(T entity)
where T : ModelBase
{
ValidateOperator.Begin().NotNull(entity, "需要新增的数据记录");
// insert single data always return 0 but the data is inserted in database successfully
//https://github.com/StackExchange/Dapper/issues/587
//List<T> data = new List<T>() { entity };
return(CurrentConnection.Insert(new List <T> {
entity
}, CurrentTransaction) > 0);
#region 测试代码
//string sql = @"INSERT INTO [dbo].[EFSample]
// ([ID]
// ,[CreateTime]
// ,[ModifyTime]
// ,[Available]
// ,[UserName])
//VALUES
// (@ID
// ,@CreateTime
// ,@ModifyTime
// ,@Available
// ,@UserName)";
//return CurrentConnection.Execute(sql, entity) > 0;
#endregion 测试代码
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="url">需要解析的URL</param>
/// 时间：2016/10/26 17:06
/// 备注：
public HtmlParse(string url)
{
string _paramterName = "需要解析的URL";
ValidateOperator.Begin().NotNullOrEmpty(url, _paramterName).IsURL(url, _paramterName);
HtmlAgilityURL = url;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="libFilePath">非托管DLL路径</param>
/// 时间：2016/11/7 13:59
/// 备注：
public UnmanagedLib(string libFilePath)
{
ValidateOperator.Begin()
.NotNullOrEmpty(libFilePath, "非托管DLL路径")
.IsFilePath(libFilePath).CheckFileExists(libFilePath);
LibFilePath = libFilePath;
}
/// <summary>
/// 将集合导出为DataTable
/// </summary>
/// <typeparam name="T">泛型</typeparam>
/// <param name="data">需要导出的集合</param>
/// <param name="propertyNameList">需要包含显示的实体类的属性</param>
/// <returns>DataTable</returns>
/// 时间:2016/10/16 15:54
/// 备注:
public static DataTable ToDataTable <T>(IEnumerable <T> data, string[] propertyNameList)
where T : class
{
ValidateOperator.Begin().NotNull(data, "需要导出的集合");
ICollection <PropertyInfo> _properties = GetCacheProperties <T>(propertyNameList);
DataTable _dataTable = new DataTable(typeof(T).Name);
foreach (PropertyInfo prop in _properties)
{
_dataTable.Columns.Add(DisplayNameHelper.Get(prop));
}
foreach (T item in data)
{
object[] _values = new object[_properties.Count];
int _index = 0;
foreach (PropertyInfo prop in _properties)
{
_values[_index] = prop.GetValue(item, null);
_index++;
}
_dataTable.Rows.Add(_values);
}
return(_dataTable);
}
/// <summary>
/// 执行Sql 脚本查询
/// </summary>
/// <param name="sql">Sql语句</param>
/// <param name="parameters">参数</param>
/// <returns>集合</returns>
public IEnumerable <T> SqlQuery <T>(string sql, IDbDataParameter[] parameters)
{
ValidateOperator.Begin()
.NotNullOrEmpty(sql, "Sql语句");
// ReSharper disable once CoVariantArrayConversion
return(Database.SqlQuery <T>(sql, parameters));
}
/// <summary>
/// 创建请求URL
/// <para>使用http请求的queryString然后加上时间戳还有随机数来作为签名的参数。</para>
/// </summary>
/// <param name="queryParamter">请求参数</param>
/// <param name="dateTime">时间戳</param>
/// <param name="rumdon">随机数</param>
/// <returns>签名参数字符串</returns>
/// 时间：2016/9/22 10:16
/// 备注：
public static string CreateQueryParamter(SortedDictionary <string, string> queryParamter, string dateTime, string rumdon)
{
ValidateOperator.Begin().NotNull(queryParamter, "请求参数");
if (string.IsNullOrEmpty(dateTime))
{
dateTime = DateTime.Now.FormatDate(12);
}
if (string.IsNullOrEmpty(rumdon))
{
rumdon = RandomHelper.NextString(8, true);
}
StringBuilder _builder = new StringBuilder();
foreach (var keyValue in queryParamter)
{
_builder.AppendFormat("{0}={1}&", keyValue.Key, keyValue.Value);
}
if (_builder.Length > 1)
{
_builder.Remove(_builder.Length - 1, 1);
}
_builder.Append(dateTime);
_builder.Append(rumdon);
return(_builder.ToString().ToUpper());
}
/// <summary>
/// 使用用户凭据
/// </summary>
/// <param name="userName">用户名称</param>
/// <param name="userPassword">用户密码</param>
/// 时间：2016-02-02 15:57
/// 备注：
public void SetServiceRunAs(string userName, string userPassword)
{
ServiceRunAs = ServiceRunAs.UserLogin;
ValidateOperator.Begin().NotNullOrEmpty(userName, "服务登陆用户名称").NotNullOrEmpty(userPassword, "服务登陆用户密码");
UserName = userName;
UserPassword = userPassword;
}
/// <summary>
/// 添加缓存文件依赖
/// </summary>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="filePath">文件路径</param>
/// <param name="itemRefreshFactory">缓存过期委托</param>
public void AddFileDependency(string key, object value, string filePath, ICacheItemRefreshAction itemRefreshFactory)
{
ValidateOperator.Begin().CheckFileExists(filePath);
FileDependency _fileDependency = new FileDependency(filePath);
CacheManager.Add(key, value, CacheItemPriority.Normal, itemRefreshFactory, _fileDependency);
}
/// <summary>
/// 根据Key，通过正则匹配从WrapCacheConfigItems里帅选出符合的缓存项目，然后通过字典缓存起来
/// </summary>
/// <param name="key">根据Key获取缓存配置项</param>
/// <returns>缓存配置项</returns>
/// <exception cref="System.Exception"></exception>
public static WrapCacheConfigItem GetCurrentWrapCacheConfigItem(string key)
{
if (wrapCacheConfigItemDic == null)
{
wrapCacheConfigItemDic = new Dictionary <string, WrapCacheConfigItem>();
}
if (wrapCacheConfigItemDic.ContainsKey(key))
{
return(wrapCacheConfigItemDic[key]);
}
lock (syncObject)
{
WrapCacheConfigItem _currentWrapCacheConfigItem = WrapCacheConfigItems.Where(i =>
Regex.IsMatch(ModuleName, i.CacheConfigItem.ModuleRegex, RegexOptions.IgnoreCase) &&
Regex.IsMatch(key, i.CacheConfigItem.KeyRegex, RegexOptions.IgnoreCase))
.OrderByDescending(i => i.CacheConfigItem.Priority).FirstOrDefault();
ValidateOperator.Begin().NotNull(_currentWrapCacheConfigItem, string.Format("依据'{0}'获取缓存配置项异常！", key));
if (!wrapCacheConfigItemDic.ContainsKey(key))
{
wrapCacheConfigItemDic.Add(key, _currentWrapCacheConfigItem);
}
return(_currentWrapCacheConfigItem);
}
}
/// <summary>
/// 文件保存路径(默认:/upload)
/// </summary>
public void SetFileDirectory(string fileDirectory)
{
ValidateOperator.Begin().NotNullOrEmpty(fileDirectory, "保存路径");
bool _mapServerPath = Regex.IsMatch(fileDirectory, @"[a-z]\:\\", RegexOptions.IgnoreCase);
uploadFileSetting.FileDirectory = _mapServerPath == true?GetRelativePath(fileDirectory) : fileDirectory;
}
/// <summary>
/// 分块下载
/// </summary>
/// <param name="context">HttpContext</param>
/// <param name="fileName">下载文件名</param>
/// <param name="filePhysicsPath">文件物理路径</param>
/// <returns>下载是否成功</returns>
public static void FileDownload(HttpContext context, string fileName, string filePhysicsPath)
{
ValidateOperator.Begin().NotNullOrEmpty(fileName, "下载文件名").CheckFileExists(filePhysicsPath);
var filePath = filePhysicsPath;
long chunkSize = 204800; //块大小
var buffer = new byte[chunkSize]; //200K的缓冲区
fileName = string.IsNullOrEmpty(fileName) ? Path.GetFileName(filePath) : fileName;
using (var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
var dataToRead = fileStream.Length; //已读的字节数
context.Response.ContentType = MimeTypes.ApplicationOctetStream;
context.Response.AddHeader("Content-Disposition",
"attachement;filename=" + HttpUtility.UrlEncode(fileName, Encoding.UTF8));
context.Response.AddHeader("Content-Length", dataToRead.ToString());
while (dataToRead > 0)
{
if (context.Response.IsClientConnected)
{
var length = fileStream.Read(buffer, 0, Convert.ToInt32(chunkSize));
context.Response.OutputStream.Write(buffer, 0, length);
context.Response.Flush();
context.Response.Clear();
dataToRead -= length;
}
else
{
dataToRead = -1;
}
}
}
}
/// <summary>
/// 初始化一个 指定页索引与页大小的分页查询条件信息类 的新实例
/// </summary>
/// <param name="pageIndex"> 页索引 </param>
/// <param name="pageSize"> 页大小 </param>
public PageCondition(int pageIndex, int pageSize)
{
ValidateOperator.Begin().CheckGreaterThan <int>(pageIndex, "页索引", 0, false).CheckGreaterThan <int>(pageSize, "页大小", 0, false);
PageIndex = pageIndex;
PageSize = pageSize;
SortConditions = new SortCondition[] { };
}
/// <summary>
/// 判断程序是否已经运行
/// </summary>
/// <param name="processPath">程序exe全路径</param>
/// <param name="owner">进程拥有者</param>
/// <returns>
/// <c>true</c> 是否已经运行 <c>false</c>.
/// </returns>
public static bool IsRunning(string processPath, string owner)
{
ValidateOperator.Begin()
.NotNullOrEmpty(processPath, "需要运行的程序路径")
.NotNullOrEmpty(owner, "进程拥有者")
.CheckFileExists(processPath);
var result = false;
var fileName = Path.GetFileNameWithoutExtension(processPath)?.ToLower();
var workingDirectory = Path.GetDirectoryName(processPath);
var processes = Process.GetProcessesByName(fileName);
if (processes?.Any() ?? false)
{
foreach (var process in processes)
{
var procOwner = GetOwner(process);
if (string.IsNullOrEmpty(procOwner))
{
continue;
}
if (string.Compare(procOwner, owner, StringComparison.OrdinalIgnoreCase) < 0)
{
continue;
}
if (process.MainModule.FileName.StartsWith(workingDirectory, StringComparison.OrdinalIgnoreCase))
{
result = true;
break;
}
}
}
return(result);
}
/// <summary>
/// 还原数据库文件
/// </summary>
/// <param name="filePath">还原备份路径</param>
/// <param name="restoreDbName">还原后数据库名称</param>
/// <returns>还原是否成功</returns>
/// 时间：2016-02-24 17:45
/// 备注：
public bool DataRestore(string filePath, string restoreDbName)
{
ValidateOperator.Begin().IsFilePath(filePath).NotNullOrEmpty(restoreDbName, "还原数据库名称");
bool _result = false;
SqlServerDataOperator _sqlHelper = new SqlServerDataOperator(ConnectString);
string _sql = @" use master ;
declare @s varchar(8000);
select @s=isnull(@s,'')+' kill '+rtrim(spID) from master..sysprocesses where dbid=db_id(@dbid);
select @s;exec(@s) ;RESTORE DATABASE @database FROM DISK = @filepath with replace";
SqlParameter[] _paramters = new SqlParameter[3];
_paramters[0] = new SqlParameter("@dbid", restoreDbName);
_paramters[1] = new SqlParameter("@database", restoreDbName);
_paramters[2] = new SqlParameter("@filepath", filePath);
try
{
_sqlHelper.ExecuteNonQuery(_sql, _paramters);
}
catch (Exception ex)
{
ex.Data.Add("filePath", filePath);
ex.Data.Add("ConnectString", ConnectString);
ex.Data.Add("BackUpDataBase", BackUpDataBase);
throw new FrameworkException(string.Format("还原数据库{0}失败，可能该数据库正在使用。", restoreDbName), ex);
}
return(_result);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="path">access路径</param>
/// <param name="password">access密码</param>
public AccessDataOperator(string path, string password)
{
CheckedAccessDBPath(path);
ValidateOperator.Begin().NotNullOrEmpty(password, "Access数据库密码");
_connectString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + path + ";Jet OLEDB:Database Password= " +
password;
}
/// <summary>
/// 批量插入
/// <para>eg:int _actual = SqlHelper.BatchInert("Person", _db, 300);</para>
/// </summary>
/// <param name="desTable">数据库目标表</param>
/// <param name="dataTable">需要插入的表</param>
/// <param name="batchSize">批量插入数量</param>
/// <returns>影响行数</returns>
public int BatchInert(string desTable, DataTable dataTable, int batchSize)
{
ValidateOperator.Begin().NotNullOrEmpty(desTable, "数据库目标表").NotNull(dataTable, "需要插入的表").CheckGreaterThan <int>(batchSize, "批量插入数量", 0, false);
try
{
using (SqlBulkCopy sbc = new SqlBulkCopy(connectionString, SqlBulkCopyOptions.UseInternalTransaction)
{
BulkCopyTimeout = 300,
NotifyAfter = dataTable.Rows.Count,
BatchSize = batchSize,
DestinationTableName = desTable
})
{
foreach (DataColumn column in dataTable.Columns)
{
sbc.ColumnMappings.Add(column.ColumnName, column.ColumnName);
}
sbc.WriteToServer(dataTable);
}
return(dataTable.Rows.Count);
}
catch (SqlException ex)
{
string _sqlExMessage = "批量插入异常：" + ex.GetSqlExceptionMessage();
ex.Data.Add("sqlServerConnectString", connectionString);
ex.Data.Add("desTable", desTable);
ex.Data.Add("batchSize", batchSize);
throw new FrameworkException(_sqlExMessage, ex);
}
}
/// <summary>
/// 备份数据库
/// </summary>
/// <param name="filePath">备份路径，需带后缀;eg:D:\ddd.bakRM_DB20160224151425.bak</param>
/// <returns>备份数据库是否成功</returns>
/// 时间：2016-02-24 16:44
/// 备注：
public bool DataBackup(string filePath)
{
ValidateOperator.Begin().IsFilePath(filePath);
bool _result = false;
//创建连接对象
SqlServerDataOperator _sqlHelper = new SqlServerDataOperator(ConnectString);
DropBackupDevice(_sqlHelper);
CreateBackupDevice(_sqlHelper, filePath);
try
{
SqlParameter[] _paramters = new SqlParameter[2];
_paramters[0] = new SqlParameter("@dataBase", BackUpDataBase);
_paramters[1] = new SqlParameter("@descdataBase", BackUpDataBase);
string _sql = "BACKUP DATABASE @dataBase TO @descdataBase WITH INIT";
_sqlHelper.ExecuteNonQuery(_sql, _paramters);
_result = false;
}
catch (Exception ex)
{
ex.Data.Add("filePath", filePath);
ex.Data.Add("ConnectString", ConnectString);
ex.Data.Add("BackUpDataBase", BackUpDataBase);
throw new FrameworkException(string.Format("备份数据库{0}失败。", BackUpDataBase), ex);
}
return(_result);
}
/// <summary>
/// 序列化
/// </summary>
/// <param name="serializeObject">需要序列化对象</param>
/// <returns>Json字符串</returns>
public string Serialize(object serializeObject)
{
ValidateOperator.Begin().NotNull(serializeObject, "需要序列化对象");
var type = serializeObject.GetType();
var serializer = new Newtonsoft.Json.JsonSerializer();
Initialize(serializer);
if (type == typeof(DataRow))
{
serializer.Converters.Add(new DataRowConverter());
}
else if (type == typeof(DataTable))
{
serializer.Converters.Add(new DataTableConverter());
}
else if (type == typeof(DataSet))
{
serializer.Converters.Add(new DataSetConverter());
}
using (var writer = new StringWriter())
{
using (var jsonWriter = new JsonTextWriter(writer))
{
jsonWriter.Formatting = Formatting.None;
jsonWriter.QuoteChar = '"';
serializer.Serialize(jsonWriter, serializeObject);
return(writer.ToString());
}
}
}
/// <summary>
/// 将对象序列化成二进制文件保存
/// </summary>
/// <param name="serializeData">需要序列化的对象</param>
/// <param name="saveFilePath">保存文件</param>
public static void BinarySerialize <T>(T serializeData, string saveFilePath)
{
CheckedSerializeData(serializeData);
ValidateOperator.Begin().IsFilePath(saveFilePath);
byte[] _buffer = BinarySerialize <T>(serializeData);
FileHelper.SaveFile(_buffer, saveFilePath);
}
/// <summary>
/// 循环集合的每一项，调用委托生成字符串，返回合并后的字符串。默认分隔符为逗号
/// </summary>
/// <param name="collection">待处理的集合</param>
/// <param name="itemFormatFunc">单个集合项的转换委托</param>
/// <param name="separetor">分隔符，默认为逗号</param>
/// <typeparam name="T">泛型类型</typeparam>
/// <returns></returns>
public static string ExpandAndToString <T>(this IEnumerable <T> collection, Func <T, string> itemFormatFunc, string separetor = ",")
{
collection = collection as IList <T> ?? collection.ToList();
ValidateOperator.Begin().NotNull(itemFormatFunc, "单个集合项的转换委托");
if (!collection.Any())
{
return(null);
}
StringBuilder _builder = new StringBuilder();
int i = 0;
int count = collection.Count();
foreach (T t in collection)
{
if (i == count - 1)
{
_builder.Append(itemFormatFunc(t));
}
else
{
_builder.Append(itemFormatFunc(t) + separetor);
}
i++;
}
return(_builder.ToString());
}
/// <summary>
/// 把<see cref="IOrderedQueryable{T}"/>集合继续按指定字段排序方式进行排序
/// </summary>
/// <typeparam name="T">动态类型</typeparam>
/// <param name="source">要排序的数据集</param>
/// <param name="propertyName">排序属性名</param>
/// <param name="sortDirection">排序方向</param>
/// <returns></returns>
public static IOrderedEnumerable <T> ThenBy <T>(this IOrderedEnumerable <T> source,
string propertyName,
ListSortDirection sortDirection = ListSortDirection.Ascending)
{
ValidateOperator.Begin().NotNull(source, "要排序的数据集").NotNullOrEmpty(propertyName, "排序属性名");
return(CollectionPropertySorter <T> .ThenBy(source, propertyName, sortDirection));
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="apiAuthenticate">IApiAuthenticate</param>
/// <param name="appCfgService">appCfgService</param>
protected AuthenticateAttribute(IApiAuthenticate apiAuthenticate, IAppConfigService appCfgService)
{
ValidateOperator.Begin()
.NotNull(apiAuthenticate, "IApiAuthenticate")
.NotNull(appCfgService, "IAppConfigService");
ApiAuthenticate = apiAuthenticate;
AppCfgService = appCfgService;
}
/// <summary>
/// 执行Sql 脚本查询
/// </summary>
/// <param name="sql">Sql语句</param>
/// <param name="parameters">参数</param>
/// <returns>集合</returns>
public IEnumerable <T> SqlQuery <T>(string sql, IDbDataParameter[] parameters)
{
ValidateOperator.Begin()
.NotNullOrEmpty(sql, "Sql语句");
var dataParameters = CreateParameter(parameters);
return(CurrentConnection.Query <T>(sql, dataParameters, CurrentTransaction));
}
