基于.net standard 的动态编译实现代码

在上篇文章[]结尾处，提到了如何方便自动的生成微服务的客户端代理，使对于调用方透明，同时将枯燥的东西使用框架集成，以提高使用便捷性。在尝试了基于 emit 中间语言后，最终决定使用生成代码片段然后动态编译的模式实现。

1.背景:

其一在前文中，我们通过框架实现了微服务面向使用者的透明调用，但是需要为每个服务写一个客户端代理，显得异常繁琐，其二项目中前端站点使用了传统的.net framework 框架，后端微服务我们使用了.net core 框架改造，短时间将前端站点调整成 .net core 框架亦不现实，为了能同时支持这两种框架。如何 .net standard 框架来自动创建微服务的客户端代理成为我们必须解决的问题。

2.问题转化

我们在回头简单看一下我们现在期望的微服务客户端代理长的样子：

        通过上面分析，我们只需要将服务接口中的每个方法，判断是否有返回值，如果有返回值调用invoke<returntype>方法，没有返回值调用invokewithoutreturn方法，然后依次将接口名，方法名以及方法的参数按顺序传入即可。各位如果是熟悉java的同学，这个问题很容易解决，使用动态代理创建一个这样的匿名类即可，但在.net 的世界里，动态代理的实现确显得异常麻烦。
       首先想到是通过中间语言 il 的 emit 实现，但无奈这个使用起来实在是太不友好了， 几经折腾最终还是选择放弃了，后又想到其实可以通过动态生成这个代码片段，动态编译后加载到系统程序集中，应该就可以了。于是在这个方向的指引下，我们尝试着去一步步实现这个问题。

3.解决方案

如何生成这个代码片段？ 通过上面的分析，我们知道只需要将接口反射获取其中的公共方法，并将接口的每个方法签名原样复制，在根据接口方法是否有返回值分别调用remoteserviceproxy基类中相关方法即可，不过需要特殊注意的泛型方法翻译，以下是生成这个代码片段的参考实现.

寻找出为服务接口程序集文件，并处理每个文件

private static stringbuilder createapiproxycode()
{
 var path = getbinpath();
 var dir = new directoryinfo(path);
 //获取项目中微服务接口文件
 var files = dir.getfiles("xzl*.api.dll");
 var codestringbuilder = new stringbuilder(1024);
 //添加必要的using
 codestringbuilder
 .appendline("using system;")
 .appendline("using system.collections.generic;")
 .appendline("using system.text;")
 .appendline("using xzl.infrastructure.apiservice;")
 .appendline("using xzl.infrastructure.defines;")
 .appendline("using xzl.model;")
 .appendline("namespace xzl.apiclientproxy")
 .appendline("{"); //namespace begin
 //处理每个文件中的接口信息
 foreach (var file in files)
 {
 createapiproxycodefromfile(codestringbuilder, file);
 }
 codestringbuilder.appendline("}"); //namespace end
 return codestringbuilder;
}

处理每个文件中的接口类型，并将每个程序集的依赖程序集找出来，方便后面动态编译

private static void createapiproxycodefromfile(stringbuilder filecodebuilder, fileinfo file)
 {
 try
 {
 assembly apiassembly = assembly.load(file.name.substring(0, file.name.length - 4));
 var types = apiassembly
 .gettypes()
 .where(c => c.isinterface && c.ispublic)
 .tolist();
 var apisvctype = typeof(iapiservice);
 bool isneed = false;
 foreach (type type in types)
 {
 //找出期望的接口类型
 if (!apisvctype.isassignablefrom(type))
 {
 continue;
 }
 //找出接口的所有方法
 var methods = type.getmethods(bindingflags.public 
 | bindingflags.flattenhierarchy 
 | bindingflags.instance);
 if (!methods.any())
 {
 continue;
 }
 //定义代理类名,以及实现接口和继承remoteserviceproxy
 filecodebuilder.appendline($"public class {type.fullname.replace(".", "_")}proxy :" +
  $"remoteserviceproxy, {type.fullname}")
 .appendline("{"); //class begin
 //处理每个方法
 foreach (var mth in methods)
 {
 createapiproxycodefrommethod(filecodebuilder, type, mth);
 }
 filecodebuilder.appendline("}"); //class end
 isneed = true;
 }
 if (isneed)
 {
 var apirefasms = apiassembly.getreferencedassemblies();
 refassemblylist.add(apiassembly.getname());
 refassemblylist.addrange(apirefasms);
 }
 }
 catch
 {
 }
 }

处理接口中的每个方法

private static void createapiproxycodefrommethod(
 stringbuilder filecodebuilder, 
 type type,
 methodinfo mth)
{
 var ismthreturn = !mth.returntype.equals(typeof(void));
 filecodebuilder.append("public ");
 //添加返回值
 if (ismthreturn)
 {
 filecodebuilder.append(getfriendlytypename(mth.returntype)).append(" ");
 }
 else
 {
 filecodebuilder.append(" void ");
 }
 //方法参数开始
 filecodebuilder.append(mth.name).append("("); 
 var mthparams = mth.getparameters();
 if (mthparams.any())
 {
 var mthparalist = new list<string>();
 foreach (var p in mthparams)
 {
 mthparalist.add(getfriendlytypename(p.parametertype) + " " + p.name);
 }
 filecodebuilder.append(string.join(",", mthparalist));
 }
 //方法参数结束
 filecodebuilder.append(")");
 //方法体开始
 filecodebuilder.appendline("{"); 
 if (ismthreturn)
 {
 //返回值
 filecodebuilder.append("return invoke<")
 .append(getfriendlytypename(mth.returntype))
 .append(">");
 }
 else
 {
 filecodebuilder.append(" invokewithoutreturn");
 }
 //拼接接口名及方法名
 filecodebuilder.append($"(\"{type.fullname}\",\"{mth.name}\"");
 //方法本身参数
 if (mthparams.any())
 {
 filecodebuilder.append(",").append(string.join(",", mthparams.select(t => t.name)));
 }
 filecodebuilder.append(");");
 //方法体结束
 filecodebuilder.appendline("}"); 
}

