dotNet 库模块帮助文档

✨ .NET 交互指南 💻 .NET 运行时

dotNet 成员列表 #

支持库。
此命名空间下的函数由当前线程默认应用程序域提供。

无参数调用 dotNet.appDomain 构造函数可返回当前线程默认应用程序域。
导入此库时如果当前是主线程则将应用程序根目录（"/"）设为当前目录。

dotNet.buffer #

调用 raw.buffer 分配可读写的、固定长度的字节串（buffer 类型）
并返回封包 buffer 的 dotNet.object 对象。
返回对象可用下标操作符 [] 读写 8 位无符号字节数值。
可用 Value 属性获取 buffer 对象，用法请参考 raw.buffer 文档。
可用 Length 属性获取数组长度。

在 .NET 中对应类型为 byte[] 字节数组。
可作为 .NET 引用、输出参数使用。

dotNet.buffer() #

返回对象:dotNetObject

dotNet.buffer(初始值) #

创建缓冲区，参数用法与 raw.buffer 相同。
参数 @1 可以指定一个结构体、字符串、或 buffer,传入空表 {} 返回 null,
此函数将重新分配内存并复制 参数 @1 指定的初始值数据。

dotNet.buffer(长度,初始值) #

创建缓冲区，参数用法与 raw.buffer 相同。

参数一指定需要分配的内存大小,

参数 @2 可以用结构体、指针、buffer 或字符串之一指定一段内存数据作为初始值,
也可用一个数值指定填充到所有字节的初始值,不指定默认初始化所有字节为 0 ,
如果初始值指定为字符串或 buffer 类型，
填充初始数据以后多余的字节丢弃，不足的部分会填充字节码为 0，

dotNet.byte #

创建 .NET System.SByte 类型数值或数组

dotNet.byte() #

返回对象:dotNetObject

dotNet.byte(value,byRef) #

创建 .NET System.SByte 类型数值或数组，
用于存储8位整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.char #

创建 .NET System.Char 类型数值或数组

dotNet.char(value,byRef) #

创建 .NET System.Char 类型数值或数组，
用于存储 16 位无符号整数。

参数 @value 可以指定数值、字符串或数值数组。
数组参数必须是普通的 aardio 数值数组（double 类型）或 16 位无符号整型 COM 数组。
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

.NET 的 char 类型数组在 aardio 中将转换为 16 位无符号整型 COM 数组（SafeArray）。
显式调用 dotNet.char 创建 .NET 对象可避免被自动转换为 COM 数组。

dotNet.color(value,byRef) #

创建 .NET System.Drawing.Color 类型数值或数组。
.NET 的 System.Drawing.Color 类型在 aardio 中会自动转换为数值，
显式调用 dotNet.color 创建 .NET 对象可避免被自动转换。

dotNet.createArray #

创建 .NET 类型化数组。
.NET 通常要求数组类型完全匹配，可以用这个函数创建类型匹配的数组。

包含.NET 对象的普通 aardio 数组在传入 .NET 时也会临时转换为类型化数组
默认的普通数值数组传入 .NET 为 double 数组，但支持自适应转换类型。
也可以用 dotNet.double,dotNet.int 等函数创建类型化数值数组。

注意 .NET 数组对象应当用 Length 属性取数组长度而非用 #号取长度，
.NET 中的简单值类型数组在 aardio 中会转换为 com.SafeArray 数组，
com.SafeArray 数组可以用 # 取长度

dotNet.createArray(数组) #

参数 @1 请指定数组。
包含.NET 对象的普通数组返回为 .NET 类型化数组，
传入其他任何类型参数直接返回

dotNet.createArray(类型,长度...) #

参数 @1 请指定 .NET 类型，
类型通常由 dotNet.import 导入，或用 .NET 对象的 GetType 函数获取。
至少指定一个数组长度参数，可指定多个长度参数以创建多维数组

dotNet.createArrayList() #

返回对象:dotNetCrlArrayListObject

dotNet.createArrayList(初始化数组) #

创建 System.Collections.ArrayList 对象
可传递到C#函数中,C#中应声明为 object 类型,然后强制转换为 ArrayList,
可选参数一指定 table 数组用于初始化对象

dotNet.createCompiler("C#") #

使用当前线程默认应用程序域创建C#编译器

dotNet.createCompiler("VB") #

使用当前线程默认应用程序域创建VB编译器

dotNet.createCompiler() #

返回对象:dotNetCompilerObject

dotNet.createNameValueList(names,values) #

创建 List> 列表对象,
参数@name,@value 必须是长度相等的非空数组,
返回 List 对象的每个元素都具有 Name,Value 属性，
其值由 @names,@values 参数按数组索引顺序分配

dotNet.createWebService #

