适用于app.config与web.config的ConfigUtil读写工具类 基于MongoDb官方C#驱动封装MongoDbCsharpHelper类（CRUD类） 基于ASP.NE...

适用于app.config与web.config的ConfigUtil读写工具类

 

之前文章：《两种读写配置文件的方案(app.config与web.config通用)》，现在重新整理一个更完善的版本，增加批量读写以及指定配置文件路径，代码如下：

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;
using  System.Threading.Tasks;
using  System.Configuration;
using  System.IO;

namespace  Zuowj.Utils
{
    ///
    /// 配置工具类
    /// Author：左文俊
    /// Date：2018/1/27
    public  static  class  ConfigUtil
    {
        ///
        /// 获取管理配置文件对象Configuration
        ///
        /// 指定要管理的配置文件路径，如果为空或不存在，则管理程序集默认的配置文件路径
        ///
        private  static  Configuration GetConfiguration( string  configPath =  null )
        {
            if  (! string .IsNullOrEmpty(configPath) && File.Exists(configPath))
            {
                ExeConfigurationFileMap map =  new  ExeConfigurationFileMap();
                map.ExeConfigFilename = configPath;
                return  ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
            }
            else
            {
                return  ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            }
        }


        ///
        /// 获取指定配置文件+配置名称的配置项的值
        ///
        public  static  string  GetAppSettingValue( string  key,  string  defaultValue =  null ,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            var  appSetting = config.AppSettings.Settings[key];
            return  appSetting.Value;
        }


        ///
        /// 设置配置值（存在则更新，不存在则新增）
        ///
        public  static  void  SetAppSettingValue( string  key,  string  value,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            var  setting = config.AppSettings.Settings[key];
            if  (setting ==  null )
            {
                config.AppSettings.Settings.Add(key, value);
            }
            else
            {
                setting.Value = value;
            }

            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "appSettings" );
        }

        ///
        /// 删除配置值
        ///
        public  static  void  RemoveAppSetting( string  key,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            config.AppSettings.Settings.Remove(key);
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "appSettings" );
        }

        ///
        /// 设置多个配置值（存在则更新，不存在则新增）
        ///
        public  static  void  SetAppSettingValues(IEnumerable string ,  string >> settingValues,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            foreach  ( var  item  in  settingValues)
            {
                var  setting = config.AppSettings.Settings[item.Key];
                if  (setting ==  null )
                {
                    config.AppSettings.Settings.Add(item.Key, item.Value);
                }
                else
                {
                    setting.Value = item.Value;
                }
            }
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "appSettings" );
        }

        ///
        /// 获取所有配置值
        ///
        public  static  Dictionary< string ,  string > GetAppSettingValues( string  configPath =  null )
        {
            Dictionary< string ,  string > settingDic =  new  Dictionary< string ,  string >();
            var  config = GetConfiguration(configPath);
            var  settings = config.AppSettings.Settings;
            foreach  ( string  key  in  settings.AllKeys)
            {
                settingDic[key] = settings[key].ToString();
            }
            return  settingDic;
        }

        ///
        /// 删除多个配置值
        ///
        public  static  void  RemoveAppSettings( string  configPath =  null ,  params  string [] keys)
        {
            var  config = GetConfiguration(configPath);
            if  (keys !=  null )
            {
                foreach  ( string  key  in  keys)
                {
                    config.AppSettings.Settings.Remove(key);
                }
            }
            else
            {
                config.AppSettings.Settings.Clear();
            }
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "appSettings" );
        }



        ///
        /// 获取连接字符串
        ///
        public  static  string  GetConnectionString( string  name,  string  defaultconnStr =  null ,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            var  connStrSettings = config.ConnectionStrings.ConnectionStrings[name];
            if  (connStrSettings ==  null )
            {
                return  defaultconnStr;
            }
            return  connStrSettings.ConnectionString;
        }

        ///
        /// 获取指定配置文件+连接名称的连接字符串配置项
        ///
        public  static  ConnectionStringSettings GetConnectionStringSetting( string  name,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            var  connStrSettings = config.ConnectionStrings.ConnectionStrings[name];
            return  connStrSettings;
        }

        ///
        /// 设置连接字符串的值（存在则更新，不存在则新增）
        ///
        public  static  void  SetConnectionString( string  name,  string  connstr,  string  provider,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            ConnectionStringSettings connStrSettings = config.ConnectionStrings.ConnectionStrings[name];
            if  (connStrSettings !=  null )
            {
                connStrSettings.ConnectionString = connstr;
                connStrSettings.ProviderName = provider;
            }
            else
            {
                connStrSettings =  new  ConnectionStringSettings(name, connstr, provider);
                config.ConnectionStrings.ConnectionStrings.Add(connStrSettings);
            }

            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "connectionStrings" );
        }

        ///
        /// 删除连接字符串配置项
        ///
        public  static  void  RemoveConnectionString( string  name,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            config.ConnectionStrings.ConnectionStrings.Remove(name);
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "connectionStrings" );
        }

        ///
        /// 获取所有的连接字符串配置项
        ///
        public  static  Dictionary< string , ConnectionStringSettings> GetConnectionStringSettings( string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            var  connStrSettingDic =  new  Dictionary< string , ConnectionStringSettings>();
            var  connStrSettings = ConfigurationManager.ConnectionStrings;
            foreach  (ConnectionStringSettings item  in  connStrSettings)
            {
                connStrSettingDic[item.Name] = item;
            }
            return  connStrSettingDic;
        }

        ///
        /// 设置多个连接字符串的值（存在则更新，不存在则新增）
        ///
        public  static  void  SetConnectionStrings(IEnumerable connStrSettings,  string  configPath =  null )
        {
            var  config = GetConfiguration(configPath);
            foreach  ( var  item  in  connStrSettings)
            {
                ConnectionStringSettings connStrSetting = config.ConnectionStrings.ConnectionStrings[item.Name];
                if  (connStrSetting !=  null )
                {
                    connStrSetting.ConnectionString = item.ConnectionString;
                    connStrSetting.ProviderName = item.ProviderName;
                }
                else
                {
                    config.ConnectionStrings.ConnectionStrings.Add(item);
                }
            }

            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "connectionStrings" );
        }

        ///
        /// 删除多个连接字符串配置项
        ///
        public  static  void  RemoveConnectionStrings( string  configPath =  null ,  params  string [] names)
        {
            var  config = GetConfiguration(configPath);
            if  (names !=  null )
            {
                foreach  ( string  name  in  names)
                {
                    config.ConnectionStrings.ConnectionStrings.Remove(name);
                }
            }
            else
            {
                config.ConnectionStrings.ConnectionStrings.Clear();
            }
            config.Save(ConfigurationSaveMode.Modified);
            ConfigurationManager.RefreshSection( "connectionStrings" );
        }

    }


}

　　

 

 

 