获取泛型类型字符串

private static string getfriendlytypename(type type)
{
 if (!type.isgenerictype)
 {
 return type.fullname;
 }
 string friendlyname = type.name;
 int ibacktick = friendlyname.indexof('`');
 if (ibacktick > 0)
 {
 friendlyname = friendlyname.remove(ibacktick);
 }
 friendlyname += "<";
 type[] typeparameters = type.getgenericarguments();
 for (int i = 0; i < typeparameters.length; ++i)
 {
 string typeparamname = getfriendlytypename(typeparameters[i]);
 friendlyname += (i == 0 ? typeparamname : "," + typeparamname);
 }
 friendlyname += ">";
 return friendlyname;
}

如何添加依赖

既然是要编译源码，那么源码中的依赖必不可少，在上一步中我们已经将每个程序集的依赖一并找出，接下来我们将这些依赖全部整理出来

//缓存程序集依赖
 var references = new list<metadatareference>(); 
 var refasmfiles = new list<string>();
 //系统依赖
 var sysreflocation = typeof(enumerable).gettypeinfo().assembly.location;
 refasmfiles.add(sysreflocation);
 //refasmfiles原本缓存的程序集依赖
 refasmfiles.add(typeof(object).gettypeinfo().assembly.location);
 refasmfiles.addrange(refassemblylist.select(t => assembly.load(t).location).distinct().tolist());
 //传统.netframework 需要添加mscorlib.dll
 var coredir = directory.getparent(sysreflocation);
 var mscorlibfile = coredir.fullname + path.directoryseparatorchar + "mscorlib.dll";
 if (file.exists(mscorlibfile))
 {
 references.add(metadatareference.createfromfile(mscorlibfile));
 }
 var apiasms = refasmfiles.select(t => metadatareference.createfromfile(t)).tolist();
 references.addrange(apiasms);
 //当前程序集依赖
 var thisassembly = assembly.getentryassembly();
 if (thisassembly != null)
 {
 var referencedassemblies = thisassembly.getreferencedassemblies();
 foreach (var referencedassembly in referencedassemblies)
 {
 var loadedassembly = assembly.load(referencedassembly);
 references.add(metadatareference.createfromfile(loadedassembly.location));
 }
 }

编译

有了代码片段, 也有了编译程序集依赖, 接下来就是最重要的编译了.

//定义编译后文件名
var path = path.combine(appdomain.currentdomain.basedirectory, "proxy");
if (!directory.exists(path))
{
 directory.createdirectory(path);
}
var apiremoteproxydllfile = path.combine(path, 
 apiremoteasmname + datetime.now.tostring("yyyymmddhhmmssfff") + ".dll");
var tree = syntaxfactory.parsesyntaxtree(codebuilder.tostring());
var compilation = csharpcompilation.create(apiremoteasmname)
 .withoptions(new csharpcompilationoptions(outputkind.dynamicallylinkedlibrary))
 .addreferences(references)
 .addsyntaxtrees(tree);
//执行编译
emitresult compilationresult = compilation.emit(apiremoteproxydllfile);
if (compilationresult.success)
{
 // load the assembly
 apiremoteasm = assembly.loadfrom(apiremoteproxydllfile);
}
else
{
 foreach (diagnostic codeissue in compilationresult.diagnostics)
 {
 string issue = $"id: {codeissue.id}, message: {codeissue.getmessage()}," +
 $" location: { codeissue.location.getlinespan()}, " +
 $"severity: { codeissue.severity}";
 appruntimes.instance.loger.error("自动编译代码出现异常," + issue);
 }
}

结语

在经过以上处理后，虽算不上完美，但顺利的实现了我们期望的样子，在之前的getservice中，当发现属于远程服务的时候，只需要类似如下形式返回代理对象即可。同时为增加调用更加顺畅，我们将此编译的时机定在了发生在程序启动的时候，ps 当然或许还有一些其他更合适的时机.

static concurrentdictionary<string, object> svcinstance = new concurrentdictionary<string, object>();
var typename = "xzl.apiclientproxy." + typeof(tservice).fullname.replace(".", "_") + "proxy";
object obj = null;
if (svcinstance.trygetvalue(typename, out obj) && obj != null)
{
 return (tservice)obj;
}
try
{
 obj = (tservice)apiremoteasm.createinstance(typename);
 svcinstance.tryadd(typename, obj);
}
catch
{
 throw new icvipexception($"未找到 {typeof(tservice).fullname} 的有效代理");
}
return (tservice)obj;

总结

以上所述是小编给大家介绍的基于.net standard 的动态编译实现代码，希望对大家有所帮助