使用当前线程默认应用程序域创建Web服务程序集

dotNet.createWebService() #

返回对象:dotNetCrlAssemblyObject

dotNet.createWebService(服务网址,命名空间,协议名,DLL路径) #

使用当前线程默认应用程序域创建 Web 服务程序集。
服务网址不需要加 ?WSDL 后缀。
可选用参数 @2 中指定一个自定义的命名空间
协议名默认为"Soap",可选值"Soap12",
如果未使用参数 @4 指定输出 DLL 路径则在内存中编译程序集

dotNet.delegate #

用于操作 .NET 委托（Delegate）或事件（event），
在 .NET 里函数要转换为委托对象才能作为回调函数传输，
在 aardio 里对所有 .NET 对象的委托字段直接赋值总是覆盖而不是追加，
对所有 .NET 事件赋值时总是追加而不是覆盖，

返回对象:dotNetDelegateObject

dotNet.dict #

将非空表转换为 .NET 字典。
如果要创建空字典，调用返回对象的 Clear 函数清空即可。
返回对象支持用下标操作符访问键值对。
可用 dotNet.each 遍历字典。

dotNet.dict() #

返回对象:DotNetDictionaryObject

返回对象:DotNetDictionaryObject

dotNet.dict(keyType,valueType,byRef) #

参数 @keyType 指定键的 .NET 类型或类型名称。
参数 @valueType 指定值的 .NET 类型或类型名称。
如果 @valueType 指定布尔类型值，则参数 @byRef 也必须指定布尔类型的值。
参数 @byRef 为可选参数
如果 @byRef 为 true，则返回对象可作为 .NET 输出与引用参数使用

dotNet.dict(tab,byRef) #

将非空表转换为 .NET 字典（Dictionary）对象。

如果传入空表或 null 返回 null 值。
否则必须传入非空表，表中所有的键必须是相同类型。
表中所有的值必须是相同类型。

参数 @byRef 为可选参数，只能指定为布尔类型的值（true/false）或省略。
如果 @byRef 为 true，则返回对象可作为 .NET 输出与引用参数使用

dotNet.double #

创建 .NET System.Double 类型数值或数组

dotNet.double() #

返回对象:dotNetObject

dotNet.double(value,byRef) #

创建 .NET System.Double 类型数值或数组，
用于存储64位浮点数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数,

注意普通数值传入 .NET 函数时，
整数默认转为32位整数,小数默认按double类型处理

dotNet.each(netObj) #

for i,v in dotNet.each(/*输入需要遍历的 .NET 对象或普通数组，  
返回值 i 为当前索引,v 为当前值，  
注意并非所有 .NET 类型都支持此接口。  
所有 .NET 对象都提供 each 方法，其作用等效于将该对象作为参数调用 dotNet.each 以创建迭代器。*/) {

}

dotNet.float #

创建 .NET System.Single 类型数值或数组

dotNet.float() #

返回对象:dotNetObject

dotNet.float(value,byRef) #

创建 .NET System.Single 类型数值或数组，
用于存储32位浮点数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.getObject() #

如果对象是 dotNet.object 对象，
返回被 dotNet.object 封装的原生 .NET 对象（在 aardio 中存为 com.NetObject 对象 ）。
原生 com.NetObject 对象传入 com.IsNetObject 函数将返回非 0 值。

如果参数 @2 为 true，并且封包的 .NET 对象是一个 DispatchableObject 代理对象，
则通过 DispatchableObject 对象的 Value 字段获取真实的值或 .NET 对象。
如果 DispatchableObject 对象实际存储的是可转换的基础类型或 System.Object 数组，
可直接使用 dotNet.object 对象的 Value 属性取值，不必调用此函数。

传入其他类型对象或原生 com.NetObject 对象会返回 null。

dotNet.import #

加载程序集，导入 .NET 命名空间、类、枚举。
在当前应用程序域 import,load 等函数不会导入重复的程序集，
同一程序集中不会重复导入相同的命名空间。

如果已存在同名的全局命名空间但元表为空（并未导入 .NET 命名空间），
则导入 .NET 命名空间到已存在的命名空间。

如果已存在同名的全局命名空间但元表非空（通常为已导入的 .NET 命名空间 ），
则不会覆盖已存在的名字间，而是在返回值返回当前调用实际创建的命名空间。
加载程序集或依赖程序集失败时此函数会抛出异常。

dotNet.import(命名空间) #

参数 @1 必须用字符串指定要名载的命名空间。
首先加载与命名空间同名的程序集，然后导入同名的 .NET 命名空间或类。
当程序集文件名与导入名字相同时，参数 @2 不必指定程序集名称。

返回命名空间可作为类构造函数调用并创建对象。
也可以用成员操作符获取静态成员，或调用静态函数。