基于MongoDb官方C#驱动封装MongoDbCsharpHelper类（CRUD类）

 

近期工作中有使用到 MongoDb作为日志持久化对象，需要实现对MongoDb的增、删、改、查，但由于MongoDb的版本比较新，是2.4以上版本的，网上已有的一些MongoDb Helper类都是基于之前MongoDb旧的版本，无法适用于新版本的MongoDb，故我基于MongoDb官方C#驱动重新封装了MongoDbCsharpHelper类（CRUD类），完整代码如下：

using  MongoDB;
using  MongoDB.Bson;
using  MongoDB.Driver;
using  System;
using  System.Collections;
using  System.Collections.Generic;
using  System.Linq;
using  System.Linq.Expressions;
using  System.Reflection;
using  System.Threading;
using  System.Web;

namespace  Zuowj.Utils
{
    ///
    /// MongoDbCsharpHelper:MongoDb基于C#语言操作帮助类
    /// Author:Zuowenjun
    /// Date:2017/11/16
    ///
    public  class  MongoDbCsharpHelper
    {
        private  readonly  string  connectionString =  null ;
        private  readonly  string  databaseName =  null ;
        private  MongoDB.Driver.IMongoDatabase database =  null ;
        private  readonly  bool  autoCreateDb =  false ;
        private  readonly  bool  autoCreateCollection =  false ;

        static  MongoDbCsharpHelper()
        {
            BsonDefaults.GuidRepresentation = GuidRepresentation.Standard;
        }

        public  MongoDbCsharpHelper( string  mongoConnStr,  string  dbName,  bool  autoCreateDb =  false ,  bool  autoCreateCollection =  false )
        {
            this .connectionString = mongoConnStr;
            this .databaseName = dbName;
            this .autoCreateDb = autoCreateDb;
            this .autoCreateCollection = autoCreateCollection;
        }

        #region 私有方法

        private  MongoClient CreateMongoClient()
        {
            return  new  MongoClient(connectionString);
        }


        private  MongoDB.Driver.IMongoDatabase GetMongoDatabase()
        {
            if  (database ==  null )
            {
                var  client = CreateMongoClient();
                if  (!DatabaseExists(client, databaseName) && !autoCreateDb)
                {
                    throw  new  KeyNotFoundException( "此MongoDB名称不存在："  + databaseName);
                }

                database = CreateMongoClient().GetDatabase(databaseName);
            }

            return  database;
        }

        private  bool  DatabaseExists(MongoClient client,  string  dbName)
        {
            try
            {
                var  dbNames = client.ListDatabases().ToList().Select(db => db.GetValue( "name" ).AsString);
                return  dbNames.Contains(dbName);
            }
            catch  //如果连接的账号不能枚举出所有DB会报错，则默认为true
            {
                return  true ;
            }

        }

        private  bool  CollectionExists(IMongoDatabase database,  string  collectionName)
        {
            var  options =  new  ListCollectionsOptions
            {
                Filter = Builders.Filter.Eq( "name" , collectionName)
            };

            return  database.ListCollections(options).ToEnumerable().Any();
        }


        private  MongoDB.Driver.IMongoCollection GetMongoCollection( string  name, MongoCollectionSettings settings =  null )
        {
            var  mongoDatabase = GetMongoDatabase();

            if  (!CollectionExists(mongoDatabase, name) && !autoCreateCollection)
            {
                throw  new  KeyNotFoundException( "此Collection名称不存在："  + name);
            }

            return  mongoDatabase.GetCollection(name, settings);
        }

