public CustomMessageHandler(SenparcWeixinSetting senparcWeixinSetting, BaseConfig settingConfig, Stream inputStream, PostModel postModel, int maxRecordCount = 0)
: base(inputStream, postModel, maxRecordCount)
{
_senparcWeixinSetting = senparcWeixinSetting;
_settingConfig = settingConfig;
//这里设置仅用于测试，实际开发可以在外部更全局的地方设置，
//比如MessageHandler<MessageContext>.GlobalWeixinContext.ExpireMinutes = 3。
GlobalMessageContext.ExpireMinutes = 3;
if (!string.IsNullOrEmpty(postModel.AppId))
{
_appId = postModel.AppId;//通过第三方开放平台发送过来的请求
}
//在指定条件下，不使用消息去重
OmitRepeatedMessageFunc = requestMessage => !(requestMessage is RequestMessageText textRequestMessage) || textRequestMessage.Content != "容错";
}
void Application_Start(object sender, EventArgs e)
{
//...
var isGLobalDebug = true; //设置全局 Debug 状态
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
var register = RegisterService.Start(senparcSetting).UseSenparcGlobal(); //CO2NET全局注册，必须！
var isWeixinDebug = true; //设置微信 Debug 状态
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);////微信全局注册，必须！
//...
// 在应用程序启动时运行的代码
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
// 从web config中取出数据目录
string dataDir = WebConfigurationManager.AppSettings["DataDir"];
if (String.IsNullOrEmpty(dataDir) == true)
{
throw new Exception("尚未在Web.config文件中设置DataDir参数");
}
if (dataDir.Substring(0, 1) == "~")
{
dataDir = Server.MapPath(string.Format(dataDir));//"~/App_Data"
}
if (Directory.Exists(dataDir) == false)
{
throw new Exception("微信数据目录" + dataDir + "不存在。");
}
// 初始化命令服务类
dp2WeiXinService.Instance.Init(dataDir);
dp2WeiXinService.Instance.WriteLog1("Application_Start完成");
// 测试application_error
//throw new Exception("test");
//Application["app"] = "test";
}
/// <summary>
/// 注册 IServiceCollection 和 MemoryCache
/// </summary>
public static void RegisterServiceCollection()
{
var serviceCollection = new ServiceCollection();
var configBuilder = new ConfigurationBuilder();
var appSettingsTestFilePath = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, UnitTestHelper.RootPath, "appsettings.Test.json"));
var appSettingsFileExisted = File.Exists(appSettingsTestFilePath);
if (appSettingsFileExisted)
{
configBuilder.AddJsonFile("appsettings.Test.json", false, false);//此文件可能包含敏感信息，不可上传至公共库
}
else
{
if (File.Exists(appSettingsTestFilePath.Replace(".Test", "")))
{
configBuilder.AddJsonFile("appsettings.json", false, false);//默认使用 appsettings.json
appSettingsFileExisted = true;
}
}
var config = configBuilder.Build();
_senparcSetting = new SenparcSetting()
{
IsDebug = true
};
_senparcWeixinSetting = new SenparcWeixinSetting()
{
IsDebug = true
};
if (appSettingsFileExisted)
{
config.GetSection("SenparcSetting").Bind(_senparcSetting);
config.GetSection("SenparcWeixinSetting").Bind(_senparcWeixinSetting);
}
serviceCollection.AddMemoryCache();//使用内存缓存
//已经包含 AddSenparcGlobalServices()，注意：必须在所有注册完成后执行
serviceCollection.AddSenparcWeixinServices(config);
_serviceProvider = serviceCollection.BuildServiceProvider();
}
/// <summary>
/// 运行默认注册流程
/// </summary>
protected void RegisterStart()
{
#if NETSTANDARD2_0 || NETCOREAPP2_0 || NETCOREAPP2_1 || NETCOREAPP2_2 || NETCOREAPP3_1 || NET6_0
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);//支持 GB2312
#endif
//注册开始
RegisterService register;
//注册 CON2ET 全局
var senparcSetting = new SenparcSetting()
{
IsDebug = true
};
#if NETSTANDARD2_0 || NETCOREAPP2_0 || NETCOREAPP2_1 || NETCOREAPP2_2 || NETCOREAPP3_1 || NET6_0
#if NETCOREAPP3_1 || NET6_0
var mockEnv = new Mock <IWebHostEnvironment>();
#else
var mockEnv = new Mock <IHostingEnvironment>();
#endif
mockEnv.Setup(z => z.ContentRootPath).Returns(() => UnitTestHelper.RootPath);
register = Senparc.CO2NET.AspNet.RegisterServices.RegisterService.Start(mockEnv.Object, senparcSetting);
RegisterServiceCollection();
#else
register = RegisterService.Start(senparcSetting);
#endif
//Func<List<IDomainExtensionCacheStrategy>> func = () =>
//{
// var list = new List<IDomainExtensionCacheStrategy>();
// list.Add(LocalContainerCacheStrategy.Instance);
// list.Add(RedisContainerCacheStrategy.Instance);
// //list.Add(MemcachedContainerCacheStrategy.Instance);
// return list;
//};
//register.UseSenparcGlobal(false, func);
register.UseSenparcGlobal(false);
//注册微信
var senparcWeixinSetting = new SenparcWeixinSetting(true);
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);
register.ChangeDefaultCacheNamespace("Senparc.Weixin Test Cache");
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var isGLobalDebug = true; //设置全局 Debug 状态
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
var register = RegisterService.Start(senparcSetting).UseSenparcGlobal(); //CO2NET全局注册，必须！
var isWeixinDebug = true; //设置微信 Debug 状态
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting); ////微信全局注册，必须！
///
}
public static void UseSenparc(this IApplicationBuilder app, IWebHostEnvironment env,
SenparcSetting senparcSetting, SenparcWeixinSetting senparcWeixinSetting)
{
app.UseSenparcGlobal(env, senparcSetting, register =>
{
}, true).
UseSenparcWeixin(senparcWeixinSetting, register =>
{
register.RegisterWxOpenAccount(senparcWeixinSetting);
});
//var register = RegisterService.Start(senparcSetting.Value).UseSenparcGlobal(false);
//register.UseSenparcWeixin(senparcWeixinSetting.Value, senparcSetting.Value);
//register.RegisterWxOpenAccount(senparcWeixinSetting.Value);
}
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
public BaseTest()
{
//设置全局 Debug 状态
var isGLobalDebug = true;
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
//CO2NET 全局注册，必须！！
IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal();
/* 微信配置开始
* 建议按照以下顺序进行注册
*/
var isWeixinDebug = true;
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
//微信全局注册，必须！！
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);
}
protected void Application_Start()
{
var isGLobalDebug = true; //设置全局 Debug 状态
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
var register = RegisterService.Start(senparcSetting).UseSenparcGlobal(); //CO2NET全局注册，必须！
var isWeixinDebug = true; //设置微信 Debug 状态
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);////微信全局注册，必须！
AccessTokenContainer.RegisterAsync("wxad6fecee3bf4ba2f", "f2b4532be0ba85edee3425bfa86f2187", "微信cjj小程序");
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);//MVC 2nd
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
/// <summary>
/// 启动应用程序
/// </summary>
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
// 开启Log4Net日志配置
LogFactory.LogFactoryConfig();
//注册定时作业任务
SystemTask.PublicSystemTask t = new SystemTask.PublicSystemTask();
t.StartUp();
#if 使用RegisterServices方式注册微信
//设置全局 Debug 状态
var isGLobalDebug = false;
//全局设置参数，将被储存到 Senparc.CO2NET.Config.SenparcSetting
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
//也可以通过这种方法在程序任意位置设置全局 Debug 状态：
//Senparc.CO2NET.Config.IsDebug = isGLobalDebug;
//CO2NET 全局注册，必须！！
IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal();
//--------注册公众号--------------
//设置微信 Debug 状态
var isWeixinDebug = true;
//全局设置参数，将被储存到 Senparc.Weixin.Config.SenparcWeixinSetting
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
//微信全局注册，必须！！
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting).RegisterMpAccount(senparcWeixinSetting, "我的公众号名称");
//可以在程序任意地方注册公众号或小程序：
//AccessTokenContainer.Register(weixin.T_AppId, weixin.T_AppSecret, weixin.T_WxName);
WxBaseConfigApp app = new WxBaseConfigApp();
var weixin = app.GetDefaultConfig();
AccessTokenContainer.RegisterAsync(weixin.AppId, weixin.AppSecret, weixin.WxName);
#endif
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
//设置全局 Debug 状态
var isGLobalDebug = true;
//全局设置参数，将被储存到 Senparc.CO2NET.Config.SenparcSetting
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
//也可以通过这种方法在程序任意位置设置全局 Debug 状态：
Senparc.CO2NET.Config.IsDebug = isGLobalDebug;
//CO2NET 全局注册，必须！！
IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal();
#region 注册日志（按需，建议）
register.RegisterTraceLog(ConfigWeixinTraceLog);//配置TraceLog
#endregion
/* 微信配置开始
* 建议按照以下顺序进行注册
*/
//设置微信 Debug 状态
var isWeixinDebug = true;
//全局设置参数，将被储存到 Senparc.Weixin.Config.SenparcWeixinSetting
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
//也可以通过这种方法在程序任意位置设置微信的 Debug 状态：
//Senparc.Weixin.Config.IsDebug = isWeixinDebug;
//微信全局注册，必须！！
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var isGLobalDebug = true; //设置全局 Debug 状态
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
var register = RegisterService.Start(senparcSetting).UseSenparcGlobal(); //CO2NET全局注册，必须！
var isWeixinDebug = true; //设置微信 Debug 状态
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);////微信全局注册，必须！
#region 配置和使用 Redis -- DPBMARK Redis
//配置全局使用Redis缓存（按需，独立）
var redisConfigurationStr = senparcSetting.Cache_Redis_Configuration;
var useRedis = !string.IsNullOrEmpty(redisConfigurationStr) && redisConfigurationStr != "Redis配置";
if (useRedis)//这里为了方便不同环境的开发者进行配置，做成了判断的方式，实际开发环境一般是确定的，这里的if条件可以忽略
{
Senparc.CO2NET.Cache.Redis.Register.SetConfigurationOption(redisConfigurationStr);
//以下会立即将全局缓存设置为 Redis
Senparc.CO2NET.Cache.Redis.Register.UseKeyValueRedisNow();//键值对缓存策略（推荐）
//Senparc.CO2NET.Cache.Redis.Register.UseHashRedisNow();//HashSet储存格式的缓存策略
//也可以通过以下方式自定义当前需要启用的缓存策略
//CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisObjectCacheStrategy.Instance);//键值对
//CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisHashSetObjectCacheStrategy.Instance);//HashSet
}
//如果这里不进行Redis缓存启用，则目前还是默认使用内存缓存
#endregion
}
/// <summary>
///
/// </summary>
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
//var container = new Container();
//GlobalConfiguration.Configuration.DependencyResolver =
// new SimpleInjectorWebApiDependencyResolver(container);
GlobalConfiguration.Configure(WebApiConfig.Register);
// FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var isGLobalDebug = true; //设置全局 Debug 状态
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
var register = RegisterService.Start(senparcSetting).UseSenparcGlobal(); //CO2NET全局注册，必须！
var isWeixinDebug = true; //设置微信 Debug 状态
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);////微信全局注册，必须
AccessTokenContainer.RegisterAsync(WXController.AppId, "5e6bc09d33684d9c41dccb6c8eec230b");
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
//引入EnableRequestRewind中间件
app.UseEnableRequestRewind();
app.UseSession();
app.UseWeb(env, Configuration, hosting);
// 启动 CO2NET 全局注册，必须！
//关于 UseSenparcGlobal() 的更多用法见 CO2NET Demo：https://github.com/Senparc/Senparc.CO2NET/blob/master/Sample/Senparc.CO2NET.Sample.netcore/Startup.cs
var senparcSetting = new SenparcSetting()
{
IsDebug = true,
DefaultCacheNamespace = "DefaultCache",
Cache_Redis_Configuration = "",//redis1:6379
Cache_Memcached_Configuration = "",
SenparcUnionAgentKey = ""
};
var senparcWeixinSetting = new SenparcWeixinSetting()
{
IsDebug = true,
EncodingAESKey = "",
WeixinAppId = "wx8eff62aca23ebf87",
WeixinAppSecret = "b224033b6b4bf36970deaf5aa846ab4d"
};
//CO2NET 设置
IRegisterService register = RegisterService.Start(env, senparcSetting).UseSenparcGlobal();
register.ChangeDefaultCacheNamespace("DefaultCO2NETCache");
//app.UseSenparcWeixinCacheMemcached();
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting)
.RegisterMpAccount(senparcWeixinSetting, "【盛派网络小助手】公众号");
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
//... register ...
//设置全局 Debug 状态
var isGLobalDebug = true;
//全局设置参数，将被储存到 Senparc.CO2NET.Config.SenparcSetting
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
//CO2NET 全局注册，必须！！
IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal();
/* 微信配置开始
* 建议按照以下顺序进行注册
*/
//设置微信 Debug 状态
var isWeixinDebug = true;
//全局设置参数，将被储存到 Senparc.Weixin.Config.SenparcWeixinSetting
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
//也可以通过这种方法在程序任意位置设置微信的 Debug 状态：
//Senparc.Weixin.Config.IsDebug = isWeixinDebug;
//微信全局注册，必须！！
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);
//除此以外，仍然可以在程序任意地方注册公众号或小程序, 命名空间：Senparc.Weixin.MP.Containers：
AccessTokenContainer.Register(Senparc.Weixin.Config.SenparcWeixinSetting.WeixinAppId,
Senparc.Weixin.Config.SenparcWeixinSetting.WeixinAppSecret);
Database.SetInitializer <WeChatHelloWorld1Context>(null);
}
/// <summary>
/// 运行默认注册流程
/// </summary>
protected void RegisterStart()
{
//注册开始
RegisterService register;
//注册 CON2ET 全局
var senparcSetting = new SenparcSetting()
{
IsDebug = true
};
#if NETSTANDARD2_0 || NETCOREAPP2_0 || NETCOREAPP2_1
var mockEnv = new Mock <IHostingEnvironment>();
mockEnv.Setup(z => z.ContentRootPath).Returns(() => UnitTestHelper.RootPath);
register = RegisterService.Start(mockEnv.Object, senparcSetting);
RegisterServiceCollection();
#else
register = RegisterService.Start(senparcSetting);
#endif
//Func<IList<IDomainExtensionCacheStrategy>> func = () =>
//{
// var list = new List<IDomainExtensionCacheStrategy>();
// list.Add(LocalContainerCacheStrategy.Instance);
// list.Add(RedisContainerCacheStrategy.Instance);
// //list.Add(MemcachedContainerCacheStrategy.Instance);
// return list;
//};
//register.UseSenparcGlobal(false, func);
register.UseSenparcGlobal(false);
//注册微信
var senparcWeixinSetting = new SenparcWeixinSetting(true);
register.UseSenparcWeixin(senparcWeixinSetting);
}
/// <summary>
/// 注册缓存策略
/// </summary>
internal static void RegisterWeixinConfig()
{
lock (typeof(WechatMpApp))
{
if (registerService == null)
{
//设置全局 Debug 状态
var isGLobalDebug = true;
//全局设置参数，将被储存到 Senparc.CO2NET.Config.SenparcSetting
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
//CO2NET 全局注册，必须！！
IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal(false, GetExCacheStrategies);
// IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal();
BuildRedisCacheStrategy();
//设置微信 Debug 状态
var isWeixinDebug = true;
//全局设置参数，将被储存到 Senparc.Weixin.Config.SenparcWeixinSetting
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
//微信全局注册，必须！！
registerService.UseSenparcWeixin(senparcWeixinSetting, senparcSetting);
}
}
}
/// <summary>
/// 获取Container扩展缓存策略
/// </summary>
/// <returns></returns>
private IList <IDomainExtensionCacheStrategy> GetExContainerCacheStrategies(SenparcWeixinSetting senparcWeixinSetting)
{
var exContainerCacheStrategies = new List <IDomainExtensionCacheStrategy>();
//判断Redis是否可用
var redisConfiguration = senparcWeixinSetting.Cache_Redis_Configuration;
if ((!string.IsNullOrEmpty(redisConfiguration) && redisConfiguration != "Redis配置"))
{
exContainerCacheStrategies.Add(RedisContainerCacheStrategy.Instance);
}
//判断Memcached是否可用
var memcachedConfiguration = senparcWeixinSetting.Cache_Memcached_Configuration;
if ((!string.IsNullOrEmpty(memcachedConfiguration) && redisConfiguration != "Memcached配置"))
{
exContainerCacheStrategies.Add(MemcachedContainerCacheStrategy.Instance);
}
//也可扩展自定义的缓存策略
return(exContainerCacheStrategies);
}
public SimulateToolController(IOptions <SenparcWeixinSetting> senparcWeixinSetting)
{
_senparcWeixinSetting = senparcWeixinSetting.Value;
}
public WeixinController(IOptions <SenparcWeixinSetting> senparcWeixinSetting)
{
_senparcWeixinSetting = senparcWeixinSetting.Value;
}
/// <summary>
/// 开始 Senparc.Weixin SDK 初始化参数流程
/// </summary>
/// <param name="registerService"></param>
/// <param name="senparcWeixinSetting">微信全局设置参数，必填</param>
/// <param name="senparcSetting">用于提供 SenparcSetting.Cache_Redis_Configuration 和 Cache_Memcached_Configuration 两个参数，如果不使用这两种分布式缓存可传入null</param>
/// <returns></returns>
public static IRegisterService UseSenparcWeixin(this IRegisterService registerService, SenparcWeixinSetting senparcWeixinSetting, SenparcSetting senparcSetting = null)
{
senparcWeixinSetting = senparcWeixinSetting ?? new SenparcWeixinSetting();
senparcSetting = (senparcSetting ?? CO2NET.Config.SenparcSetting) ?? new SenparcSetting();
//Senparc.Weixin SDK 配置
Senparc.Weixin.Config.SenparcWeixinSetting = senparcWeixinSetting;
/* 扩展缓存注册开始 */
var cacheTypes = "";//所有注册的扩展缓存
// 微信的 本地 缓存
var cache = LocalContainerCacheStrategy.Instance;//只要引用就可以被激活
cacheTypes += typeof(LocalContainerCacheStrategy);
var dt1 = SystemTime.Now;
//官方扩展缓存注册
//var officialTypes = new List<Type>() { typeof(LocalContainerCacheStrategy) };//官方提供的扩展缓存策略
//自动注册 Redis 和 Memcached
//Redis
var redisConfiguration = senparcSetting.Cache_Redis_Configuration;
if (!string.IsNullOrEmpty(redisConfiguration) &&
/*缓存配置默认值，不启用*/
redisConfiguration != "Redis配置" &&
redisConfiguration != "#{Cache_Redis_Configuration}#")
{
try
{
{
//StackExchange.Redis
var redisInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.Redis", "Senparc.Weixin.Cache.Redis", "RedisContainerCacheStrategy", "Instance");
if (redisInstance != null)
{
//officialTypes.Add(redisInstance.GetType());
cacheTypes += "\r\n" + redisInstance.GetType();
}
}
{
//CsRedis
var redisInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.CsRedis", "Senparc.Weixin.Cache.CsRedis", "RedisContainerCacheStrategy", "Instance");
if (redisInstance != null)
{
//officialTypes.Add(redisInstance.GetType());
cacheTypes += "\r\n" + redisInstance.GetType();
}
}
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
//Memcached
var memcachedConfiguration = senparcSetting.Cache_Memcached_Configuration;
if (!string.IsNullOrEmpty(memcachedConfiguration) &&
/*缓存配置默认值，不启用*/
memcachedConfiguration != "Memcached配置" &&
memcachedConfiguration != "#{Cache_Memcached_Configuration}#")
{
try
{
var memcachedInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.Memcached", "Senparc.Weixin.Cache.Memcached", "MemcachedContainerCacheStrategy", "Instance");
if (memcachedInstance != null)
{
//officialTypes.Add(memcachedInstance.GetType());
cacheTypes += "\r\n" + memcachedInstance.GetType();
}
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
var exCacheLog = $"微信扩展缓存注册总用时：{SystemTime.DiffTotalMS(dt1, "f4")}ms\r\n扩展缓存：{cacheTypes}";
WeixinTrace.SendCustomLog("微信扩展缓存注册完成", exCacheLog);
/* 扩展缓存注册结束 */
//ApiBind 自动扫描
Senparc.NeuChar.Register.RegisterApiBind(false);
return(registerService);
}
/// <summary>
/// 开始 Senparc.Weixin SDK 初始化参数流程
/// </summary>
/// <param name="registerService"></param>
/// <param name="senparcWeixinSetting"></param>
/// <param name="registerConfigure"></param>
/// <returns></returns>
public static IRegisterService UseSenparcWeixin(this IRegisterService registerService, SenparcWeixinSetting senparcWeixinSetting, Action <IRegisterService> registerConfigure)
{
var register = registerService.UseSenparcWeixin(senparcWeixinSetting, senparcSetting: null);
//由于 registerConfigure 内可能包含了 app.UseSenparcWeixinCacheRedis() 等注册代码，需要在在 registerService.UseSenparcWeixin() 自动加载 Redis 后进行
//因此必须在 registerService.UseSenparcWeixin() 之后执行。
registerConfigure?.Invoke(registerService);
return(register);
}
protected void Application_Start()
{
//DPBMARK WebSocket
RegisterWebSocket();//微信注册WebSocket模块（按需，必须执行在RouteConfig.RegisterRoutes()之前）
//DPBMARK_END
/*
* CO2NET 全局注册开始
* 建议按照以下顺序进行注册
*/
/*
* CO2NET 是从 Senparc.Weixin 分离的底层公共基础模块，经过了长达 6 年的迭代优化。
* 关于 CO2NET 在所有项目中的通用设置可参考 CO2NET 的 Sample：
* https://github.com/Senparc/Senparc.CO2NET/blob/master/Sample/Senparc.CO2NET.Sample.netcore/Startup.cs
*/
//设置全局 Debug 状态
var isGLobalDebug = true;
//全局设置参数，将被储存到 Senparc.CO2NET.Config.SenparcSetting
var senparcSetting = SenparcSetting.BuildFromWebConfig(isGLobalDebug);
//也可以通过这种方法在程序任意位置设置全局 Debug 状态：
//Senparc.CO2NET.Config.IsDebug = isGLobalDebug;
//CO2NET 全局注册，必须！！
IRegisterService register = RegisterService.Start(senparcSetting).UseSenparcGlobal();
#region 全局缓存配置（按需）
#region 配置和使用 Redis -- DPBMARK Redis
//配置全局使用Redis缓存（按需，独立）
var redisConfigurationStr = senparcSetting.Cache_Redis_Configuration;
var useRedis = !string.IsNullOrEmpty(redisConfigurationStr) && redisConfigurationStr != "Redis配置";
if (useRedis)//这里为了方便不同环境的开发者进行配置，做成了判断的方式，实际开发环境一般是确定的，这里的if条件可以忽略
{
/* 说明：
* 1、Redis 的连接字符串信息会从 Config.SenparcSetting.Cache_Redis_Configuration 自动获取并注册，如不需要修改，下方方法可以忽略
* /* 2、如需手动修改，可以通过下方 SetConfigurationOption 方法手动设置 Redis 链接信息（仅修改配置，不立即启用）
*/
Senparc.CO2NET.Cache.Redis.Register.SetConfigurationOption(redisConfigurationStr);
//以下会立即将全局缓存设置为 Redis
Senparc.CO2NET.Cache.Redis.Register.UseKeyValueRedisNow();//键值对缓存策略（推荐）
//Senparc.CO2NET.Cache.Redis.Register.UseHashRedisNow();//HashSet储存格式的缓存策略
//也可以通过以下方式自定义当前需要启用的缓存策略
//CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisObjectCacheStrategy.Instance);//键值对
//CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisHashSetObjectCacheStrategy.Instance);//HashSet
}
//如果这里不进行Redis缓存启用，则目前还是默认使用内存缓存
#endregion // DPBMARK_END
#region 配置和使用 Memcached -- DPBMARK Memcached
//配置Memcached缓存（按需，独立）
var memcachedConfigurationStr = senparcSetting.Cache_Memcached_Configuration;
var useMemcached = !string.IsNullOrEmpty(memcachedConfigurationStr) && memcachedConfigurationStr != "Memcached配置";
if (useMemcached) //这里为了方便不同环境的开发者进行配置，做成了判断的方式，实际开发环境一般是确定的，这里的if条件可以忽略
{
/* 说明：
* 1、Memcached 的连接字符串信息会从 Config.SenparcSetting.Cache_Memcached_Configuration 自动获取并注册，如不需要修改，下方方法可以忽略
* /* 2、如需手动修改，可以通过下方 SetConfigurationOption 方法手动设置 Memcached 链接信息（仅修改配置，不立即启用）
*/
Senparc.CO2NET.Cache.Memcached.Register.SetConfigurationOption(memcachedConfigurationStr);
//以下会立即将全局缓存设置为 Memcached
Senparc.CO2NET.Cache.Memcached.Register.UseMemcachedNow();
//也可以通过以下方式自定义当前需要启用的缓存策略
CacheStrategyFactory.RegisterObjectCacheStrategy(() => MemcachedObjectCacheStrategy.Instance);
}
#endregion // DPBMARK_END
#endregion
#region 注册日志（按需，建议）
register.RegisterTraceLog(ConfigWeixinTraceLog);//配置TraceLog
#endregion
/* 微信配置开始
* 建议按照以下顺序进行注册
*/
//设置微信 Debug 状态
var isWeixinDebug = true;
//全局设置参数，将被储存到 Senparc.Weixin.Config.SenparcWeixinSetting
var senparcWeixinSetting = SenparcWeixinSetting.BuildFromWebConfig(isWeixinDebug);
//也可以通过这种方法在程序任意位置设置微信的 Debug 状态：
//Senparc.Weixin.Config.IsDebug = isWeixinDebug;
//微信全局注册，必须！！
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting)
#region 注册公众号或小程序（按需）
//注册公众号（可注册多个） -- DPBMARK MP
.RegisterMpAccount(senparcWeixinSetting, "【盛派网络小助手】公众号") // DPBMARK_END
//注册多个公众号或小程序（可注册多个） -- DPBMARK MiniProgram
.RegisterWxOpenAccount(senparcWeixinSetting, "【盛派网络小助手】小程序") // DPBMARK_END
//除此以外，仍然可以在程序任意地方注册公众号或小程序：
//AccessTokenContainer.Register(appId, appSecret, name);//命名空间：Senparc.Weixin.MP.Containers
#endregion
#region 注册企业号（按需） -- DPBMARK Work
//注册企业微信（可注册多个）
.RegisterWorkAccount(senparcWeixinSetting, "【盛派网络】企业微信")
//除此以外，仍然可以在程序任意地方注册企业微信：
//AccessTokenContainer.Register(corpId, corpSecret, name);//命名空间：Senparc.Weixin.Work.Containers
#endregion // DPBMARK_END
#region 注册微信支付（按需） -- DPBMARK TenPay
//注册旧微信支付版本（V2）（可注册多个）
.RegisterTenpayOld(senparcWeixinSetting, "【盛派网络小助手】公众号") //这里的 name 和第一个 RegisterMpAccount() 中的一致，会被记录到同一个 SenparcWeixinSettingItem 对象中
//注册最新微信支付版本（V3）（可注册多个）
.RegisterTenpayV3(senparcWeixinSetting, "【盛派网络小助手】公众号") //记录到同一个 SenparcWeixinSettingItem 对象中
#endregion // DPBMARK_END
#region 注册微信第三方平台（按需） -- DPBMARK Open
//注册第三方平台（可注册多个）
.RegisterOpenComponent(senparcWeixinSetting,
//getComponentVerifyTicketFunc
async componentAppId =>
{
var dir = Path.Combine(Server.MapPath("~/App_Data/OpenTicket"));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var file = Path.Combine(dir, string.Format("{0}.txt", componentAppId));
using (var fs = new FileStream(file, FileMode.Open))
{
using (var sr = new StreamReader(fs))
{
var ticket = sr.ReadToEnd();
return(ticket);
}
}
},
//getAuthorizerRefreshTokenFunc
async(componentAppId, auhtorizerId) =>
{
var dir = Path.Combine(Server.MapPath("~/App_Data/AuthorizerInfo/" + componentAppId));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var file = Path.Combine(dir, string.Format("{0}.bin", auhtorizerId));
if (!File.Exists(file))
{
return(null);
}
using (Stream fs = new FileStream(file, FileMode.Open))
{
var binFormat = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
var result = (RefreshAuthorizerTokenResult)binFormat.Deserialize(fs);
return(result.authorizer_refresh_token);
}
},
//authorizerTokenRefreshedFunc
(componentAppId, auhtorizerId, refreshResult) =>
{
var dir = Path.Combine(Server.MapPath("~/App_Data/AuthorizerInfo/" + componentAppId));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var file = Path.Combine(dir, string.Format("{0}.bin", auhtorizerId));
using (Stream fs = new FileStream(file, FileMode.Create))
{
//这里存了整个对象，实际上只存RefreshToken也可以，有了RefreshToken就能刷新到最新的AccessToken
var binFormat = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
binFormat.Serialize(fs, refreshResult);
fs.Flush();
}
}, "【盛派网络】开放平台")
//除此以外，仍然可以在程序任意地方注册开放平台：
//ComponentContainer.Register();//命名空间：Senparc.Weixin.Open.Containers
#endregion // DPBMARK_END
;
/* 微信配置结束 */
}
/// <summary>
/// 开始 Senparc.Weixin SDK 初始化参数流程
/// </summary>
/// <param name="registerService"></param>
/// <param name="senparcWeixinSetting"></param>
/// <param name="extensionCacheStrategiesFunc"><para>需要注册的扩展缓存策略</para>
/// <para>（LocalContainerCacheStrategy、RedisContainerCacheStrategy、MemcacheContainerCacheStrategy已经自动注册），</para>
/// <para>如果设置为 null（注意：不适委托返回 null，是整个委托参数为 null），则自动使用反射扫描所有可能存在的扩展缓存策略</para></param>
/// <returns></returns>
public static IRegisterService UseSenparcWeixin(this IRegisterService registerService, SenparcWeixinSetting senparcWeixinSetting, Func <IList <IDomainExtensionCacheStrategy> > extensionCacheStrategiesFunc = null)
{
senparcWeixinSetting = senparcWeixinSetting ?? new SenparcWeixinSetting();
//Senparc.Weixin SDK 配置
Senparc.Weixin.Config.IsDebug = senparcWeixinSetting.IsDebug;
Senparc.Weixin.Config.DefaultSenparcWeixinSetting = senparcWeixinSetting;
// 微信的 本地 缓存
var cache = LocalContainerCacheStrategy.Instance;//只要引用就可以被激活
if (extensionCacheStrategiesFunc != null)
{
var containerCacheStrategies = extensionCacheStrategiesFunc();
if (containerCacheStrategies != null)
{
foreach (var cacheStrategy in containerCacheStrategies)
{
var exCache = cacheStrategy;//确保能运行到就行，会自动注册
}
}
}
else
{
var officialTypes = new List <Type>()
{
typeof(LocalContainerCacheStrategy)
};
//自动注册 Redis 和 Memcached
//Redis
var redisConfiguration = senparcWeixinSetting.Cache_Redis_Configuration;
if ((!string.IsNullOrEmpty(redisConfiguration) && redisConfiguration != "Redis配置"))
{
try
{
var redisInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.Redis", "Senparc.Weixin.Cache.Redis", "RedisContainerCacheStrategy", "Instance");
officialTypes.Add(redisInstance.GetType());
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
//Memcached
var memcachedConfiguration = senparcWeixinSetting.Cache_Memcached_Configuration;
if ((!string.IsNullOrEmpty(memcachedConfiguration) && memcachedConfiguration != "Memcached配置"))
{
try
{
var memcachedInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.Memcached", "Senparc.Weixin.Cache.Memcached", "MemcachedContainerCacheStrategy", "Instance");
officialTypes.Add(memcachedInstance.GetType());
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
//查找所有扩产缓存
var types = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes()
.Where(t => !t.IsAbstract && !officialTypes.Contains(t) && t.GetInterfaces().Contains(typeof(IDomainExtensionCacheStrategy))))
.ToArray();
foreach (var type in types)
{
try
{
var exCache = ReflectionHelper.GetStaticMember(type, "Instance");
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
}
return(registerService);
}
public HomeController(AccountService accountService, SmsRecordService smsRecordService, IOptionsSnapshot <SenparcWeixinSetting> senparcWeixinSetting)
{
_accountService = accountService;
_smsRecordService = smsRecordService;
_senparcWeixinSetting = senparcWeixinSetting.Value;
}
public SignalRController(IHubContext <SingleHub> hubContext, IOptions <SenparcWeixinSetting> senparcWeixinSetting)
{
_hubContext = hubContext;
_senparcWeixinSetting = senparcWeixinSetting.Value;
}
/// <summary>
/// 开始 Senparc.Weixin SDK 初始化参数流程
/// </summary>
/// <param name="registerService"></param>
/// <param name="senparcWeixinSetting">微信全局设置参数，必填</param>
/// <param name="senparcSetting">用于提供 SenparcSetting.Cache_Redis_Configuration 和 Cache_Memcached_Configuration 两个参数，如果不使用这两种分布式缓存可传入null</param>
/// <returns></returns>
public static IRegisterService UseSenparcWeixin(this IRegisterService registerService, SenparcWeixinSetting senparcWeixinSetting, SenparcSetting senparcSetting = null)
{
senparcWeixinSetting = senparcWeixinSetting ?? new SenparcWeixinSetting();
senparcSetting = senparcSetting ?? new SenparcSetting();
//Senparc.Weixin SDK 配置
Senparc.Weixin.Config.SenparcWeixinSetting = senparcWeixinSetting;
/* 扩展缓存注册开始 */
var cacheTypes = "";//所有注册的扩展缓存
// 微信的 本地 缓存
var cache = LocalContainerCacheStrategy.Instance;//只要引用就可以被激活
cacheTypes += typeof(LocalContainerCacheStrategy);
DateTime dt1 = DateTime.Now;
//官方扩展缓存注册
//var officialTypes = new List<Type>() { typeof(LocalContainerCacheStrategy) };//官方提供的扩展缓存策略
//自动注册 Redis 和 Memcached
//Redis
var redisConfiguration = senparcSetting.Cache_Redis_Configuration;
if ((!string.IsNullOrEmpty(redisConfiguration) && redisConfiguration != "Redis配置"))
{
try
{
var redisInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.Redis", "Senparc.Weixin.Cache.Redis", "RedisContainerCacheStrategy", "Instance");
if (redisInstance != null)
{
//officialTypes.Add(redisInstance.GetType());
cacheTypes += "\r\n" + redisInstance.GetType();
}
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
//Memcached
var memcachedConfiguration = senparcSetting.Cache_Memcached_Configuration;
if ((!string.IsNullOrEmpty(memcachedConfiguration) && memcachedConfiguration != "Memcached配置"))
{
try
{
var memcachedInstance = ReflectionHelper.GetStaticMember("Senparc.Weixin.Cache.Memcached", "Senparc.Weixin.Cache.Memcached", "MemcachedContainerCacheStrategy", "Instance");
if (memcachedInstance != null)
{
//officialTypes.Add(memcachedInstance.GetType());
cacheTypes += "\r\n" + memcachedInstance.GetType();
}
}
catch (Exception ex)
{
WeixinTrace.WeixinExceptionLog(new Exceptions.WeixinException(ex.Message, ex));
}
}
DateTime dt2 = DateTime.Now;
var exCacheLog = "微信扩展缓存注册总用时：{0}ms\r\n扩展缓存：{1}".FormatWith((dt2 - dt1).TotalMilliseconds, cacheTypes);
WeixinTrace.SendCustomLog("微信扩展缓存注册完成", exCacheLog);
/* 扩展缓存注册结束 */
//ApiBind 自动扫描
Senparc.NeuChar.Register.RegisterApiBind();
return(registerService);
}
static void Main(string[] args)
{
var dt1 = SystemTime.Now;
var configBuilder = new ConfigurationBuilder();
configBuilder.AddJsonFile("appsettings.json", false, false);
Console.WriteLine("完成 appsettings.json 添加");
var config = configBuilder.Build();
Console.WriteLine("完成 ServiceCollection 和 ConfigurationBuilder 初始化");
//更多绑定操作参见：https://docs.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-2.2
var senparcSetting = new SenparcSetting();
var senparcWeixinSetting = new SenparcWeixinSetting();
config.GetSection("SenparcSetting").Bind(senparcSetting);
config.GetSection("SenparcWeixinSetting").Bind(senparcWeixinSetting);
var services = new ServiceCollection();
services.AddMemoryCache();//使用本地缓存必须添加
/*
* CO2NET 是从 Senparc.Weixin 分离的底层公共基础模块，经过了长达 6 年的迭代优化，稳定可靠。
* 关于 CO2NET 在所有项目中的通用设置可参考 CO2NET 的 Sample：
* https://github.com/Senparc/Senparc.CO2NET/blob/master/Sample/Senparc.CO2NET.Sample.netcore/Startup.cs
*/
services.AddSenparcGlobalServices(config);//Senparc.CO2NET 全局注册
Console.WriteLine("完成 AddSenparcGlobalServices 注册");
//输出 JSON 校验
//var jsonSerializerSettings = new Newtonsoft.Json.JsonSerializerSettings() { ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore };
//Console.WriteLine($"SenparcSetting:{senparcSetting.ToJson(true, jsonSerializerSettings)}");
//Console.WriteLine($"SenparcWeixinSetting:{senparcWeixinSetting.ToJson(true,jsonSerializerSettings)}");
// 启动 CO2NET 全局注册，必须！
IRegisterService register = RegisterService.Start(senparcSetting)
//关于 UseSenparcGlobal() 的更多用法见 CO2NET Demo：https://github.com/Senparc/Senparc.CO2NET/blob/master/Sample/Senparc.CO2NET.Sample.netcore/Startup.cs
.UseSenparcGlobal();
Console.WriteLine("完成 RegisterService.Start().UseSenparcGlobal() 启动设置");
Console.WriteLine($"设定程序目录为：{Senparc.CO2NET.Config.RootDictionaryPath}");
#region CO2NET 全局配置
#region 全局缓存配置（按需）
//当同一个分布式缓存同时服务于多个网站（应用程序池）时，可以使用命名空间将其隔离（非必须）
register.ChangeDefaultCacheNamespace("DefaultCO2NETCache");
Console.WriteLine($"默认缓存命名空间替换为：{CO2NET.Config.DefaultCacheNamespace}");
#region 配置和使用 Redis -- DPBMARK Redis
//配置全局使用Redis缓存（按需，独立）
var redisConfigurationStr = senparcSetting.Cache_Redis_Configuration;
var useRedis = !string.IsNullOrEmpty(redisConfigurationStr) && redisConfigurationStr != "#{Cache_Redis_Configuration}#" /*默认值，不启用*/;
if (useRedis)//这里为了方便不同环境的开发者进行配置，做成了判断的方式，实际开发环境一般是确定的，这里的if条件可以忽略
{
/* 说明：
* 1、Redis 的连接字符串信息会从 Config.SenparcSetting.Cache_Redis_Configuration 自动获取并注册，如不需要修改，下方方法可以忽略
* /* 2、如需手动修改，可以通过下方 SetConfigurationOption 方法手动设置 Redis 链接信息（仅修改配置，不立即启用）
*/
Senparc.CO2NET.Cache.Redis.Register.SetConfigurationOption(redisConfigurationStr);
Console.WriteLine("完成 Redis 设置");
//以下会立即将全局缓存设置为 Redis
Senparc.CO2NET.Cache.Redis.Register.UseKeyValueRedisNow();//键值对缓存策略（推荐）
Console.WriteLine("启用 Redis UseKeyValue 策略");
//Senparc.CO2NET.Cache.Redis.Register.UseHashRedisNow();//HashSet储存格式的缓存策略
//也可以通过以下方式自定义当前需要启用的缓存策略
//CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisObjectCacheStrategy.Instance);//键值对
//CacheStrategyFactory.RegisterObjectCacheStrategy(() => RedisHashSetObjectCacheStrategy.Instance);//HashSet
}
//如果这里不进行Redis缓存启用，则目前还是默认使用内存缓存
#endregion // DPBMARK_END
#region 配置和使用 Memcached -- DPBMARK Memcached
//配置Memcached缓存（按需，独立）
var memcachedConfigurationStr = senparcSetting.Cache_Memcached_Configuration;
var useMemcached = !string.IsNullOrEmpty(memcachedConfigurationStr) && memcachedConfigurationStr != "#{Cache_Memcached_Configuration}#";
if (useMemcached) //这里为了方便不同环境的开发者进行配置，做成了判断的方式，实际开发环境一般是确定的，这里的if条件可以忽略
{
/* 说明：
* 1、Memcached 的连接字符串信息会从 Config.SenparcSetting.Cache_Memcached_Configuration 自动获取并注册，如不需要修改，下方方法可以忽略
* /* 2、如需手动修改，可以通过下方 SetConfigurationOption 方法手动设置 Memcached 链接信息（仅修改配置，不立即启用）
*/
Senparc.CO2NET.Cache.Memcached.Register.SetConfigurationOption(memcachedConfigurationStr);
Console.WriteLine("完成 Memcached 设置");
//以下会立即将全局缓存设置为 Memcached
Senparc.CO2NET.Cache.Memcached.Register.UseMemcachedNow();
Console.WriteLine("启用 Memcached UseKeyValue 策略");
//也可以通过以下方式自定义当前需要启用的缓存策略
CacheStrategyFactory.RegisterObjectCacheStrategy(() => MemcachedObjectCacheStrategy.Instance);
Console.WriteLine("立即启用 Memcached 策略");
}
#endregion // DPBMARK_END
#endregion
#region 注册日志（按需，建议）
register.RegisterTraceLog(ConfigTraceLog);//配置TraceLog
#endregion
#endregion
#region 微信相关配置
/* 微信配置开始
*
* 建议按照以下顺序进行注册，尤其须将缓存放在第一位！
*/
//注册开始
//开始注册微信信息，必须！
register.UseSenparcWeixin(senparcWeixinSetting, senparcSetting)
//注意：上一行没有 ; 下面可接着写 .RegisterXX()
#region 注册公众号或小程序（按需）
//注册公众号（可注册多个） -- DPBMARK MP
.RegisterMpAccount(senparcWeixinSetting, "【盛派网络小助手】公众号") // DPBMARK_END
//注册多个公众号或小程序（可注册多个） -- DPBMARK MiniProgram
.RegisterWxOpenAccount(senparcWeixinSetting, "【盛派网络小助手】小程序") // DPBMARK_END
//除此以外，仍然可以在程序任意地方注册公众号或小程序：
//AccessTokenContainer.Register(appId, appSecret, name);//命名空间：Senparc.Weixin.MP.Containers
#endregion
#region 注册企业号（按需） -- DPBMARK Work
//注册企业微信（可注册多个）
.RegisterWorkAccount(senparcWeixinSetting, "【盛派网络】企业微信")
//除此以外，仍然可以在程序任意地方注册企业微信：
//AccessTokenContainer.Register(corpId, corpSecret, name);//命名空间：Senparc.Weixin.Work.Containers
#endregion // DPBMARK_END
#region 注册微信支付（按需） -- DPBMARK TenPay
//注册旧微信支付版本（V2）（可注册多个）
.RegisterTenpayOld(senparcWeixinSetting, "【盛派网络小助手】公众号") //这里的 name 和第一个 RegisterMpAccount() 中的一致，会被记录到同一个 SenparcWeixinSettingItem 对象中
//注册最新微信支付版本（V3）（可注册多个）
.RegisterTenpayV3(senparcWeixinSetting, "【盛派网络小助手】公众号") //记录到同一个 SenparcWeixinSettingItem 对象中
#endregion // DPBMARK_END
#region 注册微信第三方平台（按需） -- DPBMARK Open
//注册第三方平台（可注册多个）
.RegisterOpenComponent(senparcWeixinSetting,
//getComponentVerifyTicketFunc
async componentAppId =>
{
var dir = Path.Combine(ServerUtility.ContentRootMapPath("~/App_Data/OpenTicket"));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var file = Path.Combine(dir, string.Format("{0}.txt", componentAppId));
using (var fs = new FileStream(file, FileMode.Open))
{
using (var sr = new StreamReader(fs))
{
var ticket = await sr.ReadToEndAsync();
return(ticket);
}
}
},
//getAuthorizerRefreshTokenFunc
async(componentAppId, auhtorizerId) =>
{
var dir = Path.Combine(ServerUtility.ContentRootMapPath("~/App_Data/AuthorizerInfo/" + componentAppId));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var file = Path.Combine(dir, string.Format("{0}.bin", auhtorizerId));
if (!File.Exists(file))
{
return(null);
}
using (Stream fs = new FileStream(file, FileMode.Open))
{
var binFormat = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
var result = (RefreshAuthorizerTokenResult)binFormat.Deserialize(fs);
return(result.authorizer_refresh_token);
}
},
//authorizerTokenRefreshedFunc
(componentAppId, auhtorizerId, refreshResult) =>
{
var dir = Path.Combine(ServerUtility.ContentRootMapPath("~/App_Data/AuthorizerInfo/" + componentAppId));
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
var file = Path.Combine(dir, string.Format("{0}.bin", auhtorizerId));
using (Stream fs = new FileStream(file, FileMode.Create))
{
//这里存了整个对象，实际上只存RefreshToken也可以，有了RefreshToken就能刷新到最新的AccessToken
var binFormat = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
binFormat.Serialize(fs, refreshResult);
fs.Flush();
}
}, "【盛派网络】开放平台")
//除此以外，仍然可以在程序任意地方注册开放平台：
//ComponentContainer.Register();//命名空间：Senparc.Weixin.Open.Containers
#endregion // DPBMARK_END
;
/* 微信配置结束 */
#endregion
Console.WriteLine("Hello Senparc.Weixin!");
Console.WriteLine($"Total initialization time: {(SystemTime.Now - dt1).TotalMilliseconds}ms");
Console.WriteLine($"当前缓存策略: {CacheStrategyFactory.GetObjectCacheStrategyInstance()}");
Console.ReadLine();
}
public HangfireJobController(IServiceProvider service, IOptionsMonitor <SenparcWeixinSetting> senparcWeixinSetting)
{
_wxSetting = senparcWeixinSetting.CurrentValue;
RequestHelper = service.GetRequiredService <IAtlassRequest>();
_logApp = service.GetRequiredService <HangfireJobAppService>();
}
public WeixinOAuthController(AccountService accountService, IOptions <SenparcWeixinSetting> options, WeixinService weixinService)
{
_accountService = accountService;
_weixinService = weixinService;
_senparcWeixinSetting = options.Value;
}
public BaseController(IOptions <SenparcWeixinSetting> weixinSettingOptions)
{
WeixinSetting = weixinSettingOptions.Value;
Log = LogManager.GetLogger(Startup.repository.Name, "");
}