导入的 .NET 命名空间在正常访问其成员时会触发元方法以获取并创建下级命名空间、类、枚举等。
但导入命名空间的函数（以及 namespace 语句）创建的上级命名空间并不会主动导入同名 .NET 命名空间\。

此函数会尽可能重用已存在的 aardio 全局命名空间导入 .NET 命名空间。
如果该全局命名空间已导入其他 .NET 命名空间则不会覆盖已存在的名空间。
此函数总是会返回当前调用实际创建的命名空间。

dotNet.import(命名空间,程序集名) #

加载参数 @2 指定文件名字的程序集。
将参数 @1 指定的空间、类、枚举等导入 aardio 全局命名空间。
必须指定完整命名空间。
参数 @1 可指定命名空间也可以指定要导入的命名空间数组。

在当前应用程序域 import,load 等函数不会导入重复的程序集，
同一程序集中不会重复导入相同的命名空间。

返回命名空间可作为类构造函数调用并创建对象。
也可以用成员操作符返回静态成员，或调用静态函数。

导入的 .NET 命名空间在正常访问其成员时会触发元方法以获取并创建下级命名空间、类、枚举等。
但导入命名空间的函数（以及 namespace 语句）创建的上级命名空间并不会主动导入同名 .NET 命名空间。

此函数会尽可能重用已存在的 aardio 全局命名空间导入 .NET 命名空间。
如果该全局命名空间已导入其他 .NET 命名空间则不会覆盖已存在的名空间。
此函数总是会返回当前调用实际创建的命名空间。

dotNet.int #

创建 .NET System.Int32 类型数值或数组

dotNet.int() #

返回对象:dotNetObject

dotNet.int(value,byRef) #

创建 .NET System.Int32 类型数值或数组，
用于存储32位整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数,

注意普通数值传入 .NET 函数时，
整数默认转为32位整数,小数默认按double类型处理

dotNet.list #

此函数会调用 System.Collections.Generic.$List 实例化泛型类，
然后调用实例化的泛型类构造列表对象。
返回构造的 .NET 列表对象

dotNet.list() #

返回对象:DotNetListObject

dotNet.list(aaray,byRef) #

参数 @aaray 指定非空数组，自元素获取类型。
创建列表对象以后将会添加 参数 @aaray 指定数组的全部元素。

参数 @byRef 为可选参数，如果 @byRef 为 true，
则返回对象可作为 .NET 输出与引用参数使用

dotNet.list(typeOrTypeName,byRef) #

参数 @typeOrTypeName 指定 .NET 类名 .NET 类型名。
指定外部 .NET 程序集加载的类型名时，
必须是通过全局命名空间可访问的完整类型名。
参数 @1 也可以直接指定导入的 .NET 类型

参数 @byRef 为可选参数，如果 @byRef 为 true，
则返回对象可作为 .NET 输出与引用参数使用

dotNet.load #

使用当前线程默认应用程序域载入并返回程序集（DLL）。
在当前应用程序域如果已使用此函数导入同名程序集，
则直接返回该程序集

dotNet.load("程序集名") #

使用当前线程默认应用程序域载入并返回程序集。
参数可以是程序集（DLL）名称或路径。

此函数会按以下顺序调用 .NET 函数尝试加载程序集：
└── Assembly.LoadWithPartialName
└── Assembly.Load
└── Assembly.LoadFrom
└── Assembly.LoadFile

dotNet.load("程序集名",虚拟程序集数据或路径) #

首先在『虚拟程序集引用表』中注册程序集名，
参数 @2 指定对应的内存 DLL 数据或 DLL 路径（支持 EXE 内嵌资源）。
然后再调用 load 函数加载并返回该虚拟程序集。

注意参数 @1 指定的是程序集的文件名，不是写导入的命名空间。
调用返回程序集对象的 import 成员函数再导入命名空间

dotNet.load() #

返回对象:dotNetCrlAssemblyObject

dotNet.loadAppData #

可用于嵌入并自 %appData% 目录加载
不支持通过 loadFile 函数内存加载的程序集

dotNet.loadAppData() #

返回对象:dotNetCrlAssemblyObject

dotNet.loadAppData(path,data) #

用 @path 指定 %appData% 目录下的相对路径,
将 @data 参数指定的内存程序集数据释放到该路径,
并使用 load 函数加载此程序集,
@data 参数应在路径前加$符号使文件数据嵌入到代码中

dotNet.loadFile #

使用当前线程默认应用程序域载入程序集（DLL）。
参数可以是 DLL 路径，内存 DLL，或 EXE 内嵌资源。
此函数并不支持 『虚拟程序集引用表』，无法在内存添加依赖 DLL
程序集如果引用了自身路径必须改用 load 函数加载

