新普京网站-澳门新普京 > 前端 > 中利用运行时编译实现泛函

中利用运行时编译实现泛函

2019/12/30 02:48

引言

我想要分享一个新模式,我开发来用于在 C# 中利用运行时编译进行泛型计算。

过去的几年里我已经在编程并且看到许多在 C# 中实现泛型数学的例子,但是没有一个能做得非常地好。在第一部分中我将一步步地解说我看到的一些例子,同时也会说明为什么他们没有向泛函提供好的模式。

我开发了这个模式以作为我的 Seven Framework 框架工程的一部分。如果你感兴趣的话你可以点击:

C#与Java的比较

 

摘自:

 

 

.NET(C#)

 

Java

 

基本类型

 

基本类型

C#中有无符号数,Java没有。

C#中有值类型,且可自己定义值类型的结构体(struct)。
Java中的基本类型(或叫基元类型)即为值类型,但Java没有结构体,所以不能自定义值类型。
C#中的值类型(包括所有基本类型)间接继承自Object,有自己的方法可以调用;Java中的值类型(即基本类型)不继承自Object,只是简单的数据,没有方法可以调用。

C#中int等同于System.Int32,是值类型;bool等同于System.Boolean;等。
Java中int是基本类型,是值类型,而Integer是引用类型,Integer是int的包装器,int自身没有方法,Integer有一些方法;int与Integer之间可隐式转换(导致装箱和拆箱),但当Integer值为null的时候会在运行时抛出异常。boolean等类似。

Java中的int与Integer的对应在C#中类似int和Nullable<int>的对应,它们的后者都是前者的包装,且后者可以等于null。但Nullable<int>实际上仍然是值类型的(所以仍然很轻量级),所以从内存上讲C#中int和Object的对应更接近Java的对应一些。C#中Nullable<int>到int的转换必须显式进行,因为Nullable<int>中的值为null时会引发运行时异常。
其他基本类型与之类似。

 

 

委托,事件

 

[无]

C#中的委托可以认为是方法的类型化,于是可以将方法放在变量里传递。事件是对委托做了一层包装。
Java通过接口来实现C#中委托和事件的功能,可通过匿名类来达到C#中匿名委托的作用(同样也能实现闭包的功能)。
另,C#中也有匿名类,但C#中的匿名类只有数据没有方法。

 

 

非托管

 

[无]

C#可以有非托管代码,可以有指针等。Java没有。

 

 

索引器

 

[无]

C#有索引器,可方便容器类实现类似数组的效果。Java没有,Java的容器基本上用put,get,set等方法达到同样效果。

 

 

属性

 

[无]

C#的属性通过在内部定义get/set方法,使外部使用时像是在使用变量字段,但其实是在调用get/set方法,以达到透明的封装数据的目的。
Java没有属性的概念。Java通过约定为字段XX添加getXX,setXX方法达到同样的目的。

 

 

预编译指令

 

[无]

C#有预编译指令可方便调试,且有ConditionalAttribute来描述方法。Java没有。

 

 

操作符重载

 

[无]

C#可重载操作符。Java没有。

Java自己重载了String的+和+=,但没有重载==,这是我这段时间犯的最多的错误。C#中String的==是比较值相等,Java中==是Object的默认行为:比较引用相等,要比较值相等得用equals方法。(这么多年编程以来,我似乎从来没有遇到过要比较两个字符串变量的引用相等。对于比较值相等来讲,==符号比equals方法调用看上去优雅得多,况且方法调用还得注意空指针的情况)

 

 

内部类

 

内部类

Java的内部类可以直接访问外部类的实例成员。
C#的不行。C#的内部类等同于Java的静态内部类。

 

 

goto、switch

 

[goto]、switch

C#允许用goto。Java的goto是保留关键字,不能使用。但Java允许有标签,在有嵌套循环时可以在continue、break后面跟标签名。

C#的switch可以使用long、String;Java不可以。

Java的switch中的case子句在后面没有跟break的情况下直接跳到下一个case子句;
C#中只有在前一个case没有任何代码的情况下才允许不写break直接跳到下一个case,C#中可以通过goto跳转到另一case。

 

 

enum

 

enum

C#中的枚举是值类型,且其基于数值类型(默认基于int),可设置枚举项对应的数字,不能在其中添加方法等任何其他成员。
Java中的枚举是引用类型(Java除了基本类型外,任何类型都是引用类型),不是基于数值类型。除了不能继承外,它跟普通类差别不大,可以添加成员方法和成员变量等(当然也就可以重写toString方法)。

C#和Java的枚举都可以用于switch。

可以将C#的枚举作为数值看待而直接进行位运算,因此可以在一个变量中存储多个位标记。
Java的枚举跟数值没有直接关系,因此不能直接这么用。Java用EnumSet来存储枚举标志,不需要直接使用位运算,更远离底层。

 

 

override

 

@Override

C#能被重写的方法必须添加virtual关键字声明为虚方法,派生类重写子类方法时添加override关键字。
Java默认方法都可被重写,派生类和子类方法签名一样时被认为是重写。要声明不能被重写的方法需在方法前加final关键字。重写时可以在方法前添加标注(即C#中的定制特性)@Override,这样一旦此方法找不到被重写的方法时编译器会报错,以防止拼写错误。

 

 

定制特性

 

标注

C#用中括号[]将定制特性括起来。Java用@打头,后面跟定制特性的名字。

 

 

泛型

 

泛型

Java中泛型实现使用的擦除机制,为类型参数传入类型并不导致新类型出现,即传入了类型参数后在运行时仍然完全不知道类型参数的具体类型,它的目的是为了兼容非泛型(所以可以在泛型和非泛型之间隐式转换,会有编译警告但不会有编译错误,这当然其实并不安全);这同时衍生了一系列问题:不能定义泛型类型参数的数组如T[],不能通过new T()的方式实例化泛型,等。
Java的泛型不支持值类型(使用的话会被自动包装成引用类型)。

 

C#的泛型在类型参数传入类型后会产生一个新类型(虽然CLR的优化机制会使引用类型共享同样的代码),可以在运行时得到类型参数的类型信息。可以定义泛型数组,可以添加约束使其可以new。C#的泛型可以使用值类型(不会被装箱)。

对于Java的泛型,简单的讲,它的好处只在编译时,运行时没有任何泛型的意义。当你在使用已有的泛型类时,这通常能满足要求;但如果你要自己定义泛型类,那你得知道它有多少你觉得它应该可以但事实上不可以的事情。

 

 

 

参数引用传递

 

[无]

C#允许使用关键字out,ref显式指定参数传递方式为引用传递。
Java只有值传递。

 

 

@字符串

 

[无]

C#在写字符串时可以在引号前加个@符号来取消/的转义作用。
Java没有。

 

 

??

 

[无]

C#的??二元操作符当前面的表达式不为null时返回前面表达式的值,前面表达式为null时返回后面表达式的值。
Java没有。

 

 

using

 

import

C#可以用using为命名空间或类指定别名。(using还有Dispose的使用方式,与命名空间无关)
Java的import可以引入类或包(即C#的命名空间),static import可以引入类的成员。

 

 

初始化

 

初始化

C#调用基类构造函数的语法为:
SubClass() : base() { }
Java调用基类构造函数的语法为:
SubClass(){
   super();
}
C#和Java都可以用类似的语法调用同一个类的其他构造函数。(分别将base和super换成this)

Java有代码块概念,会在构造函数之前执行(基类的构造函数之后)。

在成员变量声明时赋值,Java允许其赋值表达式中引用前面声明的另一个变量,如:
private int x = 1;
private int y = x + 10;
这里变量y的赋值语句有变量x。
C#不允许这样做。

 

 

interface

 

interface

Java的接口内允许有内部类、静态字段等。
C#不允许。

 

 

readonly,const

 

final

C#的const是绝对的常量,必须在声明语句中同时赋值,只有数值、枚举和String可以声明为const。const的值会内联到各个使用的地方。
C#的readonly表示变量在构造函数执行完之后是不能再变化的。它只约束变量本身,而无法约束变量引用(如果它是引用类型或者有成员是引用类型)的对象。

Java中的final(在约束变量的时候)看上去更像readonly。
但C#的readonly和const有个区别,readonly的int是不能作为switch的case语句的,const的可以。
而Java的final则是:有时候可以有时候不可以----编译时可以得到明确值的可以,反之不可以。如:
final int x = 1;   // 这个可以
final int y = new Random().nextInt();   // 这个不可以
那么可以理解为:编译时能得到明确值的时候,final等同于C#的const;编译时无法得到明确值的时候,final等同于C#的readonly。

 

 

[无]

 

throws

Java在可能抛出异常时,除了RuntimeException(包括派生类),都要么捕获,要么在方法声明中用throws关键字声明出来表示继续抛出。
C#没有采用这种强制处理机制。

 

 

 

功能相同但语法有差异的

namespace == package (Java的package对文件结构也有要求;C#没有)

internal == [默认] (Java中不写访问修饰符即表示访问权限是package;C#默认是private。C#的internal protected在Java中没有。)

lock == synchronized (Java中synchronized可以修饰方法,C#可以用定制特性[MethodImplAttribute(MethodImplOptions.Synchronized)]达到同样效果)

 : == extends,implements

base == super

is == instanceof (C#有as,Java没有)

typeof == .class

[SerializableAttribute]定制特性 == Serializable接口

[NonSerializedAttribute]定制特性 == transient

params == ... (可变数目参数)

 

 

这个列表里,Java比C#更漂亮的地方基本上只有一处:枚举。Java的枚举更高层一些,更灵活。但内存代价比C#的枚举要高,这可能就是Android里仍然使用常量而不是枚举的原因吧。
所以就从这次比较来讲,C#几乎完胜Java,而C#的新特性像完美的类型推断、动态编程特性、Lambda表达式、LINQ等等这里都没有列入比较。

当然,.NET和Java两大体系的比较,语言只是一个方面,还有平台、IDE、开源等其他很多方面,这里就不说了。

代码

这是我目前的一个通用的数学模式的版本:

using Microsoft.CSharp; using System; 
using System.CodeDom.Compiler; 
using System.Reflection; 
namespace RuntimeCodeCompiling {   
public static class Program   
{     
public static Action action;     
public static void Main(string[] args)     
{       
Console.WriteLine("Sum(double): " + Generic_Math<double>.Sum(new double[] { 1, 2, 3, 4, 5 }));
Console.WriteLine("Sum(int): " + Generic_Math<int>.Sum(new int[] { 1, 2, 3, 4, 5 }));       
Console.WriteLine("Sum(decimal): " + Generic_Math<decimal>.Sum(new decimal[] { 1, 2, 3, 4, 5 }));       
Console.ReadLine();     
}     
#region Generic Math Library Example     
public static class Generic_Math<T>     
{       
public static Func<T[], T> Sum = (T[] array) =>       
{ // This implementation will make this string be stored in memory during runtime, 
//so it might be better to read it from a file         
string code = "(System.Func<NUMBER[], NUMBER>)((NUMBER[] array) => 
{ NUMBER sum = 0; for (int i = 0; i < array.Length; i++) sum += array[i]; return sum; })";         
// This requires that "T" has an implicit converter from int values and a "+" operator         
code = code.Replace("NUMBER", typeof(T).ToString());         
// This small of an example requires no namspaces or references         
Generic_Math<T>.Sum = Generate.Object<Func<T[], T>>(new string[] { }, new string[] { }, code); 
return Generic_Math<T>.Sum(array);       
};     
}     
/// <summary>Generates objects at runtime.</summary>     
internal static class Generate    
 {
/// <summary>Generates a generic object at runtime.</summary>       
/// <typeparam name="T">The type of the generic object to create.</typeparam>      
/// <param name="references">The required assembly references.</param>       
/// <param name="name_spaces">The required namespaces.</param>       
/// <param name="code">The object to generate.</param>       
/// <returns>The generated object.</returns>       
internal static T Object<T>(string[] references, string[] name_spaces, string code)       
{
string full_code = string.Empty;         
if (name_spaces != null)           
for (int i = 0; i < name_spaces.Length; i++)             
full_code += "using " + name_spaces[i] + ";";         
full_code += "namespace Seven.Generated 
{";         
full_code += "public class Generator 
{";         
full_code += "public static object Generate() 
{ return " + code + "; } } }";         
CompilerParameters parameters = new CompilerParameters();         
foreach (string reference in references)           
parameters.ReferencedAssemblies.Add(reference);        
 parameters.GenerateInMemory = true;         
CompilerResults results = new CSharpCodeProvider().CompileAssemblyFromSource(parameters, full_code);         
if (results.Errors.HasErrors)         
{           
string error = string.Empty;           
foreach (CompilerError compiler_error in results.Errors)             
error += compiler_error.ErrorText.ToString() + "/n";           
throw new Exception(error);         
}         
MethodInfo generate = results.CompiledAssembly.GetType("Seven.Generated.Generator").GetMethod("Generate");         
return (T)generate.Invoke(null, null);       
}     
}    
#endregion   
} }

代码工作原理:

如果通用数学代码存储为一个字符串,可以使用 string hacking(又名macros aka string replace),以改变运行时的代码。我们可以写一个函数,然后在使用该函数时改变该函数的类型。因此,我们可以认定泛型有必须的数学操作符来实现该函数。

在第一次调用函泛时,它会构建自己和重新自动分配。这样,我们就不必处理一个愚蠢的构造函数,它只须要根据我们所需构造泛函即可。

据我所知,你不能编译使用运行时编译器编译单个对象,我只是编译了一个返回我需要的值类型的方法。可能存在替代方法,尤其是当你使用序列化技术的时候,但是我不是很熟悉学历恶化格式,所以这种方法对我来说可能更容易。
优点:

  1. 每一种类型只需要代码的一个版本。
  2. 有没有构造方法或设置方法调用,方法会像我们所希望的那样自我构造。
  3. 快!这种方法据我所知唯一的开销调用委托的开销。

小缺点:(这些“缺点”可以克服)
1.它可以是恼人的编写通用的数学函数作为一个字符串。 解决办法:我建议在单独的文件编写通用代码并解析。这样的字符串不是永久被保存在内存,你仍然可以编辑它,就像在 Visual Studio 中使用标准的C#一样。

2.这不是一个跨平台的例子。补丁:它很容易实现跨平台功能。根据他们的网站所述,这像一个包含反射和运行时编译库的 Mono 项目。因此只要动态查找运行时编译器就能让“生成的”功能类跨平台。

3.如果泛型的“typeof(T).ToString()”被嵌入到泛型中,现在的这些代码将会崩溃。补丁:使用某种类型创建一个函数 再创建一个适当的字符串来表示这种类型达到和原始代码一样的目的。

4.我们还是有编译错误。告诉我们有自定义类型”struct Fraction128“忘记重载”+“运算符。同时也会抛出运行时错误。补丁:这个问题可以通过在编译时写一个 VS 插件去检测泛函运算中使用的类型是否包含基本数值操作符而被修复。我只是把这些问题指出来告诉你们它是可修复的,我不会去做这些。到用的时候,不要干蠢事,:P

问题概述

首先,根本的问题是在 C# 中处理泛型就像基类一样。除了 System.Object 基类,他们都没有隐式成员。也就是说,相对于标准数值类型(int,double,decimal,等)他们没有算数运算符和隐式转换。EXAMPLE 1 是一种理想情况,但是这段代码在标准 C# 中是不能编译的。

// EXAMPLE 1 ---------------------------------------- 
namespace ConsoleApplication 
{   public class Program   
    {  public static void Main(string[] args)     
       {  Sum<int>(new int[] { 1, 2, 3, 4, 5 });     }     
    public static T Sum<T>(T[] array)     
     {  T sum = 0; // (1) cannot convert int to generic       
        for (int i = 0; i < array.Length; i++)         
        sum += array[i]; // (2) cannot assume addition operator on generic       
        return sum;     }   
               } 
}

确实如此,EXAMPLE 1 不能通过编译因为:

  1. 类型”T”不能确保int数值的隐式转换。
  2. 类型”T”不能确保一个加法操作。

现在我们了解了根本问题后,让我们开始寻找一些方法克服它。

接口化解决方法

C#中的 where 子句是一种强迫泛型满足某种类型的约束。然而,用这种方法就要求有一种不存在于C#中的基本数值类型。C#有这样一种基本数值类型是最接近强制泛型成为数值类型的可能了,但这并不能在数学上帮助我们。EXAMPLE 2 仍然不能够通过编译,但如果我们创造出了我们自己的基本数值类型,这将成为可能。

Hide Copy Code

// EXAMPLE 2 ---------------------------------------- 
namespace ConsoleApplication {   
public class Program   
{     
public static void Main(string[] args)    
{       
Sum<int>(new int[] { 1, 2, 3, 4, 5 });     
}     
public static T Sum<T>(T[] array)       
where T : number  // (1) there is no base "number" type in C#     
{       T sum = 0;       
for (int i = 0; i < array.Length; i++)         
sum += array[i];       
return sum;     }   
} 
}

现在 EXAMPLE 2 还不能编译因为:

  1. 在C#中没有基本“数值”类型。

如果我们实现了我们自己的基本“数值”类型,就可以让它通过编译。我们所必需做的就是迫使这个数值类型拥有C#基本数值类型一般的算数运算符和隐式转换。逻辑上来讲,这应该是一个接口。

然而,即使我们自己做数值接口,我们仍然有一个重大问题。我们将不能够对 C# 中的基本类型做通用数学计算,因为我们不能改变 int,double,decimal 等的源代码来实现我们的接口。所以,我们不仅必须编写自己的基本接口,还需要为C#中的原始类型编写包装器。
在例3中,我们有我们自己的数值接口,“数字”,和原始类型int的包装器,Integer32。

// EXAMPLE 3 ---------------------------------------- 
namespace ConsoleApplication 
{   
public class Program   
{     
public static void Main(string[] args)     
{       
Sum(new Number[]       
{         
new Integer32(1), // (1) initialization nightmares...         
new Integer32(2),          
new Integer32(3),         
new Integer32(4),         
new Integer32(5)       
});    
 }     
public static Number Sum(Number[] array)     
{       
Number sum = array[0].GetZero(); // (2) instance-based factory methods are terrible design      
for (int i = 0; i < array.Length; i++)         
sum = sum.Add(array[i]);       
return sum;     
}  
 }   
public interface Number   
{     
Number GetZero(); // (2) again... instance based factory methods are awful     
Number Add(Number other);   
}   
public struct Integer32 : Number // (3) C# primitives cannot implement "Number"   
{     
int _value;     
public Integer32(int value)     
{       
this._value = value;     
}     
Number Number.GetZero()     
{       
return new Integer32(0);     
}     // (4) you will have to re-write these functions for every single type      
Number Number.Add(Number other)     
{       
return new Integer32(_value + ((Integer32)other)._value);     
}   
} 
} // (5) this code is incredibly slow

好的,这样 EXAMPLE 3 就编译了,但是它有点糟,为什么呢:

  1. 编程时用接口初始化变量是非常丑陋的。
  2. 你不该用工厂方法或构造函数作为一个实例化方法,因为它是一种糟糕的设计并且很容易在程序各处造成空引用异常。
  3. 你不能让C#基本类型去实现“Number”接口所以只能使用自定义类型工作。
  4. 它不是泛函因为你必须每一步都写一个自定义的实现。
  5. 这段代码因封装了基本类型工作极其慢。

如果你的泛函库不能使在 C# 中完成泛型数学运算,没有人会对此买单。因此,接下里让我们处理这个问题。如果不能够修改 C# 原始数据类型去实现想要的接口,那么我们就创造另一种类型能够处理那些类型具有的所有数学运算。这就是在 .Net 框架中广泛使用的标准提供者模式。

边注/发泄:就我个人来说,我憎恨提供者模式。但我至今没有发现使用委托有处理不好的例子。当大量创建大量提供者时,他们没有使用委托。

当我们使用提供者模式,本质上仍是做和以前同样的事,但一个提供者类就能处理所有的数学运算。在EXAMPLE 4中检验它:

/EXAMPLE 4 ---------------------------------------- 
namespace ConsoleApplication 
{   
public class Program   
{     
public static void Main(string[] args)     
{      
Sum<int>(new int[] { 1, 2, 3, 4, 5}, new MathProvider_int());     
}     // (1) all the methods need access to the provider     
public static T 
Sum<T>(T[] array, MathProvider<T> mathProvider)     
{       
T sum = mathProvider.GetZero();       
for (int i = 0; i < array.Length; i++)         
sum = mathProvider.Add(sum, array[i]);       
return sum;     }   

public interface MathProvider<T>   
{     
T GetZero(); // (2) you still need instance factory methods     
T Add(T left, T right);   
}  
 public class MathProvider_int : MathProvider<int>   
{     
public MathProvider_int() { }     
int MathProvider<int>.GetZero()     
{       
return 0;     
}     // (3) you still have to implement each function for every single type      
int MathProvider<int>.Add(int left, int right)     
{       
return left + right;     
}   
} 
} // (4) can be slow depending on implementation (this version is slow)

EXAMPLE 4 通过把所有的泛函性质移动到帮助类中,我们可以使用C#基本类型执行数学运算。然而,这仅仅修复 EXMAPLE 3 中的第一个问题。我们仍旧需要解决以下问题:

  1. 所有方法都必须访问 mathProvider 类。虽然您可以编写代码,让其不必在每个函数间传递,这个原则同样适用于其它类似的结构。
  2. 你的实例化仍然基于工厂方法。在上面的情况中它是一个来自于int的转换。
  3. 在原始代码中你仍然需要为每一个简单的类型中实现泛函性。
  4. 这仍然相当慢,除非你为 provider 做一些”聪明的“缓存。provider 的传递和查找加起来真的很多。

现在我们已经尝试过在数值类型本身(EXAMPLE 3)和外部 provider(EXAMPLE 4)上使用接口。使用接口我们已经不能做更多了。可以确定的是我们可以运用一些聪明巧妙的存储方法,但最终仍会面临相同的问题:必须在每一步都支持定制的实现。

最后说一句…在 C# 中接口不适合用在高效的泛函计算中。

上一篇:没有了 下一篇:没有了