C# 插件热插拔
所谓热插拔就是插件可以
在主程序不重新启动的情况直接更新插件，
网上有很多方案：
https://www.cnblogs.com/happyframework/p/3405811.html
如下：
但是我发现有一种最简单粗暴的办法，
就是把插件加载到内存当中，然后使用Assembly从内存中加载DLL信息，
这样插件就可以直接被删除，而不会提示文件已被进程占用，而无法删除和更新的问题。
.NET：如何实现 “热插拔”？
背景
如果某个“功能”需要动态更新？这种动态更新，可能是需求驱动的，也可能是为了修改 BUG，面对这种场景，如何实现“热插拔”呢？先解释一下“热插拔”：在系统运行过程动态替换某些功能，不用重启系统进程。
几种方案
- 脚本化：采用 Iron 或 集成其它脚本引擎。
- AppDomain：微软的 Add In 框架就是为这个目的设计的。
- 分布式 + 负载平衡 ：轮流更新集群中的服务器。
- Assembly.LoadFrom + 强签名程序集：因为相同标识的程序集在内存中只会加载一次，所以每次功能发生变化，都要增加程序集的版本号。
- Assembly.Load + + 强签名程序集 + GAC：因为相同标识的程序集在内存中只会加载一次，所以每次功能发生变化，都要增加程序集的版本号。
- Assembly.LoadFile：Assembly.LoadFile 可以多次加载相同标识的程序集，只要程序集所在的目录位置不同。
重点说一下 Assembly.LoadFile
项目结构
测试代码
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.Threading.Tasks;
6 using System.Reflection;
7 using System.IO;
8 using Contracts;
9
10 namespace Test
11 {
12 class Program
13 {
14 static void Main(string[] args)
15 {
16 SetupPlugEnvironment();
17
18 ExecuteOperator("1.0.0.0");
19 ExecuteOperator("2.0.0.0");
20 }
21
22 private static void ExecuteOperator(string version)
23 {
24 var operatorType = Type.GetType("Implements.Operator, Implements, version = " + version + "");
25 var operatorInstance = Activator.CreateInstance(operatorType) as IOperator;
26 operatorInstance.Operate();
27 }
28
29 private static void SetupPlugEnvironment()
30 {
31 AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
32 }
33
34 static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
35 {
36 AssemblyName name = new AssemblyName(args.Name);
37
38 var file = Path.Combine(
39 @"E:\Coding\HappyStudy\LoadContextStudy\Test\bin\Debug\Plugs",
40 name.Name,
41 name.Version.ToString(),
42 name.Name + ".dll");
43
44 Console.WriteLine("加载插件：" + name.Version);
45
46 return Assembly.LoadFile(file);
47 }
48 }
49 }
输出结果
说明
调用 Type.GetType 会导致 CLR 执行程序集探测过程，在正常的探测路径下没有找到程序集就会触发 AssemblyResolve 事件，为啥会触发两次呢？我还不知道，有知道的兄弟请留言。
备注
微软不推荐使用 LoadFile（会加载相同标识的程序集多次），Add In 采用的是 AppDomain，MEF 采用的是 LoadFrom（我估计是，还没有看源代码，测试结果是）。
----
.NET：何时应该 “包装异常”？
背景
提到异常，我们会想到：抛出异常、异常恢复、资源清理、吞掉异常、重新抛出异常、替换异常、包装异常。本文想谈谈 “包装异常”，主要针对这个问题：何时应该 “包装异常”？
“包装异常” 的技术形式
包装异常是替换异常的特殊形式，具体的技术形式如下：
1 try
2 {
3 // do something
4 }
5 catch (SomeException ex)
6 {
7 throw new WrapperException("New Message", ex);
8 }
注意：WrapperException 需要将 ex 作为 InnerException，这样才不至于丢失 StackTrace，WrapperException.StackTrace 和 ex.StackTrace 共同构成了完整的 StackTrace。
让例子帮助我们得出答案
有这样一种场景：我希望为各种 ORM 框架提供一种抽象，这可以让应用开发人员自由的在不同的 ORM 实现之间做出选择。
第一个版本的实现
实现伪代码
1 interface IRepository<TEntity>
2 {
3 void Update(TEntity entity);
4 }
5
6 class EntityFrameworkRepository<TEntity> : IRepository<TEntity>
7 {
8 public void Update(TEntity entity)
9 {
10 throw new EntityFrameworkConcurrentException(); // 可能会抛出这样的异常，这里的代码不是十分准确。
11 }
12 }
13
14 class NHibernateRepository<TEntity> : IRepository<TEntity>
15 {
16 public void Update(TEntity entity)
17 {
18 throw new NHibernateConcurrentException(); // 可能会抛出这样的异常，这里的代码不是十分准确。
19 }
20 }
有什么问题？
处理并发异常是应用层开发人员的一个非常重要的职责，他们或者选择自动重试、或者选择让用户重试、甚至允许并发带来的不一致性，如果使用了上面的接口问题就大了，应用中该拦截哪种并发异常呢？EntityFrameworkConcurrentException？NHibernateConcurrentException？这样的接口和实现无论如何都达不到：OCP 和 LSP。
将异常作为契约的一部分
实现伪代码
1 interface IRepository<TEntity>
2 {
3 void Update(TEntity entity);
4 }
5
6 class ConcurrentException : Exception
7 {
8 }
9
10 class EntityFrameworkRepository<TEntity> : IRepository<TEntity>
11 {
12 public void Update(TEntity entity)
13 {
14 try
15 {
16 }
17 catch (EntityFrameworkConcurrentException ex)
18 {
19 throw new ConcurrentException(ex);
20 }
21 }
22 }
23
24 class NHibernateRepository<TEntity> : IRepository<TEntity>
25 {
26 public void Update(TEntity entity)
27 {
28 try
29 {
30 }
31 catch (NHibernateConcurrentException ex)
32 {
33 throw new ConcurrentException(ex);
34 }
35 }
36 }
有什么问题？
目前来说还觉得不错，如果 C# 编译器或 CLR 能支持异常契约就好了，Java 虽然支持，但是对于调用者来说又不太友好。
这里给出答案
当异常是契约的一部分时，才需要包装异常。
可能还会有其它答案，等我再思考思考，朋友们也可以给出一些想法。
微软的一个反例
MethodBae.Invoke
1 // System.Reflection.TargetInvocationException: 2 // 调用的方法或构造函数引发异常。 3 // 4 // System.MethodAccessException: 5 // 调用方没有调用此构造函数的权限。 6 // 7 // System.InvalidOperationException: 8 // 声明此方法的类型是开放式泛型类型。 即，System.Type.ContainsGenericParameters 属性为声明类型返回 true。 9 public abstract object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture);
当方法内部抛出异常时，Invoke 会将内部异常给包装起来，这明显不是我们期望的行为，后来微软的 dynamic 调用 和 CreateDelegate 之后使用 Delegate 调用 都修复了这个问题。
备注
最近在读第四版的 clr via c#，确实是一部好书，关于异常作为契约部分的想法，和作者产生了很大的共鸣，书中对异常处理的讲解非常细致，推荐大家读一读这本书。
log4.net 自定义日志文件名称
插件化项目中，遇到这样一个需求，每个插件 或者每个方法 一个日志文件，方便后期错误排查
源码地址： https://github.com/xlb378917466/SharpHttpServerCase.git
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
using
System;
using
System.Collections.Generic;
using
System.Linq;
using
System.Text;
using
System.Collections.Concurrent;
using
System.Configuration;
using
log4net;
using
log4net.Appender;
using
log4net.Core;
using
log4net.Layout;
using
log4net.Repository;
using
log4net.Repository.Hierarchy;
[assembly: log4net.Config.XmlConfigurator(Watch =
true
)]
namespace
TechSvr.Utils
{
public
static
class
CustomRollingFileLogger
{
private
static
readonly
ConcurrentDictionary<
string
, ILog> loggerContainer =
new
ConcurrentDictionary<
string
, ILog>();
//默认配置
private
const
int
MAX_SIZE_ROLL_BACKUPS = 20;
private
const
string
LAYOUT_PATTERN =
"%newline记录时间：%date% 描述：%message%newline"
;
private
const
string
DATE_PATTERN =
"yyyyMMdd"
;
private
const
string
MAXIMUM_FILE_SIZE =
"2MB"
;
private
const
string
LEVEL =
"ALL"
;
public
static
ILog GetCustomLogger(
string
loggerName,
string
category =
null
,
bool
additivity =
false
)
{
return
loggerContainer.GetOrAdd(loggerName,
delegate
(
string
name)
{
RollingFileAppender newAppender = GetNewFileApender(loggerName, GetFile(category, loggerName), MAX_SIZE_ROLL_BACKUPS,
true
,
true
, MAXIMUM_FILE_SIZE, RollingFileAppender.RollingMode.Composite,
DATE_PATTERN, LAYOUT_PATTERN);
log4net.Repository.Hierarchy.Hierarchy repository = (log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository();
Logger logger = repository.LoggerFactory.CreateLogger(repository, loggerName);
logger.Hierarchy = repository;
logger.Parent = repository.Root;
logger.Level = GetLoggerLevel(LEVEL);
logger.Additivity = additivity;
logger.AddAppender(newAppender);
logger.Repository.Configured =
true
;
return
new
LogImpl(logger);
});
}
//如果没有指定文件路径则在运行路径下建立 Log\{loggerName}.txt
private
static
string
GetFile(
string
category,
string
loggerName)
{
if
(
string
.IsNullOrEmpty(category))
{
return
string
.Format(
@"Logs\{0}.txt"
, loggerName);
}
else
{
return
string
.Format(
@"Logs\{0}\{1}.txt"
, category, loggerName);
}
}
private
static
Level GetLoggerLevel(
string
level)
{
if
(!
string
.IsNullOrEmpty(level))
{
switch
(level.ToLower().Trim())
{
case
"debug"
:
return
Level.Debug;
case
"info"
:
return
Level.Info;
case
"warn"
:
return
Level.Warn;
case
"error"
:
return
Level.Error;
case
"fatal"
:
return
Level.Fatal;
}
}
return
Level.Debug;
}
private
static
RollingFileAppender GetNewFileApender(
string
appenderName,
string
file,
int
maxSizeRollBackups,
bool
appendToFile =
true
,
bool
staticLogFileName =
false
,
string
maximumFileSize =
"2MB"
, RollingFileAppender.RollingMode rollingMode = RollingFileAppender.RollingMode.Size,
string
datePattern =
"yyyyMMdd\".txt\""
,
string
layoutPattern =
"%d [%t] %-5p %c - %m%n"
)
{
RollingFileAppender appender =
new
RollingFileAppender
{
LockingModel =
new
FileAppender.MinimalLock(),
Name = appenderName,
File = file,
AppendToFile = appendToFile,
MaxSizeRollBackups = maxSizeRollBackups,
MaximumFileSize = maximumFileSize,
StaticLogFileName = staticLogFileName,
RollingStyle = rollingMode,
DatePattern = datePattern
};
PatternLayout layout =
new
PatternLayout(layoutPattern);
appender.Layout = layout;
layout.ActivateOptions();
appender.ActivateOptions();
return
appender;
}
}
}
|
使用方法
|
1
2
3
4
5
6
|
public
static
Log GetLogger(
string
filename =
"Log"
)
{
ILog logger = CustomRollingFileLogger.GetCustomLogger(filename, DateTime.Now.ToString(
"yyyyMMdd"
));
return
new
Log(logger);
}
|