dotNet.loadFile("程序集路径") #

使用当前线程默认应用程序域载入程序集,
参数可以是 DLL 路径，内存 DLL，或 EXE 内嵌资源。

在路径字符串前加$符号可将文件编译并嵌入 aardio 代码,
可选在第 2 个参数中指定 pdb 调试数据或 pdb 调试文件路径。
可用 com.dte 对象提供的 AttachProcesses 自动附加到 VS 开发环境调试进程。

dotNet.loadFile() #

返回对象:dotNetCrlAssemblyObject

dotNet.long #

创建 .NET System.Int64 类型数值或数组

dotNet.long() #

返回对象:dotNetObject

dotNet.long(value,byRef) #

创建 .NET System.Int64 类型数值或数组，
用于存储64位整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.object #

转换参数 @1 指定的 aardio 值或数组为 .NET 原生 DispatchableObject 对象，
并返回为 aardio 可操作的 dotNet.object 对象。

也可用于转换 原生 .NET 对象为 dotNet.object ，
或转换 dotNet.object 为支持引用 dotNet.object。

dotNet.object 如果存储的是 Primitive,enum,string 类型或这些类型的数组，
则可以使用 Value 属性读写值。

dotnet.object 对象支持用 tostring 转换为字符串，
如果存储的是数值则支持调用 tonumber 函数转为普通数值。

dotNet.object() #

返回对象:dotNetObject

dotNet.object(value,byRef) #

参数 @byRef 为 true 则支持 .NET 的输出或引用参数

参数 @value 如果指定纯 aardio 对象或数组。
则转换为 .NET 原生 DispatchableObject 对象，并封装为 dotNet.object 后返回。

如果参数 @1 指定 dotNet.object 对象且参数 @2 不为 true 则直接返回。
如果参数传入原生 .NET 对象且参数 @2 不为 true 则仅转换为 dotNet.object。
如果参数 @2 为 true，则这些对象都会转换为 DispatchableObject 并返回新的 dotNet.object

dotNet.reference #

在『虚拟程序集引用表』注册一个或多个虚拟程序集，
这些虚拟程序集可以是内存程序集、本地程序集、EXE 内嵌资源中的程序集。

aardio 加载的 .NET 程序找不到程序集（DLL）时，
会查找『虚拟程序集引用表』并加载已注册的虚拟 DLL。

同时复制多个 DLL 路径的方法：
在资源管理器多选 DLL 文件，按住 Shift 点右键菜单项『复制为路径』

dotNet.reference(assemblyName2pathOrData) #

在『虚拟程序集引用表』注册多个虚拟程序集（DLL）。
@assemblyName2pathOrData 指定一个表：
表的「键」为虚拟程序集短名称（ DLL 文件名 ），

键对应的「值」指定程序集内存数据或程序集路径（支持内嵌资源）。

同时复制多个 DLL 路径的方法：
在资源管理器多选 DLL 文件，按住 Shift 点右键菜单项『复制为路径』

dotNet.reference(simpleAssemblyName,pathOrData) #

在『虚拟程序集引用表』注册虚拟程序集（DLL）。
@simpleAssemblyName 指定程序集短名称（虚拟 DLL 文件名）
@pathOrData 指定程序集路径或内存数据，支持内嵌资源路径
@pathOrData 也可以是返回程序集路径或数据的回调函数

dotNet.setParent #

嵌入 .NET 窗口到 aardio 窗口，作用类似 win.setParent 函数。
此函数必须在导入 win.ui 的界面线程中使用。

嵌入 .NET 控件而不是窗口对象，
请改用 System.Windows.Forms.CreateEmbed 函数

dotNet.setParent(netForm,aarForm) #

嵌入 .NET 窗口到 aardio 窗口，并完全覆盖 aardio 窗口。
@netForm 参数指定 System.Windows.Forms.Form 对象，不能是控件，
@aarForm 参数指定 aardio 中的窗体对象或 custom 控件对象,

此函数设置 aarForm 为 netForm 的父窗口，
并禁止 aarForm 窗口绘制窗口背景，
控件自动填满 aarForm 内部并自适应窗口缩放

也可在 win.ui.ctrl 命名空间下创建自定义控件

dotNet.setParent(netForm,aarForm,false) #

仅嵌入 .NET 窗口到 aardio 窗口。
不覆盖 aardio 窗口，不自动设置窗口位置，用于创建自定义控件。
@netForm 参数指定 System.Windows.Forms.Form 对象，不能是控件，
@aarForm 参数指定 aardio 中的窗体对象或 custom 控件对象,

此函数设置 aarForm 为 netForm 的父窗口，
并禁止 aarForm 窗口绘制窗口背景，
控件自动填满 aarForm 内部并自适应窗口缩放

