C# 插件热插拔

所谓热插拔就是插件可以

在主程序不重新启动的情况直接更新插件，

网上有很多方案：

https://www.cnblogs.com/happyframework/p/3405811.html

如下：

但是我发现有一种最简单粗暴的办法，

就是把插件加载到内存当中，然后使用Assembly从内存中加载DLL信息，

这样插件就可以直接被删除，而不会提示文件已被进程占用，而无法删除和更新的问题。

背景

如果某个“功能”需要动态更新？这种动态更新，可能是需求驱动的，也可能是为了修改 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（我估计是，还没有看源代码，测试结果是）。

框架地址：http://happy.codeplex.com
博客地址：http://www.cnblogs.com/happyframework

----

背景

提到异常，我们会想到：抛出异常、异常恢复、资源清理、吞掉异常、重新抛出异常、替换异常、包装异常。本文想谈谈 “包装异常”，主要针对这个问题：何时应该 “包装异常”？

“包装异常” 的技术形式

包装异常是替换异常的特殊形式，具体的技术形式如下：

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#，确实是一部好书，关于异常作为契约部分的想法，和作者产生了很大的共鸣，书中对异常处理的讲解非常细致，推荐大家读一读这本书。

框架地址：http://happy.codeplex.com
博客地址：http://www.cnblogs.com/happyframework

log4.net 自定义日志文件名称

插件化项目中，遇到这样一个需求，每个插件或者每个方法一个日志文件，方便后期错误排查

源码地址： https://github.com/xlb378917466/SharpHttpServerCase.git

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;

}

使用方法

public static Log GetLogger(string filename = "Log")

{

ILog logger = CustomRollingFileLogger.GetCustomLogger(filename, DateTime.Now.ToString("yyyyMMdd"));

return new Log(logger);

}