        private  List> BuildUpdateDefinition( object  doc,  string  parent)
        {
            var  updateList =  new  List>();
            foreach  ( var  property  in  typeof (TDoc).GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                var  key = parent ==  null  ? property.Name :  string .Format( "{0}.{1}" , parent, property.Name);
                //非空的复杂类型
                if  ((property.PropertyType.IsClass || property.PropertyType.IsInterface) && property.PropertyType !=  typeof ( string ) && property.GetValue(doc) !=  null )
                {
                    if  ( typeof (IList).IsAssignableFrom(property.PropertyType))
                    {
                        #region 集合类型
                        int  i = 0;
                        var  subObj = property.GetValue(doc);
                        foreach  ( var  item  in  subObj  as  IList)
                        {
                            if  (item.GetType().IsClass || item.GetType().IsInterface)
                            {
                                updateList.AddRange(BuildUpdateDefinition(doc,  string .Format( "{0}.{1}" , key, i)));
                            }
                            else
                            {
                                updateList.Add(Builders.Update.Set( string .Format( "{0}.{1}" , key, i), item));
                            }
                            i++;
                        }
                        #endregion
                    }
                    else
                    {
                        #region 实体类型
                        //复杂类型，导航属性，类对象和集合对象
                        var  subObj = property.GetValue(doc);
                        foreach  ( var  sub  in  property.PropertyType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
                        {
                            updateList.Add(Builders.Update.Set( string .Format( "{0}.{1}" , key, sub.Name), sub.GetValue(subObj)));
                        }
                        #endregion
                    }
                }
                else  //简单类型
                {
                    updateList.Add(Builders.Update.Set(key, property.GetValue(doc)));
                }
            }

            return  updateList;
        }


        private  void  CreateIndex(IMongoCollection col,  string [] indexFields, CreateIndexOptions options =  null )
        {
            if  (indexFields ==  null )
            {
                return ;
            }
            var  indexKeys = Builders.IndexKeys;
            IndexKeysDefinition keys =  null ;
            if  (indexFields.Length > 0)
            {
                keys = indexKeys.Descending(indexFields[0]);
            }
            for  ( var  i = 1; i < indexFields.Length; i++)
            {
                var  strIndex = indexFields[i];
                keys = keys.Descending(strIndex);
            }

            if  (keys !=  null )
            {
                col.Indexes.CreateOne(keys, options);
            }

        }

        #endregion

        public  void  CreateCollectionIndex( string  collectionName,  string [] indexFields, CreateIndexOptions options =  null )
        {
            CreateIndex(GetMongoCollection(collectionName), indexFields, options);
        }

        public  void  CreateCollection( string [] indexFields =  null , CreateIndexOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            CreateCollection(collectionName, indexFields, options);
        }

        public  void  CreateCollection( string  collectionName,  string [] indexFields =  null , CreateIndexOptions options =  null )
        {
            var  mongoDatabase = GetMongoDatabase();
            mongoDatabase.CreateCollection(collectionName);
            CreateIndex(GetMongoCollection(collectionName), indexFields, options);
        }


        public  List Find(Expression bool >> filter, FindOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            return  Find(collectionName, filter, options);
        }

        public  List Find( string  collectionName, Expression bool >> filter, FindOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            return  colleciton.Find(filter, options).ToList();
        }


        public  List FindByPage(Expression bool >> filter, Expression> keySelector,  int  pageIndex,  int  pageSize,  out  int  rsCount)
        {
            string  collectionName =  typeof (TDoc).Name;
            return  FindByPage(collectionName, filter, keySelector, pageIndex, pageSize,  out  rsCount);
        }

        public  List FindByPage( string  collectionName, Expression bool >> filter, Expression> keySelector,  int  pageIndex,  int  pageSize,  out  int  rsCount)
        {
            var  colleciton = GetMongoCollection(collectionName);
            rsCount = colleciton.AsQueryable().Where(filter).Count();

            int  pageCount = rsCount / pageSize + ((rsCount % pageSize) > 0 ? 1 : 0);
            if  (pageIndex > pageCount) pageIndex = pageCount;
            if  (pageIndex <= 0) pageIndex = 1;

            return  colleciton.AsQueryable( new  AggregateOptions { AllowDiskUse =  true  }).Where(filter).OrderByDescending(keySelector).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList();
        }

        public  void  Insert(TDoc doc, InsertOneOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            Insert(collectionName, doc, options);
        }

        public  void  Insert( string  collectionName, TDoc doc, InsertOneOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            colleciton.InsertOne(doc, options);
        }


        public  void  InsertMany(IEnumerable docs, InsertManyOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            InsertMany(collectionName, docs, options);
        }

        public  void  InsertMany( string  collectionName, IEnumerable docs, InsertManyOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            colleciton.InsertMany(docs, options);
        }

        public  void  Update(TDoc doc, Expression bool >> filter, UpdateOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            var  colleciton = GetMongoCollection(collectionName);
            List> updateList = BuildUpdateDefinition(doc,  null );
            colleciton.UpdateOne(filter, Builders.Update.Combine(updateList), options);
        }

        public  void  Update( string  collectionName, TDoc doc, Expression bool >> filter, UpdateOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            List> updateList = BuildUpdateDefinition(doc,  null );
            colleciton.UpdateOne(filter, Builders.Update.Combine(updateList), options);
        }


        public  void  Update(TDoc doc, Expression bool >> filter, UpdateDefinition updateFields, UpdateOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            Update(collectionName, doc, filter, updateFields, options);
        }

        public  void  Update( string  collectionName, TDoc doc, Expression bool >> filter, UpdateDefinition updateFields, UpdateOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            colleciton.UpdateOne(filter, updateFields, options);
        }


        public  void  UpdateMany(TDoc doc, Expression bool >> filter, UpdateOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            UpdateMany(collectionName, doc, filter, options);
        }


        public  void  UpdateMany( string  collectionName, TDoc doc, Expression bool >> filter, UpdateOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            List> updateList = BuildUpdateDefinition(doc,  null );
            colleciton.UpdateMany(filter, Builders.Update.Combine(updateList), options);
        }


        public  void  Delete(Expression bool >> filter, DeleteOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            Delete(collectionName, filter, options);
        }

        public  void  Delete( string  collectionName, Expression bool >> filter, DeleteOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            colleciton.DeleteOne(filter, options);
        }


        public  void  DeleteMany(Expression bool >> filter, DeleteOptions options =  null )
        {
            string  collectionName =  typeof (TDoc).Name;
            DeleteMany(collectionName, filter, options);
        }


        public  void  DeleteMany( string  collectionName, Expression bool >> filter, DeleteOptions options =  null )
        {
            var  colleciton = GetMongoCollection(collectionName);
            colleciton.DeleteMany(filter, options);
        }

        public  void  ClearCollection( string  collectionName)
        {
            var  colleciton = GetMongoCollection(collectionName);
            var  inddexs = colleciton.Indexes.List();
            List> docIndexs =  new  List>();
            while  (inddexs.MoveNext())
            {
                docIndexs.Add(inddexs.Current);
            }
            var  mongoDatabase = GetMongoDatabase();
            mongoDatabase.DropCollection(collectionName);

            if  (!CollectionExists(mongoDatabase, collectionName))
            {
                CreateCollection(collectionName);
            }

            if  (docIndexs.Count > 0)
            {
                colleciton = mongoDatabase.GetCollection(collectionName);
                foreach  ( var  index  in  docIndexs)
                {
                    foreach  (IndexKeysDefinition indexItem  in  index)
                    {
                        try
                        {
                            colleciton.Indexes.CreateOne(indexItem);
                        }
                        catch
                        { }
                    }
                }
            }

        }
    }
}

对上述代码中几个特别的点进行简要说明：

1.由于MongoClient.GetDatabase 获取DB、MongoClient.GetCollection 获取文档（也可称为表）的方法 都有一个特点，即：如果指定的DB名称、Collection名称不存在，则会直接创建，但有的时候可能是因为DB名称、Collection名称写错了导致误创建了的DB或Collection，那就引起不必要的麻烦，故在MongoDbCsharpHelper类类内部封装了两个私有的方法：DatabaseExists（判断DB是否存在，如是连接的账号没有检索DB的权限可能会报错，故代码中加了直接返回true）、CollectionExists（判断Collection是否存在）；

2.每个CRUD方法，我都分别重载了两个方法，一个是无需指定Collection名称，一个是需要指定Collection名称，为什么这么做呢？原因很简单，因为有时Collection的结构是相同的但又是不同的Collection，这时TDoc是同一个实体类，但collectionName却是不同的；

3.分页查询的时候如果Collection的数据量比较大，那么就会报类似错误：exception: Sort exceeded memory limit of 104857600 bytes, but did not opt in to external sorting. Aborting operation. Pass allowDiskUse:true，根据报错提示，我们在查询大数据量时增加AggregateOptions对象，如： colleciton.AsQueryable(new AggregateOptions { AllowDiskUse = true })

4.ClearCollection清除Collection的所有数据，如果Collection的数据量非常大，那么直接使用colleciton.DeleteMany可能需要很久，有没有类似SQL SERVER 的truncate table的方法呢？经过多方论证，很遗憾并没有找到同类功能的方法，只有DropCollection方法，而这个DropCollection方法是直接删除Collection，当然包括Collection的所有数据，效率也非常高，但是由于是Drop，Collection就不存在了，如果再访问有可能会报Collection不存在的错误，那有没有好的办法解决了，当然有，那就是先DropCollection 然后再CreateCollection，最后别忘了把原有的索引插入到新创建的Collection中，这样就实现了truncate 初始化表的作用，当然在创建索引的时候，有的时候可能报报错（如：_id），因为_id默认就会被创建索引，再创建可能就会报错，故colleciton.Indexes.CreateOne外我加了try catch，如果报错则忽略。

5.CreateCollection（创建集合）、CreateCollectionIndex（创建集合索引）因为有的时候我们需要明确的去创建一个Collection或对已有的Collection创建索引，如果通过shell命令会非常不方便，故在此封装了一下。