也可在 win.ui.ctrl 命名空间下创建自定义控件

dotNet.ubyte #

创建 .NET System.Byte 类型数值或数组

dotNet.ubyte() #

返回对象:dotNetObject

dotNet.ubyte(value,byRef) #

创建 .NET System.Byte 类型数值或数组，
用于存储8位无符号整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.uint #

创建 .NET System.UInt32 类型数值或数组

dotNet.uint() #

返回对象:dotNetObject

dotNet.uint(value,byRef) #

创建 .NET System.UInt32 类型数值或数组，
用于存储32位无符号整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.ulong #

创建 .NET System.UInt64 类型数值或数组

dotNet.ulong() #

返回对象:dotNetObject

dotNet.ulong(value,byRef) #

创建 .NET System.UInt64 类型数值或数组，
用于存储64位无符号整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.unwrapObject() #

如果对象是 dotNet.object 对象
返回被封装的原生 com.NetObject 对象,
否则直接返回参数
n
原生 com.NetObject 对象传入 com.IsNetObject 函数应返回非 0 值

dotNet.uword #

创建 .NET System.UInt16 类型数值或数组

dotNet.uword() #

返回对象:dotNetObject

dotNet.uword(value,byRef) #

创建 .NET System.UInt16 类型数值或数组，
用于存储16位无符号整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.wait #

等待 .NET 异步任务执行完成。
如果任务执行成功返回异步任务的 Result 属性，
出错返回 null，错误信息，取消返回 null,空字符串 。
范例

dotNet.wait(task,winform,...) #

参数 @1 指定异步函数返回的 System.Threading.Tasks.Task 对象。
参数 @2 指定 win.form 对象，其他可选参数传给 winform.wait 函数。
如果参数 @2 为 null （未指定值）则循环等待（不卡界面），忽略其他参数。
成功返回异步任务的 Result 属性（异步函数返回值）。失败返回 null，错误信息；取消返回 null，空字符串。

异步任务的 Result 属性可取返回值，Exception.Message 属性可取错误信息。
也可以用异步任务的 ContinueWith 方法指定异步回调函数，在任务完成后触发。

dotNet.word #

创建 .NET System.Int16 类型数值或数组

dotNet.word() #

返回对象:dotNetObject

dotNet.word(value,byRef) #

创建 .NET System.Int16 类型数值或数组，
用于存储16位整数。

参数 @value 可以为数值或数组，
参数 @byRef 为 true 则支持 .NET 的输出或引用参数

dotNet.wrapObject() #

如参数是原生 com.NetObject 对象,则返回 dotNet.object 对象，否则直接返回参数。

所有 .NET 原生对象已经自动转换为 dotNet.object 对象，
除非 .NET 调用普通 aardio 对象的成员函数而非回调特定的委托或事件函数。
这时候回调参数中的 .NET 对象需要用此函数转换，但数值和字符串不需要转换。

参数传入 com.IsNetObject 函数会返回非 0 值即为原生 com.NetObject 对象，
非原生 com.NetObject 对象转换为 dotNet.object 应当直接调用 dotNet.object 函数。

dotNetObject 成员列表 #

dotNetObject.Length #

如果 dotNet.object 对象存储的是数组，可用些属性获取数组长度。
并可以用数值下标读写指定索引的值

dotNetObject.Value #

如果 dotNet.object 对象封包的是 .NET 代理对象（DispatchableObject），
并且实际存储的是 aardio 可自动转换的基础 .NET 类型数据或者 System.Object 数组，
则在 aardio 中可以使用 Value 属性读写 DispatchableObject 真实存储的值。

可自动转换的类型支持 .NET 中的 Primitive,enum,string 类型或这些类型的数组，

注意 DispatchableObject 的 Value 属性的作用主要是将 .NET 值转换为 aardio 值，
不要取 Value 属性又传回给 .NET 函数，这会导致不必要地重复来回转换。
应当直接传 dotNet.object 对象自身给 .NET 函数。

dotNetObject.byRef(true) #

如果 dotNet.object 对象存储的是 DispatchableObject 。
则可调用此函数修改传参方式，参数用布尔值指定是否支持参数传址（作为引用或输出参数）。
如果不指定参数则获取一个表示是否支持参数传址的值。
指定参数 @1 则返回对象自身。

.NET 返回的 aardio 无法直接使用的对象会自动封包为 DispatchableObject 。
调用 dotNet.object 也可以创建 DispatchableObject。

dotNetObject.each() #

for i,v in dotNetObject.each() {
    /*遍历 .NET 集合对象，i 为迭代序号，v 为迭代值。  
不是所有 .NET 对象都支持此迭代接口。*/
}

