ZhiYeJianKang_PeiXun/cyqdata-master/Action/AppConfig.cs

1694 lines
57 KiB
C#
Raw Permalink Normal View History

2025-02-20 15:41:53 +08:00
using System;
using System.Configuration;
using CYQ.Data.SQL;
using CYQ.Data.Tool;
using System.Web;
using System.Collections.Generic;
using System.Threading;
using System.IO;
using System.Reflection;
using System.Security.Cryptography;
using System.Diagnostics;
using CYQ.Data.Cache;
using CYQ.Data.Aop;
namespace CYQ.Data
{
/// <summary>
/// 常用配置文件项[Web(App).Config]的[appSettings|connectionStrings]项和属性名一致。
/// 除了可以从配置文件配置,也可以直接赋值。
/// </summary>
public static partial class AppConfig
{
//public delegate void OnAppChange(string key, string value);
//public delegate void OnConnChange(string name, string connectionString);
///// <summary>
///// SetApp 方法事件监听
///// </summary>
//public static event OnAppChange OnAppChangeEvent;
///// <summary>
///// SetConn 方法事件监听
///// </summary>
//public static event OnConnChange OnConnChangeEvent;
static AppConfig()
{
//这个比较常用,只好把这里当成应用程序入口最早的调用处
DBSchema.InitDBSchemasOnStart();
}
#region
private static MDictionary<string, string> appConfigs = new MDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
private static MDictionary<string, string> connConfigs = new MDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
//internal static void Clear()
//{
// appConfigs.Clear();
// connConfigs.Clear();
//}
/// <summary>
/// 设置Web.config或App.config的值 value为null时移除缓存。
/// </summary>
public static bool SetApp(string key, string value)
{
if (string.IsNullOrEmpty(key)) { return false; }
//if (OnAppChangeEvent != null) { OnAppChangeEvent(key, value); }
if (value == null)
{
return appConfigs.Remove(key);
}
if (appConfigs.ContainsKey(key))
{
appConfigs[key] = value;
}
else
{
appConfigs.Add(key, value);
}
return true;
}
/// <summary>
/// 获取Web.config或App.config的值。
/// </summary>
public static string GetApp(string key)
{
return GetApp(key, string.Empty);
}
/// <summary>
/// 获取Web.config或App.config的值允许值不存在或为空时输出默认值
/// </summary>
public static string GetApp(string key, string defaultValue)
{
// 注释以下代码:读取时,配置面不写入缓存字典【修改配置文件不重置通过代码设置的配置项。】
if (string.IsNullOrEmpty(key)) { return defaultValue; }
var appSettings = ConfigurationManager.AppSettings;
string[] items = key.Split(',');
foreach (string item in items)
{
if (appConfigs.ContainsKey(item))
{
return appConfigs[item];
}
string value = appSettings[item];
if (string.IsNullOrEmpty(value))
{
if (item.IndexOf('.') > 0)
{
value = appSettings[item.Replace(".", "")];
if (string.IsNullOrEmpty(value))
{
value = appSettings[item.Substring(item.IndexOf('.') + 1)];
}
}
if (string.IsNullOrEmpty(value) && IsNetCore)
{
value = Convert.ToString(ConfigurationManager.GetSection(item));
}
}
if (!string.IsNullOrEmpty(value))
{
return value;
}
}
return defaultValue;
}
/// <summary>
/// 获取Web.config或App.config的数字值允许值不存在或为空时输出默认值
/// </summary>
public static int GetAppInt(string key, int defaultValue)
{
int result = 0;
string value = GetApp(key);
if (!int.TryParse(value, out result))
{
return defaultValue;
}
return result;
}
/// <summary>
/// 获取Web.config或App.config的数字值允许值不存在或为空时输出默认值
/// </summary>
public static bool GetAppBool(string key, bool defaultValue)
{
return ConvertTool.ChangeType<bool>(GetApp(key, defaultValue.ToString()));
}
/// <summary>
/// 获取Web.config或App.config的数字值允许值不存在或为空时输出默认值
/// </summary>
public static T GetApp<T>(string key, T defaultValue)
{
return ConvertTool.ChangeType<T>(GetApp(key, defaultValue.ToString()));
}
/// <summary>
/// 获取Web.config或App.config的connectionStrings节点的值。
/// </summary>
public static string GetConn(string name)
{
if (string.IsNullOrEmpty(name))
{
name = DB.DefaultConn;
}
if (name.Trim().Contains(" "))
{
return name;
}
if (connConfigs.ContainsKey(name))
{
return connConfigs[name];
}
ConnectionStringSettings conn = ConfigurationManager.ConnectionStrings[name];
if (conn == null)
{
if (name.IndexOf('.') > 0)
{
conn = ConfigurationManager.ConnectionStrings[name.Replace(".", "")];
}
}
if (conn != null)
{
string connString = conn.ConnectionString;
if (name == connString || string.IsNullOrEmpty(connString))//避免误写自己造成死循环。
{
return name;
}
if (connString.EndsWith(".txt") || connString.EndsWith(".ini") || connString.EndsWith(".json"))
{
return ConnConfigWatch.Start(name, connString);
}
//允许配置文件里加密。
if (connString.Length > 32 && connString.Split(';', '=', ' ').Length == 1)
{
connString = EncryptHelper.Decrypt(connString);
}
//启动高可用配置加载方式
if (connString.Length < 32 && connString.Split(' ').Length == 1)
{
return GetConn(connString);
}
// 注释以下代码:读取时,配置面不写入缓存字典【修改配置文件不重置通过代码设置的配置项。】
//if (!connConfigs.ContainsKey(name))
//{
// connConfigs.Add(name, connString);
//}
return connString;
}
if (name.Length > 32 && name.Split('=').Length > 3 && name.Contains(";")) //链接字符串很长,没空格的情况 txt path={0}
{
return name;
}
if (name == "Conn" && name != DB.DefaultConn)
{
return GetConn(DB.DefaultConn);
}
return "";
}
/// <summary>
/// 添加自定义链接内存有效并未写入config文件 value为null时移除缓存
/// </summary>
/// <param name="name">名称</param>
/// <param name="connectionString">链接字符串</param>
public static bool SetConn(string name, string connectionString)
{
if (string.IsNullOrEmpty(name)) { return false; }
//if (OnConnChangeEvent != null) { OnConnChangeEvent(name, connectionString); }
if (connectionString == null)
{
return connConfigs.Remove(name);
}
if (!connConfigs.ContainsKey(name))
{
connConfigs.Add(name, connectionString);
}
else
{
connConfigs[name] = connectionString;
}
return true;
}
#endregion
/// <summary>
/// Aop 插件配置项 示例配置:[ 完整类名,程序集(dll)名称]&lt;add key="Aop" value="Web.Aop.AopAction,Aop"/>
/// </summary>
public static string Aop
{
get
{
return GetApp("Aop");
}
set
{
SetApp("Aop", value);
}
}
}
public static partial class AppConfig
{
#region
/// <summary>
/// 工具类相关配置
/// </summary>
public static class Tool
{
/// <summary>
/// EncryptHelper加密的Key。
/// </summary>
public static string EncryptKey
{
get
{
return GetApp("Tool.EncryptKey", "");
}
set
{
SetApp("Tool.EncryptKey", value);
}
}
/// <summary>
/// Tool.ThreadBreak 使用时外置的文件配置相对路径默认在环境变量Temp对应文件中
/// </summary>
public static string ThreadBreakPath
{
get
{
return GetApp("Tool.ThreadBreakPath", Environment.GetEnvironmentVariable("TEMP", EnvironmentVariableTarget.User));
}
set
{
SetApp("Tool.ThreadBreakPath", value);
}
}
}
#endregion
#region
/// <summary>
/// 通用缓存配置
/// </summary>
public static class Cache
{
/// <summary>
/// 默认缓存的时间[分钟(默认60)]
/// 配置Cache.DefaultMinutes = 60
/// </summary>
public static int DefaultMinutes
{
get
{
return GetAppInt("Cache.DefaultMinutes", 60);
}
set
{
SetApp("Cache.DefaultMinutes", value.ToString());
}
}
}
#endregion
#region Xml相关配置
/// <summary>
/// XHtml 相关的配置
/// </summary>
public static class XHtml
{
/// <summary>
/// Xml.XHtmlHelper 中使用的 "&lt;![CDATA[" 项
/// </summary>
internal static string CDataLeft
{
get
{
return GetApp("CDataLeft", "<![CDATA[");
}
set
{
SetApp("CDataLeft", value);
}
}
/// <summary>
/// Xml.XHtmlHelper 中使用的 "]]&gt;" 项
/// </summary>
internal static string CDataRight
{
get
{
return GetApp("CDataRight", "]]>");
}
set
{
SetApp("CDataRight", value);
}
}
/// <summary>
/// Xml.XHtmlHelper 中操作Html需要配置的DTD解析文档相对路径
/// </summary>
public static string DtdUri
{
get
{
string dtdUri = GetApp("XHtml.DtdUri", (IsWeb ? "/App_Data/dtd/" : "/Setting/DTD/") + "xhtml1-transitional.dtd");
if (dtdUri != null && dtdUri.IndexOf("http://") == -1)//相对路径
{
dtdUri = AppConfig.WebRootPath + dtdUri.TrimStart('/');//.Replace("/", "\\");
if (!dtdUri.StartsWith("/") && dtdUri.Contains(":\\"))
{
dtdUri = dtdUri.Replace("/", "\\");
}
}
return dtdUri;
}
set
{
SetApp("XHtml.DtdUri", value);
}
}
private static string _Domain;
/// <summary>
/// Xml.MutilLanguage 语言切换设置时Cookie所需要的网站主域名[不带www]
/// </summary>
public static string Domain
{
get
{
if (string.IsNullOrEmpty(_Domain))
{
Uri uri = AppConfig.WebUri;
string domainList = GetApp("XHtml.Domain", "");
if (!string.IsNullOrEmpty(domainList))
{
string[] domains = domainList.Split(',');
if (domains != null && domains.Length > 0)
{
if (domains.Length > 1 && uri != null)
{
foreach (string domain in domains)
{
if (uri.Authority.Contains(domain))
{
_Domain = domain;
break;
}
}
}
if (string.IsNullOrEmpty(_Domain))
{
_Domain = domains[0];
}
}
}
else
{
if (uri != null && uri.Host != "localhost" && uri.Host != "127.0.0.1")
{
_Domain = uri.Host.Replace("www.", string.Empty);
}
}
}
return _Domain;
}
set
{
_Domain = string.Empty;
SetApp("XHtml.Domain", value);
}
}
//private static int _UserFileLoadXml = -1;
///// <summary>
///// Xml.XHtmlHelper 操作Html时配置此项使用File加载Xml[便可在IIS7以上非信任主机机制下使用]
///// </summary>
//public static bool UseFileLoadXml
//{
// get
// {
// if (_UserFileLoadXml == -1)
// {
// _UserFileLoadXml = GetApp("UseFileLoadXml") == "true" ? 1 : 0;
// }
// return _UserFileLoadXml == 1;
// }
// set
// {
// _UserFileLoadXml = value ? 1 : 0;
// }
//}
/// <summary>
/// Xml.MutilLanguage 类的默认语言Key默认值Chinese
/// </summary>
public static string SysLangKey
{
get
{
return GetApp("XHtml.SysLangKey", "Chinese");
}
set
{
SetApp("XHtml.SysLangKey", value);
}
}
}
#endregion
#region
/// <summary>
/// DataBase 相关的配置
/// </summary>
public static class DB
{
static string _DefaultConn = string.Empty;
/// <summary>
/// 默认数据库链接可赋完整链接语句或Web.config配置项名称
/// 如果不在配置文件(Web.Config上配置Conn链接可对此属性赋值进行配置。
/// </summary>
public static string DefaultConn
{
get
{
if (string.IsNullOrEmpty(_DefaultConn))
{
_DefaultConn = "Conn";
if (ConfigurationManager.ConnectionStrings != null && ConfigurationManager.ConnectionStrings[_DefaultConn] == null)
{
foreach (ConnectionStringSettings item in ConfigurationManager.ConnectionStrings)
{
if (item.Name.ToLower().EndsWith("conn"))
{
_DefaultConn = item.Name;
break;
}
}
}
}
return _DefaultConn;
}
set
{
if (value == null)
{
value = string.Empty;
}
ConnObject.Remove("Conn");//移除原有配置文件的Conn项的链接缓存。
ConnBean.Remove("Conn");
_DefaultConn = value;
SetConn("Conn", value);
}
}
/*
static string _DefaultConnBak = string.Empty;
/// <summary>
/// 默认备用数据库链接(当主数据挂掉时,会自动切换到备用数据库链接)
/// 如果不在配置文件(Web.Config上配置Conn_Bak链接可对此属性赋值进行配置。
/// </summary>
public static string DefaultConnBak
{
get
{
if (_DefaultConnBak == string.Empty && _DefaultConn.Length < 32 && _DefaultConn.Split(' ').Length == 1)
{
return _DefaultConn + "_Bak";
}
return _DefaultConnBak;
}
set
{
_DefaultConnBak = value;
}
}
*/
private static string _DefaultDataBaseName;
/// <summary>
/// 默认数据库名称(只读)
/// </summary>
public static string DefaultDataBaseName
{
get
{
if (string.IsNullOrEmpty(_DefaultDataBaseName))
{
SetDefault();
}
return _DefaultDataBaseName;
}
}
private static DataBaseType _DefaultDataBaseType = DataBaseType.None;
/// <summary>
/// 默认数据库类型(只读)
/// </summary>
public static DataBaseType DefaultDataBaseType
{
get
{
if (_DefaultDataBaseType == DataBaseType.None)
{
SetDefault();
}
return _DefaultDataBaseType;
}
}
private static void SetDefault()
{
DalBase db = DalCreate.CreateDal(DefaultConn);
if (db != null)
{
_DefaultDataBaseName = db.DataBaseName;
_DefaultDataBaseType = db.DataBaseType;
db.Dispose();
}
}
///// <summary>
///// MSSQL是否启用分页存储过程SelectBase默认false
///// </summary>
//public static bool PagerBySelectBase
//{
// get
// {
// return GetAppBool("PagerBySelectBase", false);
// }
// set
// {
// SetApp("PagerBySelectBase", value.ToString());
// }
//}
/// <summary>
/// 配置此项时,会对:插入/更新/删除的操作进行Lock[请适当使用]
/// </summary>
//public static bool LockOnDbExe
//{
// get
// {
// bool _LockOnDbExe;
// bool.TryParse(GetApp("LockOnDbExe"), out _LockOnDbExe);
// return _LockOnDbExe;
// }
// set
// {
// SetApp("LockOnDbExe", value.ToString());
// }
//}
/// <summary>
/// 文本数据库是否只读用于Demo演示避免演示账号或数据被删除
/// 配置项DB.IsTxtReadOnly false
/// </summary>
public static bool IsTxtReadOnly
{
get
{
return GetAppBool("DB.IsTxtReadOnly", false);
}
set
{
SetApp("DB.IsTxtReadOnly", value.ToString());
}
}
/// <summary>
/// Postgre 是否小写模式(默认true)。
/// 配置项DB.IsPostgreLower true
/// </summary>
public static bool IsPostgreLower
{
get
{
return GetAppBool("DB.IsPostgreLower", true);
}
set
{
SetApp("DB.IsPostgreLower", value.ToString());
}
}
/// <summary>
/// KingBaseES 是否小写模式(默认true)。
/// 配置项DB.IsKingBaseESLower true
/// </summary>
public static bool IsKingBaseESLower
{
get
{
return GetAppBool("DB.IsKingBaseESLower", true);
}
set
{
SetApp("DB.IsKingBaseESLower", value.ToString());
}
}
/// <summary>
/// Oracle 是否大写模式(默认true)。
/// 配置项DB.IsOracleUpper true
/// </summary>
public static bool IsOracleUpper
{
get
{
return GetAppBool("DB.IsOracleUpper", true);
}
set
{
SetApp("DB.IsOracleUpper", value.ToString());
}
}
/// <summary>
/// DB2 是否大写模式(默认true)。
/// 配置项DB.IsDB2Upper true
/// </summary>
public static bool IsDB2Upper
{
get
{
return GetAppBool("DB.IsDB2Upper", true);
}
set
{
SetApp("DB.IsDB2Upper", value.ToString());
}
}
/// <summary>
/// Firebird 是否大写模式(默认true)。
/// 配置项DB.IsFireBirdUpper true
/// </summary>
public static bool IsFireBirdUpper
{
get
{
return GetAppBool("DB.IsFireBirdUpper", true);
}
set
{
SetApp("DB.IsFireBirdUpper", value.ToString());
}
}
/// <summary>
/// DaMeng 是否大写模式(默认true)。
/// 配置项DB.IsDaMengUpper true
/// </summary>
public static bool IsDaMengUpper
{
get
{
return GetAppBool("DB.IsDaMengUpper", true);
}
set
{
SetApp("DB.IsDaMengUpper", value.ToString());
}
}
/// <summary>
/// MAction所有操作中的where条件默认有超强的过滤单词来过滤Sql注入关键字如果语句包含指定的过滤词则会返回错误信息并记录日志。
/// 如果需要自定义关键字可配置此项“delete;from,truncate其它单词”分号表词组需要同时包含两个词 多个过滤词组以","逗号分隔
/// 配置项DB.FilterSqlInjection
/// </summary>
public static string FilterSqlInjection
{
get
{
return GetApp("DB.FilterSqlInjection", SqlInjection.filterSqlInjection);
}
set
{
SetApp("DB.ilterSqlInjection", value);
if (!string.IsNullOrEmpty(value))
{
List<string> list = new List<string>();
list.AddRange(value.TrimEnd(',').Split(','));
SqlInjection.FilterKeyList = list;
}
}
}
/*
/// <summary>
/// MAction所有操作中的where条件会被替换为空的字符默认为“--“。
/// 如果需要自定义,可配置此项,如:“--,;“ 多个替换符号以逗号分隔
/// </summary>
public static string ReplaceSqlInjection
{
get
{
return GetApp("ReplaceSqlInjection", SqlInjection.replaceSqlInjection);
}
set
{
SetApp("ReplaceSqlInjection", value);
}
}
*/
/// <summary>
/// MAction 操作 Oracle 时自增加int类型id所需要配置的序列idGuid为id则不用。
/// 如果需要为每个表都配置一个序列号可以使用SEQ_{0} 其中{0}会自动配对成表名,如果没有{0},则为整个数据库共用一个序列。
/// 配置项DB.AutoID SEQ_{0}
/// </summary>
public static string AutoID
{
get
{
return GetApp("DB.AutoID", "SEQ_{0}");
}
set
{
SetApp("DB.AutoID", value);
}
}
/// <summary>
/// MAction 可将表架构映射到外部指定相对路径[外部存储,可避开数据库读取]
/// 配置项DB.SchemaMapPath /App_Data/schema
/// </summary>
public static string SchemaMapPath
{
get
{
return GetApp("DB.SchemaMapPath", (IsWeb && !IsDebugMode) ? "/App_Data/schema" : "");
}
set
{
SetApp("DB.SchemaMapPath", value);
}
}
/// <summary>
/// 软删除字段名称若表存在此设置的字段名称时MActon的删除操作将变更变为更新操作
/// 配置项DB.DeleteField IsDeleted
/// </summary>
public static string DeleteField
{
get
{
return GetApp("DB.DeleteField", "IsDeleted");
}
set
{
SetApp("DB.DeleteField", value);
}
}
/// <summary>
/// 更新时间字段名称(若表存在指定字段名称时,自动更新时间,多个用逗号分隔)
/// 配置项DB.EditTimeFields
/// </summary>
public static string EditTimeFields
{
get
{
return GetApp("DB.EditTimeFields", string.Empty);
}
set
{
SetApp("DB.EditTimeFields", value);
}
}
/// <summary>
/// 系统全局要隐藏的字段名称(默认值为:"cyqrownum,rowguid,deletefield"
/// 配置项DB.HiddenFields cyqrownum,rowguid
/// </summary>
public static string HiddenFields
{
get
{
string result = GetApp("DB.HiddenFields", "cyqrownum,rowguid");
//if (result == string.Empty)
//{
// result = "cyqrownum,rowguid," + DeleteField;
//}
return result;
}
set
{
if (!value.Contains("cyqrownum,rowguid"))
{
value = "cyqrownum,rowguid," + value;
}
SetApp("DB.HiddenFields", value);
}
}
/// <summary>
/// 全局的数据库命令默认超时设置默认值120秒单位
/// 配置项DB.CommandTimeout 120
/// </summary>
public static int CommandTimeout
{
get
{
return GetAppInt("DB.CommandTimeout", 120);
}
set
{
SetApp("DB.CommandTimeout", value.ToString());
}
}
/// <summary>
/// 读写分离时用户对主数据库操作持续时间默认值10秒s单位秒s
/// 配置项DB.MasterSlaveTime 10
/// </summary>
public static int MasterSlaveTime
{
get
{
return GetAppInt("DB.MasterSlaveTime", 10);
}
set
{
SetApp("DB.MasterSlaveTime", value.ToString());
}
}
/// <summary>
/// 毫秒数(记录数据库执行时时长(ms)的SQL语句写入日志对应配置项Log.Path的配置路径
/// 配置项DB.PrintSql -1
/// </summary>
public static int PrintSql
{
get
{
return GetAppInt("DB.PrintSql", -1);
}
set
{
SetApp("DB.PrintSql", value.ToString());
}
}
/// <summary>
/// 生成的实体类的后缀。
/// 配置项DB.EntitySuffix Bean
/// </summary>
public static string EntitySuffix
{
get
{
return GetApp("DB.EntitySuffix", "Bean");
}
set
{
SetApp("DB.EntitySuffix", value);
}
}
/// <summary>
/// 是否使用表字段枚举转Int方式默认为false
/// 设置为true时可以加快一点性能但生成的表字段枚举必须和数据库一致。
/// 配置项DB.IsEnumToInt false
/// </summary>
public static bool IsEnumToInt
{
get
{
return GetAppBool("DB.IsEnumToInt", false);
}
set
{
SetApp("DB.IsEnumToInt", value.ToString());
}
}
}
#endregion
#region
/// <summary>
/// Redis 配置
/// </summary>
public static class Redis
{
/// <summary>
/// Redis分布式缓存的服务器配置多个用逗号,)分隔
/// 格式ip:port - password
/// 配置项Redis.Servers 192.168.1.9:6379 - 888888
/// </summary>
public static string Servers
{
get
{
return GetApp("Redis.Servers", string.Empty);
}
set
{
SetApp("Redis.Servers", value);
}
}
/// <summary>
/// Redis 使用的DB数默认1使用db0
/// 配置项Redis.UseDBCount 1
/// </summary>
public static int UseDBCount
{
get
{
return GetAppInt("Redis.UseDBCount", 1);
}
set
{
SetApp("Redis.UseDBCount", value.ToString());
}
}
/// <summary>
/// Redis 使用的DB 索引默认0若配置则会忽略RedisUseDBCount
/// 配置项Redis.UseDBIndex 0
/// </summary>
public static int UseDBIndex
{
get
{
return GetAppInt("Redis.UseDBIndex", 0);
}
set
{
SetApp("Redis.UseDBIndex", value.ToString());
}
}
/// <summary>
/// Redis 备份服务器(当主服务器挂了后,请求会转向备用机),多个用逗号(,)分隔
/// 格式ip:port - password
/// 配置项Redis.ServersBak 192.168.1.9:6379 - 888888
/// </summary>
//public static string ServersBak
//{
// get
// {
// return GetApp("Redis.ServersBak", string.Empty);
// }
// set
// {
// SetApp("Redis.ServersBak", value);
// }
//}
/// <summary>
/// Redis Socket 链接建立超时时间毫秒ms
/// 配置项Redis.Timeout 1000
/// </summary>
public static int Timeout
{
get
{
return GetAppInt("Redis.Timeout", 1000);
}
set
{
SetApp("Redis.Timeout", value.ToString());
}
}
/// <summary>
/// Redis 单个主机节点最大的链接数
/// 配置项Redis.MaxSocket 32
/// </summary>
public static int MaxSocket
{
get
{
return GetAppInt("Redis.MaxSocket", 32);
}
set
{
SetApp("Redis.MaxSocket", value.ToString());
}
}
/// <summary>
/// Redis 超出最大链接数后等等时间ms毫秒)
/// 配置项Redis.MaxWait 1000
/// </summary>
public static int MaxWait
{
get
{
return GetAppInt("Redis.MaxWait", 1000);
}
set
{
SetApp("Redis.MaxWait", value.ToString());
}
}
}
/// <summary>
/// MemCache 配置
/// </summary>
public static class MemCache
{
/// <summary>
/// MemCache分布式缓存的服务器配置多个用逗号,)分隔
/// 格式ip:port
/// 配置项MemCache.Servers 192.168.1.9:12121
/// </summary>
public static string Servers
{
get
{
return GetApp("MemCache.Servers", string.Empty);
}
set
{
SetApp("MemCache.Servers", value);
}
}
/// <summary>
/// MemCache 备份服务器(当主服务器挂了后,请求会转向备用机)
/// 格式ip:port
/// 配置项MemCache.ServersBak 192.168.1.9:12121
/// </summary>
//public static string ServersBak
//{
// get
// {
// return GetApp("MemCache.ServersBak", string.Empty);
// }
// set
// {
// SetApp("MemCache.ServersBak", value);
// }
//}
/// <summary>
/// MemCache Socket 链接建立超时时间毫秒ms
/// 配置项MemCache.Timeout 1000
/// </summary>
public static int Timeout
{
get
{
return GetAppInt("MemCache.Timeout", 1000);
}
set
{
SetApp("MemCache.Timeout", value.ToString());
}
}
/// <summary>
/// MemCache 单个主机节点最大的链接数
/// 配置项MemCache.MaxSocket 32
/// </summary>
public static int MaxSocket
{
get
{
return GetAppInt("MemCache.MaxSocket", 32);
}
set
{
SetApp("MemCache.MaxSocket", value.ToString());
}
}
/// <summary>
/// MemCache 超出最大链接数后等等时间ms毫秒)
/// 配置项MemCache.MaxWait 1000
/// </summary>
public static int MaxWait
{
get
{
return GetAppInt("MemCache.MaxWait", 1000);
}
set
{
SetApp("MemCache.MaxWait", value.ToString());
}
}
}
#endregion
#region
/// <summary>
/// 自动缓存【即AopCache】相关的配置
/// </summary>
public static class AutoCache
{
/// <summary>
/// 是否启用智能自动缓存数据(默认开启)
/// 配置项AutoCache.IsEnable true
/// </summary>
public static bool IsEnable
{
get
{
string value = GetApp("AutoCache.IsEnable");
if (!string.IsNullOrEmpty(value))
{
bool result;
bool.TryParse(value, out result);
return result;
}
return GetAppBool("IsAutoCache", true);//兼容旧配置
}
set
{
SetApp("AutoCache.IsEnable", value.ToString());
}
}
/// <summary>
/// AutoCache开启时可以设置仅需要缓存的Table多个用逗号分隔此项配置时NoCacheTables配置则被无忽略
/// 配置项AutoCache.Tables users,user_vip
/// </summary>
public static string Tables
{
get
{
string value = GetApp("AutoCache.Tables");
if (!string.IsNullOrEmpty(value))
{
return value;
}
return GetApp("CacheTables", "");//兼容旧配置
}
set
{
SetApp("AutoCache.Tables", value);
}
}
/// <summary>
/// AutoCache开启时可以设置不缓存的Table多个用逗号分隔
/// 配置项AutoCache.IngoreTables logs,logs_temp
/// </summary>
public static string IngoreTables
{
get
{
string value = GetApp("AutoCache.IngoreTables");
if (!string.IsNullOrEmpty(value))
{
return value;
}
return GetApp("NoCacheTables", "");//兼容旧配置
}
set
{
SetApp("AutoCache.IngoreTables", value);
}
}
/// <summary>
/// AutoCache开启时可以设置不受更新影响的列名用Json格式。
/// 配置项AutoCache.IngoreColumns {user:'updatetime,createtime',tb2:'col1,2'}
/// </summary>
public static string IngoreColumns
{
get
{
string value = GetApp("AutoCache.IngoreColumns");
if (!string.IsNullOrEmpty(value))
{
return value;
}
return GetApp("IngoreCacheColumns", "");
}
set
{
SetApp("AutoCache.IngoreColumns", value);
AopCache.IngoreCacheColumns = null;
}
}
private static string _AutoCacheConn = null;
/// <summary>
/// CYQ.Data.Cache 自动缓存 - 数据库链接配置
/// 在多个不同的应用项目里操作同一个数据库时又不想使用分布式缓存MemCache或Redis可以开启此项达到缓存智能清除的效果。
/// 配置项AutoCacheConnserver=.;database=x;uid=s;pwd=p;
/// </summary>
public static string Conn
{
get
{
if (_AutoCacheConn == null)
{
_AutoCacheConn = AppConfig.GetConn("AutoCacheConn");
}
return _AutoCacheConn;
}
set
{
_AutoCacheConn = value;
}
}
/// <summary>
/// 当AutoCacheConn开启后定时扫描数据库的任务时间毫秒,默认1000
/// 配置项AutoCache.TaskTime1000
/// </summary>
public static int TaskTime
{
get
{
return GetAppInt("AutoCache.TaskTime", 1000);
}
set
{
SetApp("AutoCache.TaskTime", value.ToString());
}
}
/*
/// <summary>
/// Cache.CacheManage 内置线程-缓存的同步时间[(默认5)分钟同步一次]
/// </summary>
public static int CacheClearWorkTime
{
get
{
return GetAppInt("CacheClearWorkTime", 5);
}
set
{
SetApp("CacheClearWorkTime", value.ToString());
}
}
/// <summary>
/// Cache.CacheManage 内置线程-调用次数:[N(默认4)分钟内调用次数少于指定值(默认2),缓存即被清除]
/// </summary>
public static int CacheClearCallCount
{
get
{
return GetAppInt("CacheClearCallCount", 2);
}
set
{
SetApp("CacheClearCallCount", value.ToString());
}
}
/// <summary>
/// Cache.CacheManage 内置线程-时间设置:[N(默认4)分钟内调用次数少于指定值(默认2),缓存即被清除]
/// </summary>
public static int CacheClearTime
{
get
{
return GetAppInt("CacheClearTime", 4);
}
set
{
SetApp("CacheClearTime", value.ToString());
}
}
*/
}
#endregion
#region
/// <summary>
/// 日志类Log 相关的配置
/// </summary>
public static class Log
{
/// <summary>
/// 是否写数据库异常日志默认true:开启时:有异常不抛出,转写入数据库;不开启:有异常会抛出
/// 配置项Log.IsEnable true
/// </summary>
public static bool IsEnable
{
get
{
string value = GetApp("Log.IsEnable");
if (!string.IsNullOrEmpty(value))
{
bool result;
bool.TryParse(value, out result);
return result;
}
return GetAppBool("IsWriteLog", true);//兼容旧配置
}
set
{
SetApp("Log.IsEnable", value.ToString());
}
}
/// <summary>
/// CYQ.Data.Log 类记录数据库异常日志 - 数据库链接配置
/// 配置项LogConnserver=.;database=x;uid=s;pwd=p;
/// </summary>
public static string Conn
{
get
{
return GetConn("LogConn");
}
set
{
SetConn("LogConn", value);
}
}
/// <summary>
/// 文本日志的配置相对路径Web 默认为:/App_Data/log"
/// 配置项Log.Path /App_Data/log
/// </summary>
public static string Path
{
get
{
return GetApp("Log.Path", IsWeb ? "/App_Data/log" : "/Logs");
}
set
{
SetApp("Log.Path", value);
}
}
/// <summary>
/// 异常日志表名默认为SysLogs可配置
/// 配置项Log.TableName SysLogs
/// </summary>
public static string TableName
{
get
{
return GetApp("Log.TableName", "SysLogs");
}
set
{
SetApp("Log.TableName", value);
}
}
}
#endregion
#region
/// <summary>
/// 调试类AppDebug 相关的配置
/// </summary>
public class Debug
{
#region
/// <summary>
/// 开启信息调试记录开启后MAction.DebugInfo可输出执行日志。
/// 同时AppDebug若要使用也需要开启此项。
/// 配置项Debug.IsEnable false
/// </summary>
public static bool IsEnable
{
get
{
return GetAppBool("Debug.IsEnable", IsDebugMode);
}
set
{
SetApp("Debug.IsEnable", value.ToString());
}
}
#endregion
}
#endregion
#region UI
/// <summary>
/// 有UI界面的Web、Winform、WPF。
/// </summary>
public static class UI
{
/// <summary>
/// UI取值的默认前缀ddl,chb,txt),多个用逗号(,)分隔
/// 配置项UI.AutoPrefixs txt,chb,ddl
/// </summary>
public static string AutoPrefixs
{
get
{
return GetApp("UI.AutoPrefixs", IsNetCore ? "" : "txt,chb,ddl");
}
set
{
SetApp("UI.AutoPrefixs", value);
}
}
}
#endregion
#region Json
/// <summary>
/// JsonHelper 相关配置
/// </summary>
public static class Json
{
/// <summary>
/// ToJson 输出时是否自动转义特殊符号("\ \r \t等)
/// 配置Json.Escape = Default 可选Default、Yes、No
/// </summary>
public static string Escape
{
get
{
return GetApp("Json.Escape", "Default");
}
set
{
SetApp("Json.Escape", value);
}
}
}
#endregion
}
/// <summary>
/// 只读属性
/// </summary>
public static partial class AppConfig
{
#region Web相关
private static object lockObj = new object();
private static bool? _IsDebugMode;
/// <summary>
/// Get 是否在 Debug 模式下运行。
/// </summary>
public static bool IsDebugMode
{
get
{
if (_IsDebugMode == null)
{
lock (lockObj)
{
if (_IsDebugMode == null)
{
var assembly = Assembly.GetEntryAssembly();
if (assembly == null)
{
Assembly[] assList = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly ass in assList)
{
if (ass.GlobalAssemblyCache || ass.GetName().GetPublicKeyToken().Length > 0)
{
//去掉系统dll
continue;
}
object[] das = ass.GetCustomAttributes(typeof(DebuggableAttribute), true);
if (das.Length > 0)
{
DebuggableAttribute da = das[0] as DebuggableAttribute;
if (da.IsJITTrackingEnabled)
{
_IsDebugMode = true;
break;
}
}
}
}
else
{
object[] das = assembly.GetCustomAttributes(typeof(DebuggableAttribute), true);
if (das.Length > 0)
{
DebuggableAttribute da = das[0] as DebuggableAttribute;
_IsDebugMode = da.IsJITTrackingEnabled;
// _IsDebugMode = (da.DebuggingFlags & DebuggableAttribute.DebuggingModes.EnableEditAndContinue) == DebuggableAttribute.DebuggingModes.EnableEditAndContinue;
}
}
if (_IsDebugMode == null) { _IsDebugMode = false; }
}
}
}
return _IsDebugMode.Value;
}
}
//[Conditional("DEBUG")]
private static void SetDebugRootPath(ref string path)
{
if (IsDebugMode)
{
bool isdebug = IsDebugMode;
path = Environment.CurrentDirectory;
path = path + (path[0] == '/' ? '/' : '\\');
}
}
private static readonly object lockPathObj = new object();
private static string _WebRootPath;
/// <summary>
/// Get 运行根目录,以"/"或"\"结尾。
/// </summary>
public static string WebRootPath
{
get
{
if (string.IsNullOrEmpty(_WebRootPath))
{
if (IsNetCore)
{
lock (lockPathObj)
{
if (string.IsNullOrEmpty(_WebRootPath))
{
string path = AppDomain.CurrentDomain.BaseDirectory;
SetDebugRootPath(ref path);
path = path + "wwwroot";
if (path[0] == '/')
{
path = path + "/";
}
else
{
path = path + "\\";
}
if (Directory.Exists(path) || IsWeb)
{
_WebRootPath = path;
}
}
}
}
if (string.IsNullOrEmpty(_WebRootPath))
{
_WebRootPath = AppDomain.CurrentDomain.BaseDirectory;
}
}
return _WebRootPath;
}
}
private static readonly object lockWebObj = new object();
private static int webState = -1;
/// <summary>
/// Get 当前运行环境是否 Web 应用。
/// </summary>
public static bool IsWeb
{
get
{
if (webState == -1)
{
lock (lockWebObj)
{
if (webState == -1)
{
string basePath = AppDomain.CurrentDomain.BaseDirectory;
bool isWeb = File.Exists(basePath + "web.config");
if (!isWeb && IsNetCore)
{
isWeb = File.Exists(basePath + "Taurus.Core.dll") || File.Exists(basePath + "Aries.Core.dll") || Directory.Exists("wwwroot");
if (!isWeb)
{
Assembly[] assList = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly ass in assList)
{
if (isWeb) { break; }
switch (ass.GetName().Name)
{
case "Microsoft.AspNetCore.Server.Kestrel":
case "Microsoft.AspNetCore.Server.IIS":
isWeb = true;
break;
}
}
}
}
webState = isWeb ? 1 : 0;
}
}
}
return webState == 1;
}
}
internal static Uri WebUri
{
get
{
if (HttpContext.Current != null)// && HttpContext.Current.Handler != null //AppConfig.XHtml.Domain 可能需要在Begin事件中获取因此只能冒险一取。
{
try
{
return HttpContext.Current.Request.Url;
}
catch
{
return null;
}
}
return null;
}
}
#endregion
/// <summary>
/// 获取 CYQ.Data.dll 的版本号
/// </summary>
public static string Version
{
get
{
return System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString();
}
}
/// <summary>
/// Get 框架的运行路径(最外层的目录),以"\\" 或"/"结尾
/// Win、 .NetCore 项目是dll和exe所在的目录
/// ASPNET 项目:是指根目录;
/// </summary>
public static string RunPath
{
get
{
if (AppConfig.IsWeb)
{
string path = AppDomain.CurrentDomain.BaseDirectory;
if (IsNetCore)
{
SetDebugRootPath(ref path);
}
return path;
}
return AppConst.AssemblyPath;
}
}
/// <summary>
/// Get 程序集(dll) 所在的运行路径,以"\\" 或"/"结尾
/// </summary>
public static string AssemblyPath
{
get
{
return AppConst.AssemblyPath;
}
}
}
}