 使用示例如下：

var  mongoDbHelper =  new  MongoDbCsharpHelper( "MongoDbConnectionString" ,  "LogDB" );

mongoDbHelper.CreateCollection( "SysLog1" , new []{ "LogDT" });

mongoDbHelper.Find( "SysLog1" , t => t.Level ==  "Info" );

int  rsCount=0;
mongoDbHelper.FindByPage( "SysLog1" ,t=>t.Level== "Info" ,t=>t,1,20, out  rsCount);

mongoDbHelper.Insert( "SysLog1" , new  SysLogInfo { LogDT = DateTime.Now, Level =  "Info" , Msg =  "测试消息"  });

mongoDbHelper.Update( "SysLog1" , new  SysLogInfo { LogDT = DateTime.Now, Level =  "Error" , Msg =  "测试消息2"  },t => t.LogDT== new  DateTime(1900,1,1));

mongoDbHelper.Delete(t => t.Level ==  "Info" );

mongoDbHelper.ClearCollection( "SysLog1" );

 

 

 

 

基于ASP.NET WEB API实现分布式数据访问中间层（提供对数据库的CRUD）

 

一些小的C/S项目（winform、WPF等），因需要访问操作数据库，但又不能把DB连接配置在客户端上，原因有很多，可能是DB连接无法直接访问，或客户端不想安装各种DB访问组件，或DB连接不想暴露在客户端（即使加密连接字符串仍有可能被破解的情况），总之都是出于安全考虑，同时因项目小，也无需采用分布式架构来将业务操作封装到服务端，但又想保证客户端业务的正常处理，这时我们就可以利用ASP.NET WEB API框架开发一个简单的提供对数据库的直接操作（CRUD）框架，简称为：分布式数据访问中间层。

实现方案很简单，就是利用ASP.NET WEB API框架编写于一个DataController，然后在DataController分别实现CRUD相关的公开ACTION方法即可，具体实现代码如下：（因为逻辑简单，一看就懂，故下面不再详细说明逻辑，文末会有一些总结）

ASP.NET WEB API服务端相关核心代码：

1.DataController代码：

    [SqlInjectionFilter]
    [Authorize]
    public class DataController : ApiController
    {

        [AllowAnonymous]
        [HttpPost]
        public ApiResultInfo Login([FromBody]string[] loginInfo)
        {
            ApiResultInfo loginResult = null;
            try
            {
                if (loginInfo == null || loginInfo.Length != 4)
                {
                    throw new Exception("登录信息不全。");
                }

                using (var da = BaseUtil.CreateDataAccess())
                {
                    if (用户名及密码判断逻辑)
                    {
                        throw new Exception("登录名或密码错误。");
                    }
                    else
                    {
                        string token = Guid.NewGuid().ToString("N");
                        HttpRuntime.Cache.Insert(Constants.CacheKey_SessionTokenPrefix + token, loginInfo[0], null, Cache.NoAbsoluteExpiration, TimeSpan.FromHours(1));
                    
                        //登录成功后需要处理的逻辑


                        loginResult = ApiResultInfo.BuildOKResult(token);
                    }
                }
            }
            catch (Exception ex)
            {
                LogUitl.Error(ex, "Api.Data.Login", BaseUtil.SerializeToJson(loginInfo));
                loginResult = ApiResultInfo.BuildErrResult("LoginErr", ex.Message);
            }

            return loginResult;
        }

        [HttpPost]
        public ApiResultInfo LogOut([FromBody] string token)
        {
            try
            {
                if (!string.IsNullOrEmpty(token))
                {
                    if (HttpRuntime.Cache[Constants.CacheKey_SessionTokenPrefix + token] != null)
                    {
                        HttpRuntime.Cache.Remove(token);
                    }

                    using (var da = BaseUtil.CreateDataAccess())
                    {
                        //登出后需要处理的逻辑
                    }
                }
            }
            catch
            { }

            return ApiResultInfo.BuildOKResult();
        }


        [HttpPost]
        public ApiResultInfo GetValue([FromBody]SqlCmdInfo sqlCmd)
        {
            using (var da = BaseUtil.CreateDataAccess())
            {
                var result = da.ExecuteScalar(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());
                return ApiResultInfo.BuildOKResult(result);
            }

        }


