C# 插件热插拔 .NET：何时应该 “包装异常”？ log4.net 自定义日志文件名称...

阅读量：5905 次

发布时间：2019-06-19

本文共 9398 字，大约阅读时间需要 31 分钟。

所谓热插拔就是插件可以

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

网上有很多方案：

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 Test11 {12     class Program13     {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（我估计是，还没有看源代码，测试结果是）。

框架地址：

博客地址：

----

背景

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

“包装异常” 的技术形式

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

1             try2             {3                 // do something4             }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
          
            2     { 3         void Update(TEntity entity); 4     } 5  6     class EntityFrameworkRepository
           
             : IRepository
            
              7     { 8         public void Update(TEntity entity) 9         {10             throw new EntityFrameworkConcurrentException(); // 可能会抛出这样的异常，这里的代码不是十分准确。11         }12     }13 14     class NHibernateRepository
             
               : IRepository
              
               15     {16         public void Update(TEntity entity)17         {18             throw new NHibernateConcurrentException(); // 可能会抛出这样的异常，这里的代码不是十分准确。19         }20     }

有什么问题？

处理并发异常是应用层开发人员的一个非常重要的职责，他们或者选择自动重试、或者选择让用户重试、甚至允许并发带来的不一致性，如果使用了上面的接口问题就大了，应用中该拦截哪种并发异常呢？EntityFrameworkConcurrentException？NHibernateConcurrentException？这样的接口和实现无论如何都达不到：OCP 和 LSP。

将异常作为契约的一部分

实现伪代码

1     interface IRepository
          
            2     { 3         void Update(TEntity entity); 4     } 5  6     class ConcurrentException : Exception 7     { 8     } 9 10     class EntityFrameworkRepository
           
             : IRepository
            
             11     {12         public void Update(TEntity entity)13         {14             try15             {16             }17             catch (EntityFrameworkConcurrentException ex)18             {19                 throw new ConcurrentException(ex);20             }21         }22     }23 24     class NHibernateRepository
             
               : IRepository
              
               25     {26         public void Update(TEntity entity)27         {28             try29             {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#，确实是一部好书，关于异常作为契约部分的想法，和作者产生了很大的共鸣，书中对异常处理的讲解非常细致，推荐大家读一读这本书。

框架地址：

博客地址：

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

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

                                           
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);
      
}
              
            