DotNetDictionaryObject 成员列表 #

DotNetDictionaryObject.Add(key,value) #

添加键值

DotNetDictionaryObject.Clear() #

清空字典

DotNetDictionaryObject.ContainsKey(key) #

是否包含参数 @key 指定键的值

DotNetDictionaryObject.ContainsValue(value) #

是否包含参数 @value 指定值的键

DotNetDictionaryObject.Count #

包含键值对总数

DotNetDictionaryObject.Remove(key) #

移除参数 @key 指定的键值

DotNetDictionaryObject.Keys 成员列表 #

键名数组

DotNetDictionaryObject.Keys.Item(索引) #

获取或设置指定索引处的键，aardio 中也可直接使用下标访问

DotNetDictionaryObject.Values 成员列表 #

键值数组

DotNetDictionaryObject.Values.Item(索引) #

获取或设置指定索引处的值，aardio 中也可直接使用下标访问

DotNetListObject 成员列表 #

DotNetListObject.Add(添加对象) #

添加成员到列表末尾

DotNetListObject.AddRange(数组) #

将数组或集合的元素添加到列表末尾

DotNetListObject.Clear() #

清空所有元素

DotNetListObject.Contains(对象) #

确定对象是否在列表中

DotNetListObject.Count #

获取列表中实际包含的元素数

DotNetListObject.GetRange(索引,数量) #

返回列表中的指定范围

DotNetListObject.IndexOf(对象) #

返回对象在列表中的索引

DotNetListObject.Insert(索引,对象) #

在指定索引处插入元素

DotNetListObject.Item(索引) #

获取或设置指定索引处的元素，aardio 中也可直接使用下标访问

DotNetListObject.Remove(对象) #

从列表中移除指定对象

DotNetListObject.RemoveAt(索引) #

移除指定索引处的元素

DotNetListObject.Reverse() #

反转整个列表的顺序

DotNetListObject.Sort() #

对整个列表进行排序

DotNetListObject.ToArray() #

转换并返回数组

dotNetCompilerObject 成员列表 #

dotNetCompilerObject.Compile #

编译并返回程序集

dotNetCompilerObject.Compile() #

返回对象:dotNetCrlAssemblyObject

dotNetCompilerObject.Compile(outpath) #

编译并返回程序集,所有参数可选,
如果参数 @outpath 指定了输出 dll 或 exe 文件路径，则输出为文件,
遇到错误不会抛出异常，请调用 getLastError 函数获取错误信息

dotNetCompilerObject.CompileOrFail #

编译并返回程序集

dotNetCompilerObject.CompileOrFail() #

返回对象:dotNetCrlAssemblyObject

dotNetCompilerObject.CompileOrFail(outpath) #

编译并返回程序集,所有参数可选,
如果参数 @outpath 指定了输出 dll 或 exe 文件路径，则输出为文件,
遇到错误会抛出异常

dotNetCompilerObject.Reference #

引用程序集，System.dll 已默认添加

注意这函数不支持内存 DLL，
也不支持用 dotNet.reference 添加的内存 DLL。

dotNetCompilerObject.Reference(assemblyDir,subPath...) #

引用程序集,
参数@1指定目录,可指定一个或多个子路径,
使用 io.joinpath 函数合并参数转换为完整路径,
然后引用该程序集。

dotNetCompilerObject.Reference(assemblyPath,...) #

引用程序集,
可指定任意多个程序集路径或名称参数,
如果指定不含 dll 后缀名的程序集名，则加载程序集并转换为完整路径。

dotNetCompilerObject.Source #

dotNetCompilerObject.Source = /***  
using System;  

namespace CSharpLibrary    
{  
    public class NetObject    
    {  
        public NetObject()  
        {  
            /*Source 属性可用字符串或字符串数组指定要编辑的代码。  
如果指定字符串则启用 aardio 模板语法，如果代码开始没有模板标记则自动添加。  
编译器对象的 ownerArgs 属性指定模板 owner 参数。  
CLR v2.0 / v4.0 可运行在 3.x,4.x 编译的 DLL，但编译器仅支持 CLR 相同版本语法。  
如果要添加文件，请改用 addSource 函数。*/  
        }   
    }  
}   
***/

dotNetCompilerObject.addSource #

添加源码，使用此函数添加源码后 Source 属性将变为数组

dotNetCompilerObject.addSource(code,rep) #

参数 @code 可以指定代码或代码文件路径。
可指定嵌入资源路径，源文件必须使用 UTF-8 编码。
如果代码开始的非空白空字为 <? 或 ?> 则启用 aardio 模板语法，
编译器对象的 ownerArgs 属性指定模板 owner 参数。
参数 @rep 指定是否丢弃之前添加的代码

dotNetCompilerObject.defaultSource #