        [Compression]
        [HttpPost]
        public ApiResultInfo GetDataSet([FromBody]SqlCmdInfo sqlCmd)
        {
            using (var da = BaseUtil.CreateDataAccess())
            {
                var ds = da.ExecuteDataSet(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());
                return ApiResultInfo.BuildOKResult(ds);
            }
        }

        [Compression]
        [HttpPost]
        public ApiResultInfo GetDataTable([FromBody]SqlCmdInfo sqlCmd)
        {
            using (var da = BaseUtil.CreateDataAccess())
            {
                var table = da.ExecuteDataTable(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());
                return ApiResultInfo.BuildOKResult(table);
            }
        }


        [HttpPost]
        public ApiResultInfo ExecuteCommand([FromBody]SqlCmdInfo sqlCmd)
        {
            using (var da = BaseUtil.CreateDataAccess())
            {
                int result = da.ExecuteCommand(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());
                return ApiResultInfo.BuildOKResult(result);
            }
        }

        [HttpPost]
        public ApiResultInfo BatchExecuteCommand([FromBody] IEnumerable sqlCmds)
        {
            using (var da = BaseUtil.CreateDataAccess())
            {
                int execCount = 0;
                da.UseTransaction();
                foreach (var sqlCmd in sqlCmds)
                {
                    execCount += da.ExecuteCommand(sqlCmd.SqlCmdText, sqlCmd.GetCommandType(), sqlCmd.Parameters.TryToArray());
                }
                da.Commit();
                return new ApiResultInfo(execCount > 0);
            }
        }


        [HttpPost]
        public async Task ExecuteCommandAsync([FromBody]SqlCmdInfo sqlCmd)
        {
            return await Task.Factory.StartNew((arg) =>
             {
                 var sqlCmdObj = arg as SqlCmdInfo;
                 string connName = BaseUtil.GetDbConnectionName(sqlCmdObj.DbType);
                 using (var da = BaseUtil.CreateDataAccess(connName))
                 {
                     try
                     {
                         int result = da.ExecuteCommand(sqlCmdObj.SqlCmdText, sqlCmdObj.GetCommandType(), sqlCmdObj.Parameters.TryToArray());
                         return ApiResultInfo.BuildOKResult(result);
                     }
                     catch (Exception ex)
                     {
                         LogUitl.Error(ex, "Api.Data.ExecuteCommandAsync", BaseUtil.SerializeToJson(sqlCmdObj));

                         return ApiResultInfo.BuildErrResult("ExecuteCommandAsyncErr", ex.Message,
                                new Dictionary { { "StackTrace", ex.StackTrace } });
                     }
                 }
             }, sqlCmd);
        }

        [HttpPost]
        public IHttpActionResult SaveLog([FromBody]string[] logInfo)
        {
            if (logInfo == null || logInfo.Length < 3)
            {
                return Ok();
            }

            string[] saveLogInfo = new string[7];
            for (int i = 1; i < logInfo.Length; i++)
            {
                if (saveLogInfo.Length > i + 1)
                {
                    saveLogInfo[i] = logInfo[i];
                }
            }


            switch (saveLogInfo[0].ToUpperInvariant())
            {
                case "ERR":
                    {
                        LogUitl.Error(saveLogInfo[1], saveLogInfo[2], saveLogInfo[3], saveLogInfo[4], saveLogInfo[5], saveLogInfo[6]);
                        break;
                    }
                case "WARN":
                    {
                        LogUitl.Warn(saveLogInfo[1], saveLogInfo[2], saveLogInfo[3], saveLogInfo[4], saveLogInfo[5], saveLogInfo[6]);
                        break;
                    }
                case "INFO":
                    {
                        LogUitl.Info(saveLogInfo[1], saveLogInfo[2], saveLogInfo[3], saveLogInfo[4], saveLogInfo[5], saveLogInfo[6]);
                        break;
                    }
            }

            return Ok();

        }



    }

 2.SqlInjectionFilterAttribute (防止SQL注入、危险关键字攻击过滤器)

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class SqlInjectionFilterAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuting(System.Web.Http.Controllers.HttpActionContext actionContext)
        {
            if (actionContext.ActionArguments.ContainsKey("sqlCmd"))
            {
                var sqlCmd = actionContext.ActionArguments["sqlCmd"] as SqlCmdInfo;
                if (BaseUtil.IsIncludeDangerSql(sqlCmd.SqlCmdText))
                {
                    throw new Exception("存在SQL注入风险，禁止操作！");
                }
            }

            base.OnActionExecuting(actionContext);
        }
    }

IsIncludeDangerSql：判断是否包含危险关键字

        /// 

        /// 判断是否包含危险的SQL关键词
        /// 
        /// 
        /// 包含返回true，否则false
        public static bool IsIncludeDangerSql(string sqlCmdText)
        {
            if (string.IsNullOrWhiteSpace(sqlCmdText)) return false;

            sqlCmdText = sqlCmdText.Replace("[", " ").Replace("]", " ");

            //string dangerSqlObjs = @"sys\.columns|sys\.tables|sys\.views|sys\.objects|sys\.procedures|sys\.indexes|INFORMATION_SCHEMA\.TABLES|INFORMATION_SCHEMA\.VIEWS|INFORMATION_SCHEMA\.COLUMNS|GRANT|DENY|SP_HELP|SP_HELPTEXT";
            //dangerSqlObjs += @"|object_id|syscolumns|sysobjects|sysindexes|drop\s+\w+|alter\s+\w+|create\s+\w+";

            string dangerSqlObjs = @"sys\.\w+|INFORMATION_SCHEMA\.\w+|GRANT|DENY|SP_HELP|SP_HELPTEXT|sp_executesql";
            dangerSqlObjs += @"|object_id|syscolumns|sysobjects|sysindexes|exec\s+\(.+\)|(create|drop|alter)\s+(database|table|index|procedure|view|trigger)\s+\w+(?!#)";

            string patternStr = string.Format(@"(^|\s|,|\.)({0})(\s|,|\(|;|$)", dangerSqlObjs);
            bool mathed = Regex.IsMatch(sqlCmdText, patternStr, RegexOptions.IgnoreCase);
            if (mathed)
            {
                //TODO:记录到危险请求表中，以便后续追查
                LogUitl.Warn("检测到包含危险的SQL关键词语句：" + sqlCmdText, "IsIncludeDangerSql");
            }

            return mathed;
        }

3.SqlCmdInfo （ACTION参数对象，SQL命令信息类）

    [Serializable]
    public class SqlCmdInfo
    {
        public string SqlCmdText { get; set; }

        public ArrayList Parameters { get; set; }

        public bool IsSPCmdType { get; set; }

        public int DbType { get; set; }

        public CommandType GetCommandType()
        {
            return IsSPCmdType ? CommandType.StoredProcedure : CommandType.Text;
        }
    }

4.CompressionAttribute（压缩返回内容过滤器，当返回的是大量数据时，可以标记该过滤器，以便提高响应速度）

    /// 

    /// 压缩返回信息
    /// 
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class CompressionAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            var content = actionExecutedContext.Response.Content;

            #region 根据请求是否压缩，暂时不用
            var acceptEncoding = actionExecutedContext.Request.Headers.AcceptEncoding.
                Where(x => x.Value == "gzip" || x.Value == "deflate").ToList();
            if (acceptEncoding.HasItem() && content != null && actionExecutedContext.Request.Method != HttpMethod.Options)
            {
                var first = acceptEncoding.FirstOrDefault();
                if (first != null)
                {
                    var bytes = content.ReadAsByteArrayAsync().Result;
                    switch (first.Value)
                    {
                        case "gzip":
                            actionExecutedContext.Response.Content = new ByteArrayContent(CompressionHelper.GZipBytes(bytes));
                            actionExecutedContext.Response.Content.Headers.Add("Content-Encoding", "gzip");
                            break;
                        case "deflate":
                            actionExecutedContext.Response.Content = new ByteArrayContent(CompressionHelper.DeflateBytes(bytes));
                            actionExecutedContext.Response.Content.Headers.Add("Content-encoding", "deflate");
                            break;
                    }
                }
            }

            #endregion

            //只要使用了CompressionAttribute，则默认使用GZIP压缩
            var bytes = content.ReadAsByteArrayAsync().Result;
            actionExecutedContext.Response.Content = new ByteArrayContent(CompressionHelper.GZipBytes(bytes));
            actionExecutedContext.Response.Content.Headers.Add("Content-Encoding", "gzip");

            base.OnActionExecuted(actionExecutedContext);
        }
    }
    /// 

    /// 压缩帮助类
    /// 
    internal static class CompressionHelper
    {
        public static byte[] DeflateBytes(byte[] bytes)
        {
            if (bytes == null || bytes.Length == 0)
            {
                return null;
            }
            using (var output = new MemoryStream())
            {
                using (var compressor = new DeflateStream(output, CompressionMode.Compress, false))
                {
                    compressor.Write(bytes, 0, bytes.Length);
                }
                return output.ToArray();
            }
        }

        public static byte[] GZipBytes(byte[] bytes)
        {
            if (bytes == null || bytes.Length == 0)
            {
                return null;
            }
            using (var output = new MemoryStream())
            {
                using (var compressor = new GZipStream(output, CompressionMode.Compress, false))
                {
                    compressor.Write(bytes, 0, bytes.Length);
                }
                return output.ToArray();
            }
        }
    }

 5.RequestAuthenticationHandler （验证请求合法性处理管道（包含请求内容解密），即：未正确登录则不能调API操作数据库）

    public class RequestAuthenticationHandler : DelegatingHandler
    {
        private const string rsaPrivateKey = "私钥字符串";
        protected async override System.Threading.Tasks.Task SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
        {
            try
            {
                //验证TOKEN
                HttpRequestHeaders headers = request.Headers;
                IEnumerable tokenHeaders = null;
                if (headers.TryGetValues("AccessToken", out tokenHeaders) && tokenHeaders.Any())
                {

                    string loginID = TokenVerification(tokenHeaders.ElementAt(0));

                    if (!string.IsNullOrEmpty(loginID))
                    {
                        var principal = new GenericPrincipal(new GenericIdentity(loginID, "token"), null);
                        Thread.CurrentPrincipal = principal;
                        if (HttpContext.Current != null)
                        {
                            HttpContext.Current.User = principal;
                        }
                    }
                }

                IEnumerable encryptHeaders=null;
                if (headers.TryGetValues("Encryption", out encryptHeaders) && encryptHeaders.Any())
                {
                    if (encryptHeaders.ElementAt(0) == "1")
                    {
                        //私钥解密请求体内容
                        var originContent = request.Content;
                        string requestData = await request.Content.ReadAsStringAsync();

                        string deContentStr = EncryptUtility.RSADecrypt(rsaPrivateKey, requestData);
                        request.Content = new StringContent(deContentStr);

                        request.Content.Headers.Clear();
                        foreach (var header in originContent.Headers)
                        {
                            request.Content.Headers.Add(header.Key, header.Value);
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                LogUitl.Error(ex, "Api.RequestAuthenticationHandler");
            }

            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);

            return response;
        }

        private string TokenVerification(string token)
        {
            if (string.IsNullOrEmpty(token))
            {
                return null;
            }

            string loginID = null;
            if (HttpRuntime.Cache[Constants.CacheKey_SessionTokenPrefix + token] == null) //如果过期，则尝试从DB中恢复授权状态
            {
                using (var da = BaseUtil.CreateDataAccess())
                {
                    //loginID = 根据Token获取登录用户ID逻辑
                    if (!string.IsNullOrEmpty(loginID))
                    {
                        HttpRuntime.Cache.Insert(Constants.CacheKey_SessionTokenPrefix + token, loginID, null, Cache.NoAbsoluteExpiration, TimeSpan.FromHours(1));
                    }
                }
            }
            else
            {
                loginID = HttpRuntime.Cache[Constants.CacheKey_SessionTokenPrefix + token].ToNotNullString();
            }

            return loginID;

        }

    }

 6.HandleExceptionFilterAttribute（全局异常处理过滤器，只要某个ACTION发生异常就会报被该过滤器捕获并处理）

    /// 

    /// 统一全局异常过滤处理
    /// 
    public class HandleExceptionFilterAttribute : ExceptionFilterAttribute
    {
        public override void OnException(HttpActionExecutedContext actionExecutedContext)
        {
            string ctrllerName = actionExecutedContext.ActionContext.ControllerContext.ControllerDescriptor.ControllerName;
            string actionName = actionExecutedContext.ActionContext.ActionDescriptor.ActionName;
            string sqlCmd = null;
            if (actionExecutedContext.ActionContext.ActionArguments.ContainsKey("sqlCmd"))
            {
                sqlCmd = BaseUtil.SerializeToJson(actionExecutedContext.ActionContext.ActionArguments["sqlCmd"] as SqlCmdInfo);
            }

            //记录到日志表中
            LogUitl.Error(actionExecutedContext.Exception.Message, "Api.HandleExceptionFilterAttribute",
                            string.Format("SqlCmdInfo:{0};StackTrace:{1}", sqlCmd, actionExecutedContext.Exception.StackTrace));

            var errResult = new ApiResultInfo(false, sqlCmd, actionName + "Err", actionExecutedContext.Exception.Message);
            errResult.ExtendedData["StackTrace"] = actionExecutedContext.Exception.StackTrace;

            actionExecutedContext.Response = actionExecutedContext.ActionContext.Request.CreateResponse(HttpStatusCode.OK, errResult, "application/json");

        }
    }

7.ApiResultInfo（API返回结果实体类）

    [Serializable]
    public class ApiResultInfo
    {
        public bool Stauts { get; set; }

        public object Data { get; set; }

        public string ErrCode { get; set; }

        public string ErrMsg { get; set; }

        public Dictionary ExtendedData { get; set; }


        public ApiResultInfo()
        {
            this.ExtendedData = new Dictionary();
        }


        public ApiResultInfo(bool status, object data = null, string errCode = null, string errMsg = null, Dictionary extData = null)
        {
            this.Stauts = status;
            this.Data = data;
            this.ErrCode = errCode;
            this.ErrMsg = errMsg;
            this.ExtendedData = extData;
            if (this.ExtendedData == null)
            {
                this.ExtendedData = new Dictionary();
            }
        }

        /// 

        /// 构建成功结果对象
        /// 
        /// 
        /// 
        /// 
        public static ApiResultInfo BuildOKResult(object data = null, Dictionary extData = null)
        {
            return new ApiResultInfo(true, data, extData: extData);
        }

        /// 

        /// 构建错误结果对象
        /// 
        /// 
        /// 
        /// 
        /// 
        public static ApiResultInfo BuildErrResult(string errCode = null, string errMsg = null, Dictionary extData = null)
        {
            return new ApiResultInfo(false, errCode: errCode, errMsg: errMsg, extData: extData);
        }
    }

 8.非对称加解密算法（允许客户端请求时进行公钥加密请求内容，然后服务端API中通过RequestAuthenticationHandler自定义验证管道解密请求内容） 

        /// 

        /// 生成公钥及私钥对
        /// 
        /// 
        /// 
        public static void GeneratePublicAndPrivateKey(out string publickey, out string privatekey)
        {
            RSACryptoServiceProvider crypt = new RSACryptoServiceProvider();
            publickey = crypt.ToXmlString(false);//公钥
            privatekey = crypt.ToXmlString(true);//私钥
        }


        /// 

        /// 分段使用公钥加密
        /// 
        /// 
        /// 
        /// 
        public static string RSAEncrypt(string publicKey, string rawInput)
        {
            if (string.IsNullOrEmpty(rawInput))
            {
                return string.Empty;
            }

            if (string.IsNullOrWhiteSpace(publicKey))
            {
                throw new ArgumentException("Invalid Public Key");
            }

            using (var rsaProvider = new RSACryptoServiceProvider())
            {
                var inputBytes = Encoding.UTF8.GetBytes(rawInput);//有含义的字符串转化为字节流
                rsaProvider.FromXmlString(publicKey);//载入公钥
                int bufferSize = (rsaProvider.KeySize / 8) - 11;//单块最大长度
                var buffer = new byte[bufferSize];
                using (MemoryStream inputStream = new MemoryStream(inputBytes),
                     outputStream = new MemoryStream())
                {
                    while (true)
                    { //分段加密
                        int readSize = inputStream.Read(buffer, 0, bufferSize);
                        if (readSize <= 0)
                        {
                            break;
                        }

                        var temp = new byte[readSize];
                        Array.Copy(buffer, 0, temp, 0, readSize);
                        var encryptedBytes = rsaProvider.Encrypt(temp, false);
                        outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);
                    }
                    return Convert.ToBase64String(outputStream.ToArray());//转化为字节流方便传输
                }
            }
        }


        /// 

        /// 分段使用私钥解密
        /// 
        /// 
        /// 
        /// 
        public static string RSADecrypt(string privateKey, string encryptedInput)
        {
            if (string.IsNullOrEmpty(encryptedInput))
            {
                return string.Empty;
            }

            if (string.IsNullOrWhiteSpace(privateKey))
            {
                throw new ArgumentException("Invalid Private Key");
            }

            using (var rsaProvider = new RSACryptoServiceProvider())
            {
                var inputBytes = Convert.FromBase64String(encryptedInput);
                rsaProvider.FromXmlString(privateKey);
                int bufferSize = rsaProvider.KeySize / 8;
                var buffer = new byte[bufferSize];
                using (MemoryStream inputStream = new MemoryStream(inputBytes),
                     outputStream = new MemoryStream())
                {
                    while (true)
                    {
                        int readSize = inputStream.Read(buffer, 0, bufferSize);
                        if (readSize <= 0)
                        {
                            break;
                        }

                        var temp = new byte[readSize];
                        Array.Copy(buffer, 0, temp, 0, readSize);
                        var rawBytes = rsaProvider.Decrypt(temp, false);
                        outputStream.Write(rawBytes, 0, rawBytes.Length);
                    }
                    return Encoding.UTF8.GetString(outputStream.ToArray());
                }
            }
        }

9.LogUitl（基于NLOG.MONGO组件简单封装实现MONGODB日志功能）--后期有机会再单独讲MONGODB的相关知识 

    public static class LogUitl
    {
        private static NLog.Logger _Logger = null;
        private const string cacheKey_NLogConfigFlag = "NLogConfigFlag";
        private static Logger GetLogger()
        {
            if (_Logger == null || HttpRuntime.Cache[cacheKey_NLogConfigFlag] == null)
            {
                LoggingConfiguration config = new LoggingConfiguration();

                string connSetStr = ConfigUtility.GetAppSettingValue("MongoDbConnectionSet");

                MongoTarget mongoTarget = new MongoTarget();
                mongoTarget.ConnectionString = EncryptUtility.Decrypt(connSetStr);
                mongoTarget.DatabaseName = "KYELog";
                mongoTarget.CollectionName = "KYCallCenterLog";
                mongoTarget.IncludeDefaults = false;
                AppendLogMongoFields(mongoTarget.Fields);

                LoggingRule rule1 = new LoggingRule("*", LogLevel.Debug, mongoTarget);
                config.LoggingRules.Add(rule1);
                LogManager.Configuration = config;

                _Logger = LogManager.GetCurrentClassLogger();

                HttpRuntime.Cache.Insert(cacheKey_NLogConfigFlag, "Nlog", new System.Web.Caching.CacheDependency(HttpContext.Current.Server.MapPath("~/Web.config")));
            }

            return _Logger;

        }

        private static void AppendLogMongoFields(IList mongoFields)
        {
            mongoFields.Clear();
            Type logPropertiesType = typeof(SysLogInfo.LogProperties);
            foreach (var pro in typeof(SysLogInfo).GetProperties(BindingFlags.Public | BindingFlags.Instance))
            {
                if (pro.PropertyType == logPropertiesType) continue;

                string layoutStr = string.Empty; //"${event-context:item=" + pro.Name + "}";
                if (pro.Name.Equals("ThreadID") || pro.Name.Equals("Level") || pro.Name.Equals("MachineName"))
                {
                    layoutStr = "${" + pro.Name.ToLower() + "}";
                }
                else if (pro.Name.Equals("LogDT"))
                {
                    layoutStr = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}";
                }
                else if (pro.Name.Equals("Msg"))
                {
                    layoutStr = "${message}";
                }

                if (!string.IsNullOrEmpty(layoutStr))
                {
                    mongoFields.Add(new MongoField(pro.Name, layoutStr, pro.PropertyType.Name));
                }
            }
        }


        private static LogEventInfo BuildLogEventInfo(LogLevel level, string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)
        {
            var eventInfo = new LogEventInfo();
            eventInfo.Level = level;
            eventInfo.Message = msg;
            eventInfo.Properties["DetailTrace"] = detailTrace ?? string.Empty;
            eventInfo.Properties["Source"] = source ?? string.Empty;
            eventInfo.Properties["Other1"] = other1 ?? string.Empty;
            eventInfo.Properties["Other2"] = other2 ?? string.Empty;
            eventInfo.Properties["Other3"] = other3 ?? string.Empty;

            string uid = string.Empty;
            if (HttpContext.Current.User != null)
            {
                uid = HttpContext.Current.User.Identity.Name;
            }
            eventInfo.Properties["UserID"] = uid;

            return eventInfo;
        }

        public static void Info(string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)
        {
            try
            {
                var eventInfo = BuildLogEventInfo(LogLevel.Info, msg, source, detailTrace, other1, other2, other3);
                var logger = GetLogger();
                logger.Log(eventInfo);
            }
            catch
            { }
        }

        public static void Warn(string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)
        {
            try
            {
                var eventInfo = BuildLogEventInfo(LogLevel.Warn, msg, source, detailTrace, other1, other2, other3);

                var logger = GetLogger();
                logger.Log(eventInfo);
            }
            catch
            { }
        }


        public static void Error(string msg, string source, string detailTrace = null, string other1 = null, string other2 = null, string other3 = null)
        {
            try
            {
                var eventInfo = BuildLogEventInfo(LogLevel.Error, msg, source, detailTrace, other1, other2, other3);

                var logger = GetLogger();
                logger.Log(eventInfo);
            }
            catch
            { }
        }

        public static void Error(Exception ex, string source, string other1 = null, string other2 = null, string other3 = null)
        {
            try
            {
                var eventInfo = BuildLogEventInfo(LogLevel.Error, ex.Message, source, ex.StackTrace, other1, other2, other3);

                var logger = GetLogger();
                logger.Log(eventInfo);
            }
            catch
            { }
        }


    }



    public class SysLogInfo
    {
        public DateTime LogDT { get; set; }

        public int ThreadID { get; set; }

        public string Level { get; set; }

        public string Msg { get; set; }

        public string MachineName { get; set; }

        public LogProperties Properties { get; set; }

        public class LogProperties
        {
            public string Source { get; set; }

            public string DetailTrace { get; set; }

            public string UserID { get; set; }

            public string Other1 { get; set; }

            public string Other2 { get; set; }

            public string Other3 { get; set; }
        }



    }

 

10.其它一些用到的公共实用方法

//BaseUtil:
        public static DataAccess CreateDataAccess(string connName = "DefaultConnectionString")
        {
            return new DataAccess(connName, EncryptUtility.Decrypt);
        }

        public static string SerializeToJson(object obj)
        {
            return JsonConvert.SerializeObject(obj);
        }

        public static JObject DeserializeObject(string json)
        {
            return JObject.Parse(json);
        }

        public static T DeserializeObject(string json)
        {
            return JsonConvert.DeserializeObject(json);
        }

//=====================================

    /// 

    /// 类型扩展方法集合
    /// 
    public static class TypeExtension
    {
        /// 

        /// 转换为不为空的字符串（即：若为空，则返回为空字符串，而不是Null）
        /// 
        /// 
        /// 
        public static string ToNotNullString(this object obj)
        {
            if (obj == null || obj == DBNull.Value)
            {
                return string.Empty;
            }
            return obj.ToString();
        }



        /// 

        /// 判断列表中是否存在项
        /// 
        /// 
        /// 
        public static bool HasItem(this IEnumerable