编译前默认添加到前面的代码

dotNetCompilerObject.getLastError() #

获取编译错误信息

dotNetCompilerObject.getProvider() #

编译器

dotNetCompilerObject.import #

编译代码生成程序集，遇到错误会抛出异常。
将 参数@1指定的命名空间或类导入 aardio 全局命名空间。
在同一程序集中不会重复导入命名空间。

如果程序集用不是用 load 函数加载，则有可能重复导入命名空间,
重复导入 .NET 命名空间不会修改已存在的全局命名空间，
但此函数总是会返回当前调用实际创建的命名空间

dotNetCompilerObject.import() #

返回对象:dotNetNameSpaceObject

dotNetCompilerObject.import(netNamespace) #

编译代码生成程序集，遇到错误会抛出异常。
将 参数@1指定的命名空间或类导入 aardio 全局命名空间。
必须指定完整命名空间,不传入参数则默认指定参数为程序集名称。

返回命名空间可作为类构造函数调用并创建对象
也可以用成员操作符返回静态成员，或调用静态函数。

重复导入 .NET 命名空间不会修改已存在的全局命名空间，
但此函数总是会返回当前调用实际创建的命名空间

dotNetCompilerObject.loadcode #

用于自定义板解析函数，
用于解析启用 aardio 模板语法的 C# 代码。
默认指向 string.loadcode 。

dotNetCompilerObject.ownerArgs #

模板语法使用的 owner 参数，默认为表对象。

dotNetCompilerObject.Parameters 成员列表 #

编译参数

dotNetCompilerObject.Parameters.CompilerOptions #

dotNetCompilerObject.Parameters.CompilerOptions = "/optimize /unsafe"/*编译参数，/optimize 为开启优化*/

dotNetCompilerObject.Parameters.GenerateExecutable #

是否编译为EXE执行文件
编译为DLL设为false

dotNetCompilerObject.Parameters.GenerateInMemory #

是否内存编译

dotNetCompilerObject.Parameters.OutputAssembly #

指定输出文件路径,
参数需要调用io.fullpath()转换为绝对路径,
需要设GenerateInMemory为false取消内存编译,
调用setGenerateExecutable指定编译为DLL或者EXE

dotNetCrlArrayListObject 成员列表 #

dotNetCrlArrayListObject.Add(添加对象) #

添加成员到数组中

dotNetCrlArrayListObject.Clear() #

添空数组

dotNetCrlArrayListObject.ToArray() #

转换并返回数组

dotNetCrlArrayListObject.ToList() #

转换并返回 List 对象

dotNetCrlAssemblyObject 成员列表 #

dotNetCrlAssemblyObject.FullName #

获取程序集的全名

用于获取程序集的全名。

dotNetCrlAssemblyObject.Location #

获取完整路径

用于获取完整路径。

dotNetCrlAssemblyObject.appDomain #

加载此程序集的应用程序域。

返回对象:dotNetAppDomainObject

dotNetCrlAssemblyObject.getName(copiedName) #

返回 .NET 的 System.Reflection.AssemblyName 对象。
可选参数 copiedName 为 false 时返回对象的 CodeBase 属性指向原始位置（默认值）

dotNetCrlAssemblyObject.getStaticMember("类名.字段名") #

获取字段或属性值、或枚举值

获取字段或属性值、或枚举值

dotNetCrlAssemblyObject.getType() #

获取程序集本身的类型

返回对象:dotNetNameSpaceObject

dotNetCrlAssemblyObject.getType(name) #

仅指定 name 参数时等价于调用程序集的 import 方法。
这将导入 .NET 类型，如果类型不存在则作为 .NET 命名空间导入。

dotNetCrlAssemblyObject.getType(name,throwOnError) #

自程序集获取 name 指定的 .NET 类型，
throwOnError 必须指定为 true，否则失败会退出进程。

dotNetCrlAssemblyObject.import #

将 .NET 类名或命名空间导入 aardio 全局命名空间。
在当前应用程序域 import,load 等函数不会导入重复的程序集，
在同一程序集中不会重复导入命名空间。

如果程序集用其他函数加载，则有可能重复导入命名空间,
重复导入 .NET 命名空间不会修改已存在的全局命名空间，
但此函数总是会返回当前调用实际创建的命名空间

dotNetCrlAssemblyObject.import("字符串参数") #

参数 @1 指定要导入 .NET 命名空间、类、枚举，
与程序集名称相同的命名空间前缀可省略。
不传入参数则默认指定参数为程序集名称。

在当前应用程序域 import,load 等函数不会导入重复的程序集，
同一程序集中不会重复导入相同的命名空间。

返回命名空间可作为类构造函数调用并创建对象。
也可以用成员操作符返回静态成员，或调用静态函数。

导入的 .NET 命名空间在正常访问其成员时会触发元方法以获取并创建下级命名空间、类、枚举等。
但导入命名空间的函数（以及 namespace 语句）创建的上级命名空间并不会主动导入同名 .NET 命名空间\。

此函数会尽可能重用已存在的 aardio 全局命名空间导入 .NET 命名空间。
如果该全局命名空间已导入其他 .NET 命名空间则不会覆盖已存在的名空间。
此函数总是会返回当前调用实际创建的命名空间

dotNetCrlAssemblyObject.import(netNamespace) #

将参数@1 指定的 .NET 类名或命名空间导入 aardio 全局命名空间，
必须指定完整命名空间。
参数 @1 可指定命名空间也可以指定要导入的命名空间数组。
不传入参数则默认指定参数为程序集名称。

返回命名空间可作为类构造函数调用并创建对象
也可以用成员操作符返回静态成员，或调用静态函数。

重复导入 .NET 命名空间不会修改已存在的全局命名空间，
但此函数总是会返回当前调用实际创建的命名空间

dotNetCrlAssemblyObject.import(netNamespace,...) #

参数@1 指定要导入的 .NET 类名。
如果再指定一个或多个类型参数时则导入泛型类。
类型参数可以是导入的 .NET 类、类名全称、System.Type.GetType 获取的类型对象。
对导入的 .NET 类使用下标 ["<>"] 也可以返回一个创建泛型类的函数。
泛型类不会缓存，也不会设为 aardio 全局命名空间

dotNetCrlAssemblyObject.invokeMember("类名.方法名",BindingFlags) #

调用类的方法,
可添加不定个数调用参数
失败返回空值,以及错误信息

dotNetCrlAssemblyObject.invokeStaticMember("类名.方法名",... ) #

调用类的静态方法,
可添加不定个数调用参数
失败返回空值,以及错误信息

调用类的静态方法,
可添加不定个数调用参数
失败返回空值,以及错误信息

dotNetCrlAssemblyObject.new("类名",... ) #

创建对象实例,
可添加不定个数构造参数
失败返回空值,以及错误信息

创建对象实例,
可添加不定个数构造参数
失败返回空值,以及错误信息

dotNetDelegateObject 成员列表 #

dotNetDelegateObject.combine #

合并委托
在 .NET 里函数要转换为委托对象才能作为回调函数传输

dotNetDelegateObject.combine(委托对象1,委托对象2) #

返回合并的委托对象,允许省略所有参数，
如果指定参数则至少有一个 .NET 委托对象，
另一个参数可以是委托对象，也可指定普通 aardio 函数或表,
如果是普通 aardio 表则回调 _call 元方法,
aardio 函数或表参数会自动转换为所需类型的 .NET 委托

dotNetDelegateObject.combine(对象,委托成员名,委托对象) #

自参数@1指定的 .NET 对象中查询参数 @2指定的的属性或字段,
如果该成员是一个 delegate 或 event 类型，则合并参数@2，@3指定的委托并更新该成员的值。
原委托成员可为空值，但参数@1,@2 不可省略。

参数 @3 可指定 .NET 委托对象、null 值或省略。
如果参数 @3 是普通的 aardio 函数或表则转换为所需类型的 .NET 委托。
此函数返回参数@3创建的委托对象,可用于 remove 函数.

dotNetDelegateObject.create #

创建委托
在 .NET 里函数要转换为委托对象才能作为回调函数传输

dotNetDelegateObject.create(对象,委托成员名,函数对象) #

自参数@1指定的 .NET 对象中查询参数 @2指定的的属性或字段,
如果该成员是一个 delegate 或 event 类型，
则将@3指定的函数转换为该类型的委托对象并返回

dotNetDelegateObject.list() #

返回参数 @1 指定委托对象的调用对象列表,
相当于调用委托对象的 GetInvocationList 函数。

dotNetDelegateObject.remove #

移除委托

dotNetDelegateObject.remove(委托对象1,委托对象2) #

自参数@1指定的委托中移除以参数@2指定的委托，
所有参数必须是 .NET 委托对象,
成功返回新的委托，
失败或委托调用链没有变化返回 null,
任何一个参数为 null 返回 null

dotNetDelegateObject.remove(对象,委托成员名,委托对象) #

自参数@1指定的 .NET 对象中查询参数 @2指定的的属性或字段,
如果该成员是一个 delegate 或 event 类型，则移除参数@3指定的委托并更新该成员的值。
原委托成员可为空值，但参数@1,@2 不可省略。

参数 @3 指定需要移除的 .NET 委托对象。
不指定参数 @3 则不执行任何操作。
移除成功返回 true，失败返回 false

Markdown 格式