相对于 Python 模块的导入优先级

import 优先考虑 .py 文件。例如，如果路径中存在名为 System.py 的文件，它将被导入，而不是 System 命名空间

>>> # create System.py in the current folder
>>> f = open("System.py", "w")
>>> f.write('print "Loading System.py"')
>>> f.close()
>>>
>>> # unload the System namespace if it has been loaded
>>> import sys
>>> if sys.modules.has_key("System"):
...     sys.modules.pop("System") #doctest: +ELLIPSIS
<module 'System' (CLS module, ... assemblies loaded)>
>>>
>>> import System
Loading System.py
>>> System #doctest: +ELLIPSIS
<module 'System' from '...System.py'>

>>> import os
>>> os.remove("System.py")
>>> sys.modules.pop("System") #doctest: +ELLIPSIS
<module 'System' from '...System.py'>
>>> import System
>>> System #doctest: +ELLIPSIS
<module 'System' (CLS module, ... assemblies loaded)>

访问泛型类型

.NET 支持 泛型类型，它允许相同的代码支持多个类型参数，同时保留类型安全的优势。集合类型（如列表、向量等）是泛型类型有用的典型示例。.NET 在 System.Collections.Generic 命名空间中包含许多泛型集合类型。

IronPython 将泛型类型公开为一个特殊的 type 对象，该对象支持使用 type 对象作为索引（或索引）进行索引

>>> from System.Collections.Generic import List, Dictionary
>>> int_list = List[int]()
>>> str_float_dict = Dictionary[str, float]()

请注意，可能存在非泛型类型以及一个或多个具有相同名称的泛型类型 [1]。在这种情况下，可以使用该名称而不进行任何索引来访问非泛型类型，并且可以使用不同数量的类型进行索引来访问具有相应数量的类型参数的泛型类型。以下代码访问 System.EventHandler 以及 System.EventHandler<TEventArgs>

>>> from System import EventHandler, EventArgs
>>> EventHandler # this is the combo type object
<types 'EventHandler', 'EventHandler[TEventArgs]'>
>>> # Access the non-generic type
>>> dir(EventHandler) #doctest: +ELLIPSIS
['BeginInvoke', 'Clone', 'DynamicInvoke', 'EndInvoke', ...
>>> # Access the generic type with 1 type paramter
>>> dir(EventHandler[EventArgs]) #doctest: +ELLIPSIS
['BeginInvoke', 'Call', 'Clone', 'Combine', ...

>>> clr.GetClrType(EventHandler[EventArgs]).Name
'EventHandler`1'

访问嵌套类型

嵌套类型作为外部类的属性公开

>>> from System.Environment import SpecialFolder
>>> SpecialFolder
<type 'SpecialFolder'>

从类型中导入 .NET 成员

.NET 类型作为 Python 类公开。与 Python 类一样，您通常不能使用 from <name> import * 导入 .NET 类型的所有属性

>>> from System.Guid import *
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: no module named Guid

您可以导入特定的成员，包括静态成员和实例成员

>>> from System.Guid import NewGuid, ToByteArray
>>> g = NewGuid()
>>> ToByteArray(g) #doctest: +ELLIPSIS
Array[Byte](...

请注意，如果您导入静态属性，您将在 import 执行时导入该值，而不是导入一个在每次使用时都会被评估的命名对象，正如您可能错误地预期的那样

>>> from System.DateTime import Now
>>> Now #doctest: +ELLIPSIS
<System.DateTime object at ...>
>>> # Let's make it even more obvious that "Now" is evaluated only once
>>> a_second_ago = Now
>>> import time
>>> time.sleep(1)
>>> a_second_ago is Now
True
>>> a_second_ago is System.DateTime.Now
False

>>> from System.Environment import *
>>> Exit is System.Environment.Exit
True

>>> SpecialFolder is System.Environment.SpecialFolder
True

>>> OSVersion
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'OSVersion' is not defined
>>> System.Environment.OSVersion #doctest: +ELLIPSIS
<System.OperatingSystem object at ...>

类型系统统一 (type 和 System.Type)

.NET 使用 System.Type 来表示类型。但是，当你在 Python 代码中访问 .NET 类型时，你得到的是一个 Python type 对象 [2]

>>> from System.Collections import BitArray
>>> ba = BitArray(5)
>>> isinstance(type(ba), type)
True

这允许对 Python 和 .NET 类型进行统一（Pythonic）的视图。例如，isinstance 也适用于 .NET 类型。

>>> from System.Collections import BitArray
>>> isinstance(ba, BitArray)
True

如果需要获取 .NET 类型的 System.Type 实例，你需要使用 clr.GetClrType。相反，你可以使用 clr.GetPythonType 获取与 System.Type 对象对应的 type 对象。

这种统一也扩展到其他类型系统实体，例如方法。.NET 方法作为 method 的实例公开。

>>> type(BitArray.Xor)
<type 'method_descriptor'>
>>> type(ba.Xor)
<type 'builtin_function_or_method'>

>>> isinstance(type(ba), type)
True
>>> type(ba) is type
False

>>> del list.append
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: cannot delete attribute 'append' of builtin type 'list'
>>>
>>> import System
>>> del System.DateTime.ToByteArray
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't set attributes of built-in/extension type 'DateTime'

调用 .NET 实例方法

调用 .NET 实例方法就像使用属性符号调用 Python 对象上的方法一样。

>>> from System.Collections import BitArray
>>> ba = BitArray(5)
>>> ba.Set(0, True) # call the Set method
>>> ba[0]
True

IronPython 还支持命名参数。

>>> ba.Set(index = 1, value = True)
>>> ba[1]
True

IronPython 还支持字典参数。

>>> args = [2, True] # list of arguments
>>> ba.Set(*args)
>>> ba[2]
True

IronPython 还支持关键字参数。

>>> args = { "index" : 3, "value" : True }
>>> ba.Set(**args)
>>> ba[3]
True

参数转换

当参数类型与 .NET 方法期望的参数类型不完全匹配时，IronPython 会尝试转换参数。IronPython 使用传统的 .NET 转换规则，如 转换运算符，以及 IronPython 特定的规则。此代码片段展示了在调用 Set(System.Int32, System.Boolean) 方法时如何转换参数。

>>> from System.Collections import BitArray
>>> ba = BitArray(5)
>>> ba.Set(0, "hello") # converts the second argument to True.
>>> ba[0]
True
>>> ba.Set(1, None) # converts the second argument to False.
>>> ba[1]
False

有关详细的转换规则，请参阅 appendix-type-conversion-rules。请注意，某些 Python 类型是在 .NET 类型中实现的，在这种情况下不需要转换。有关映射，请参阅 builtin-type-mapping。

支持的一些转换包括：

方法重载

.NET 支持通过参数数量和参数类型来 重载方法。当 IronPython 代码调用重载方法时，IronPython 会尝试根据传递给方法的参数数量和类型以及任何关键字参数的名称，在运行时选择其中一个重载。在大多数情况下，会选择预期的重载。当参数类型与其中一个重载签名完全匹配时，选择重载很容易。

>>> from System.Collections import BitArray
>>> ba = BitArray(5) # calls __new__(System.Int32)
>>> ba = BitArray(5, True) # calls __new__(System.Int32, System.Boolean)
>>> ba = BitArray(ba) # calls __new__(System.Collections.BitArray)

参数类型不必与方法签名完全匹配。如果存在非歧义转换到其中一个重载签名，IronPython 会尝试转换参数。以下代码调用 __new__(System.Int32)，即使有两个接受一个参数的构造函数，并且它们都不接受 float 作为参数。

>>> ba = BitArray(5.0)

但是，请注意，如果存在对多个重载的转换，IronPython 会引发 TypeError。

>>> BitArray((1, 2, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Multiple targets could match: BitArray(Array[Byte]), BitArray(Array[bool]), BitArray(Array[int])

如果你想控制要调用的确切重载，可以使用 method 对象上的 Overloads 方法。

>>> int_bool_new = BitArray.__new__.Overloads[int, type(True)]
>>> ba = int_bool_new(BitArray, 5, True) # calls __new__(System.Int32, System.Boolean)
>>> ba = int_bool_new(BitArray, 5, "hello") # converts "hello" to a System.Boolan
>>> ba = int_bool_new(BitArray, 5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __new__() takes exactly 2 arguments (1 given)

TODO - 使用数组、byref 等对 Overloads 进行索引的示例，使用 Type.MakeByrefType

使用未绑定的类实例方法

有时需要使用未绑定的类实例方法调用实例方法，并将显式的 self 对象作为第一个参数传递。例如，.NET 允许一个类声明一个实例方法，该方法与基类型中的方法具有相同的名称，但不会覆盖基方法。有关详细信息，请参阅 System.Reflection.MethodAttributes.NewSlot。在这种情况下，使用未绑定的类实例方法语法允许你精确地选择要调用的插槽。

>>> import System
>>> System.ICloneable.Clone("hello") # same as : "hello".Clone()
'hello'

未绑定的类实例方法语法会导致虚拟调用，并调用虚拟方法插槽的最派生实现。

>>> s = "hello"
>>> System.Object.GetHashCode(s) == System.String.GetHashCode(s)
True
>>> from System.Runtime.CompilerServices import RuntimeHelpers
>>> RuntimeHelpers.GetHashCode(s) == System.String.GetHashCode(s)
False

调用显式实现的接口方法

.NET 允许使用不同名称的方法来覆盖基类方法实现或接口方法槽。这在类型实现两个具有相同名称方法的接口时很有用。这被称为 显式实现的接口方法。例如，Microsoft.Win32.RegistryKey 显式实现 System.IDisposable.Dispose

>>> from Microsoft.Win32 import RegistryKey
>>> clr.GetClrType(RegistryKey).GetMethod("Flush") #doctest: +ELLIPSIS
<System.Reflection.RuntimeMethodInfo object at ... [Void Flush()]>
>>> clr.GetClrType(RegistryKey).GetMethod("Dispose")
>>>

在这种情况下，IronPython 尝试使用其简单名称来公开方法 - 如果没有歧义

>>> from Microsoft.Win32 import Registry
>>> rkey = Registry.CurrentUser.OpenSubKey("Software")
>>> rkey.Dispose()

但是，该类型可能具有另一个具有相同名称的方法。在这种情况下，显式实现的方法无法作为属性访问。但是，它仍然可以通过使用未绑定的类实例方法语法来调用

>>> rkey = Registry.CurrentUser.OpenSubKey("Software")
>>> System.IDisposable.Dispose(rkey)

调用静态 .NET 方法

调用静态 .NET 方法类似于调用 Python 静态方法

>>> System.GC.Collect()

与 Python 静态方法一样，.NET 静态方法也可以作为子类型的属性访问

>>> System.Object.ReferenceEquals is System.GC.ReferenceEquals
True

TODO 如果子类型具有相同名称但签名不同的静态方法会发生什么？两种重载都可用还是不可用？

调用泛型方法

泛型方法被公开为属性，这些属性可以用 type 对象索引。以下代码调用 System.Activator.CreateInstance<T>

>>> from System import Activator, Guid
>>> guid = Activator.CreateInstance[Guid]()

调用泛型方法时的类型参数推断

在许多情况下，类型参数可以根据传递给方法调用的参数推断出来。考虑以下泛型方法的使用 [3]

>>> from System.Collections.Generic import IEnumerable, List
>>> list = List[int]([1, 2, 3])
>>> import clr
>>> clr.AddReference("System.Core")
>>> from System.Linq import Enumerable
>>> Enumerable.Any[int](list, lambda x : x < 2)
True

使用泛型类型参数推断，最后一个语句也可以写成

>>> Enumerable.Any(list, lambda x : x < 2)
True

有关详细规则，请参见 附录。

ref 和 out 参数

Python 语言通过值传递所有参数。没有语法来指示参数应该像在 .NET 语言（如 C# 和 VB.NET）中通过 ref 和 out 关键字一样通过引用传递。IronPython 支持两种将 ref 或 out 参数传递给方法的方式，一种是隐式方式，另一种是显式方式。

在隐式方式中，参数通常传递给方法调用，并且其（可能）更新的值与正常返回值（如果有）一起从方法调用返回。这与 Python 的多个返回值功能很好地结合在一起。 System.Collections.Generic.Dictionary 具有一个方法 bool TryGetValue(K key, out value)。它可以从 IronPython 中只用一个参数调用，并且调用返回一个 元组，其中第一个元素是布尔值，第二个元素是值（如果第一个元素是 False，则为 0.0 的默认值）

>>> d = { "a":100.1, "b":200.2, "c":300.3 }
>>> from System.Collections.Generic import Dictionary
>>> d = Dictionary[str, float](d)
>>> d.TryGetValue("b")
(True, 200.2)
>>> d.TryGetValue("z")
(False, 0.0)

在显式方式中，您可以为 ref 或 out 参数传递 clr.Reference[T] 的实例，并且其 Value 字段将通过调用设置。如果有多个带有 ref 参数的重载，则显式方式很有用

>>> import clr
>>> r = clr.Reference[float]()
>>> d.TryGetValue("b", r)
True
>>> r.Value
200.2

扩展方法

扩展方法 目前不受 IronPython 的原生支持。因此，它们不能像实例方法一样调用。相反，它们必须像静态方法一样调用。

非默认 .NET 索引器

请注意，默认索引器只是一个属性（通常称为 Item），带有一个参数。如果声明类型使用 DefaultMemberAttribute 将属性声明为默认成员，则它被视为索引器。

有关非默认索引器的信息，请参见 property-with-parameters。

带参数的属性

COM 和 VB.NET 支持带参数的属性。它们也被称为非默认索引器。C# 不支持声明或使用带参数的属性。

IronPython 支持带参数的属性。例如，上面的默认索引器也可以使用非默认格式访问，如下所示

>>> ba.Item[0]
False

.NET 数组

IronPython 支持使用 type 对象对 System.Array 进行索引，以访问一维强类型数组。

>>> System.Array[int]
<type 'Array[int]'>

IronPython 还添加了一个 __new__ 方法，该方法接受一个 IList<T> 来初始化数组。这允许使用 Python list 字面量来初始化 .NET 数组。

>>> a = System.Array[int]([1, 2, 3])

此外，IronPython 公开了 __getitem__ 和 __setitem__，允许使用 Python 索引语法对数组对象进行索引。

>>> a[2]
3

请注意，索引语法会产生 Python 语义。如果您使用负值进行索引，它会导致从数组末尾进行索引，而 .NET 索引（通过调用下面的 GetValue 演示）会引发 System.IndexOutOfRangeException 异常。

>>> a.GetValue(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: Index was outside the bounds of the array.
>>> a[-1]
3

类似地，也支持切片。

>>> a[1:3]
Array[int]((2, 3))

.NET 异常

raise 可以引发 Python 异常以及 .NET 异常。

>>> raise ZeroDivisionError()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError
>>> import System
>>> raise System.DivideByZeroException()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: Attempted to divide by zero.

except 关键字可以捕获 Python 异常以及 .NET 异常。

>>> try:
...    import System
...    raise System.DivideByZeroException()
... except System.DivideByZeroException:
...    print "This line will get printed..."
...
This line will get printed...
>>>

>>> e = ZeroDivisionError()
>>> e.foo = 1 # this works
>>> e = System.DivideByZeroException()
>>> e.foo = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'DivideByZeroException' object has no attribute 'foo'

>>> import clr
>>> try:
...     1/0
... except ZeroDivisionError as e:
...     pass
>>> type(e)
<type 'exceptions.ZeroDivisionError'>
>>> type(e.clsException)
<type 'DivideByZeroException'>

>>> e.clsException.Data["PythonExceptionInfo"] #doctest: +ELLIPSIS
<IronPython.Runtime.Exceptions.PythonExceptions+ExceptionDataWrapper object at ...>

>>> import System
>>> try:
...     try:
...         1/0
...     except System.DivideByZeroException as e1:
...         raise e1
... except ZeroDivisionError as e2:
...     pass
>>> type(e1)
<type 'DivideByZeroException'>
>>> type(e2)
<type 'exceptions.ZeroDivisionError'>
>>> e2.clsException is e1
True

>>> # since "Exception" might be System.Exception after "from System import *"
>>> if "Exception" in globals(): del Exception
>>> class MyException(Exception):
...     def __init__(self, value):
...         self.value = value
...     def __str__(self):
...         return repr(self.value)
>>> try:
...     raise MyException("some message")
... except System.Exception as e:
...     pass
>>> clr.GetClrType(type(e)).FullName
'System.Exception'
>>> e.Message
'Python Exception: MyException'

枚举

.NET 枚举类型是 `System.Enum` 的子类型。枚举类型的枚举值作为类属性公开

print System.AttributeTargets.All # access the value "All"

IronPython 还支持对枚举值使用按位运算符

>>> import System
>>> System.AttributeTargets.Class | System.AttributeTargets.Method
<enum System.AttributeTargets: Class, Method>

值类型

Python 期望所有可变值都表示为引用类型。另一方面，.NET 引入了值类型的概念，这些值类型主要被复制而不是被引用。特别是，返回值类型的 .NET 方法和属性将始终返回副本。

从 Python 程序员的角度来看，这可能会令人困惑，因为随后对这种值类型字段的更新将发生在本地副本上，而不是在最初提供值类型的任何封闭对象中。

虽然大多数 .NET 值类型被设计为不可变的，并且 .NET 设计指南建议值类型不可变，但这并没有被 .NET 强制执行，因此确实存在一些可变的 .NET 值类型。**TODO** - 示例。

例如，考虑以下 C# 定义

struct Point {
    # Poorly defined struct - structs should be immutable
    public int x;
    public int y;
}

class Line {
    public Point start;
    public Point end;

    public Point Start { get { return start; } }
    public Point End { get { return end; } }
}

如果 `line` 是引用类型 Line 的实例，那么 Python 程序员可能会期望 “`line.Start.x = 1`” 设置该线段起点的 x 坐标。实际上，`Start` 属性返回了 `Point` 值类型的副本，并且更新是在该副本上进行的

print line.Start.x    # prints ‘0’
line.Start.x = 1
print line.Start.x    # still prints ‘0’

这种行为非常微妙且令人困惑，以至于如果在 C# 中编写类似的代码（尝试修改从属性调用中返回的值类型的字段），C# 会产生编译时错误。

更糟糕的是，当尝试通过 Line 公开的 start 字段直接修改值类型时（即 “`line.start.x = 1`”），IronPython 仍然会更新 `Point` 结构的本地副本。这是因为 Python 的结构使得 “foo.bar” 始终会产生一个可用的值：在上面的情况下， “line.start” 需要返回一个完整的值类型，这反过来意味着一个副本。

另一方面，C# 会解释整个 “`line.start.x = 1`” 语句，并实际上为 “line.start” 部分生成一个值类型引用，该引用反过来可以用来就地设置 “x” 字段。

这突出了两种语言之间的语义差异。在 Python 中， “line.start.x = 1” 和 “foo = line.start; foo.x = 1” 在语义上是等效的。在 C# 中，情况并非如此。

总之：Python 程序员对嵌入在对象中的值类型进行更新，这些更新将被静默地丢失，而相同的语法在 C# 中会产生预期的语义。对从 .NET 属性返回的值类型进行更新，也会看起来成功，但会更新本地副本，并且不会像在 C# 世界中那样导致错误。这两个问题很容易成为大型应用程序中难以追踪的微妙错误的根源。

为了防止意外更新本地值类型副本，同时尽可能保持 Python 风格和一致的视图，IronPython 不允许直接更新值类型字段，并会引发 ValueError。

>>> line.start.x = 1 #doctest: +SKIP
Traceback (most recent call last):
   File , line 0, in input##7
ValueError Attempt to update field x on value type Point; value type fields can not be directly modified

这使得值类型“几乎”不可变；仍然可以通过值类型本身的实例方法进行更新。

代理类型

IronPython 无法直接使用 System.MarshalByRefObject 实例。IronPython 在运行时使用反射来确定如何访问对象。但是，System.MarshalByRefObject 实例不支持反射。

您可以使用 unbound-class-instance-method 语法来调用此类代理对象上的方法。

委托

Python 函数和绑定实例方法可以转换为委托。

>>> from System import EventHandler, EventArgs
>>> def foo(sender, event_args):
...     print event_args
>>> d = EventHandler(foo)
>>> d(None, EventArgs()) #doctest: +ELLIPSIS
<System.EventArgs object at ... [System.EventArgs]>

>>> def foo(*args):
...     print args
>>> d = EventHandler(foo)
>>> d(None, EventArgs()) #doctest: +ELLIPSIS
(None, <System.EventArgs object at ... [System.EventArgs]>)

>>> def foo(*args):
...     return 100 # this return value will get ignored
>>> d = EventHandler(foo)
>>> d(None, EventArgs())

>>> def foo(str1, str2):
...     return 100.1 # this return value will get converted to an int
>>> d = System.Comparison[str](foo)
>>> d("hello", "there")
100

具有多个重载的方法

Python 不支持方法重载。一个类只能有一个具有给定名称的方法。因此，您无法覆盖 .NET 子类型的特定方法重载。相反，您需要使用定义接受任意参数列表的函数（请参阅 _tut-arbitraryargs），然后通过检查参数的类型来确定调用的方法重载。

>>> import clr
>>> import System
>>> StringComparer = System.Collections.Generic.IEqualityComparer[str]
>>>
>>> class MyComparer(StringComparer):
...     def GetHashCode(self, *args):
...          if len(args) == 0:
...              # Object.GetHashCode() called
...              return 100
...
...          if len(args) == 1 and type(args[0]) == str:
...              # StringComparer.GetHashCode() called
...              return 200
...
...          assert("Should never get here")
...
>>> comparer = MyComparer()
>>> getHashCode1 = clr.GetClrType(System.Object).GetMethod("GetHashCode")
>>> args = System.Array[object](["another string"])
>>> getHashCode2 = clr.GetClrType(StringComparer).GetMethod("GetHashCode")
>>>
>>> # Use Reflection to simulate a call to the different overloads
>>> # from another .NET language
>>> getHashCode1.Invoke(comparer, None)
100
>>> getHashCode2.Invoke(comparer, args)
200

具有 ref 或 out 参数的方法

Python 没有语法来指定方法参数是按引用传递还是按值传递，因为参数始终按值传递。当覆盖具有 ref 或 out 参数的 .NET 方法时，ref 或 out 参数将作为 clr.Reference[T] 实例接收。通过读取 Value 属性访问传入的参数值，并通过设置 Value 属性指定结果值。

>>> import clr
>>> import System
>>> StrFloatDictionary = System.Collections.Generic.IDictionary[str, float]
>>>
>>> class MyDictionary(StrFloatDictionary):
...     def TryGetValue(self, key, value):
...         if key == "yes":
...             value.Value = 100.1 # set the *out* parameter
...             return True
...         else:
...             value.Value = 0.0  # set the *out* parameter
...             return False
...     # Other methods of IDictionary not overriden for brevity
...
>>> d = MyDictionary()
>>> # Use Reflection to simulate a call from another .NET language
>>> tryGetValue = clr.GetClrType(StrFloatDictionary).GetMethod("TryGetValue")
>>> args = System.Array[object](["yes", 0.0])
>>> tryGetValue.Invoke(d, args)
True
>>> args[1]
100.1

泛型方法

当您覆盖泛型方法时，类型参数将作为参数传入。考虑以下泛型方法声明。

// csc /t:library /out:convert.dll convert.cs
public interface IMyConvertible {
    T1 Convert<T1, T2>(T2 arg);
}

以下代码覆盖了泛型方法 Convert。

>>> import clr
>>> clr.AddReference("convert.dll")
>>> import System
>>> import IMyConvertible
>>>
>>> class MyConvertible(IMyConvertible):
...     def Convert(self, t2, T1, T2):
...         return T1(t2)
>>>
>>> o = MyConvertible()
>>> # Use Reflection to simulate a call from another .NET language
>>> type_params = System.Array[System.Type]([str, float])
>>> convert = clr.GetClrType(IMyConvertible).GetMethod("Convert")
>>> convert_of_str_float = convert.MakeGenericMethod(type_params)
>>> args = System.Array[object]([100.1])
>>> convert_of_str_float.Invoke(o, args)
'100.1'

从 Python 调用

当您从 Python 调用方法，并且该方法重写了基类型的 .NET 方法时，该调用将作为常规的 Python 调用执行。参数不会进行转换，也不会以任何方式修改，例如用 clr.Reference 包装。因此，该调用的编写方式可能与用其他语言重写方法时有所不同。例如，尝试从 overriding-ref-args 部分调用 MyDictionary 类型的 TryGetValue，如下所示，会导致 TypeError，而类似的调用在 System.Collections.Generic.Dictionary[str, float] 中有效。

>>> result, value = d.TryGetValue("yes")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: TryGetValue() takes exactly 3 arguments (2 given)

可变对象的散列

CLR 期望 System.Object.GetHashCode 始终为给定对象返回相同的值。如果未维护此不变性，则使用对象作为 System.Collections.Generic.Dictionary<K,V> 中的键将导致错误行为。Python 允许 __hash__ 返回不同的结果，并依赖用户处理将对象用作哈希中键的情况。Python 和 CLR 关于相等性和哈希的概念之间的上述映射意味着处理 Python 对象的 CLR 代码必须意识到这个问题。如果静态 MSIL 代码使用 Python 对象作为 Dictionary<K,V> 中的键，则可能会发生意外行为。

为了减少使用常见 Python 类型时发生这种情况的可能性，IronPython 不会将 __hash__ 映射到 Array 和 Hash 的 GetHashCode。对于其他 Python 类，如果 Python 类是可变的，但还需要用作 Dictionary<K,V> 中的键，则用户可以为 __eq__ 和 Equals 以及 __hash__ 和 GetHashCode 提供单独的实现。

Python 对象上的 ToString

在 Python 对象上调用 ToString 将调用默认的 System.Object.ToString 实现，即使 Python 类型定义了 __str__

>>> class MyClass(object):
...     def __str__(self):
...         return "__str__ result"
>>> o = MyClass()
>>> # Use Reflection to simulate a call from another .NET language
>>> o.GetType().GetMethod("ToString").Invoke(o, None) #doctest: +ELLIPSIS
'IronPython.NewTypes.System.Object_...'

__repr__/__str__ 在 .NET 对象上

所有 Python 用户类型都有 __repr__ 和 __str__

>>> class MyClass(object):
...     pass
>>> o = MyClass()
>>> o.__repr__() #doctest: +ELLIPSIS
'<MyClass object at ...>'
>>> o.__str__() #doctest: +ELLIPSIS
'IronPython.NewTypes.System.Object_...'
>>> str(o) #doctest: +ELLIPSIS
'<MyClass object at ...>'

对于没有重写 ToString 的 .NET 类型，IronPython 提供 __repr__ 和 __str__ 方法，其行为类似于 Python 用户类型的行为 [10]

>>> from System.Collections import BitArray
>>> ba = BitArray(5)
>>> ba.ToString() # BitArray inherts System.Object.ToString()
'System.Collections.BitArray'
>>> ba.__repr__() #doctest: +ELLIPSIS
'<System.Collections.BitArray object at ... [System.Collections.BitArray]>'
>>> ba.__str__() #doctest: +ELLIPSIS
'<System.Collections.BitArray object at ... [System.Collections.BitArray]>'

对于确实重写了 ToString 的 .NET 类型，IronPython 将 ToString 的结果包含在 __repr__ 中，并将 ToString 直接映射到 __str__

>>> e = System.Exception()
>>> e.ToString()
"System.Exception: Exception of type 'System.Exception' was thrown."
>>> e.__repr__() #doctest: +ELLIPSIS
"<System.Exception object at ... [System.Exception: Exception of type 'System.Exception' was thrown.]>"
>>> e.__str__() #doctest:
"System.Exception: Exception of type 'System.Exception' was thrown."

对于重写 ToString 的 Python 类型，__str__ 映射到 ToString 重写

>>> class MyClass(object):
...     def ToString(self):
...         return "ToString implemented in Python"
>>> o = MyClass()
>>> o.__repr__() #doctest: +ELLIPSIS
'<MyClass object at ...>'
>>> o.__str__()
'ToString implemented in Python'
>>> str(o) #doctest: +ELLIPSIS
'<MyClass object at ...>'

属性

有一个重要的细节值得指出。IronPython 尝试使用 OleAut 对象的类型库（如果可以找到），以便在访问方法或属性时进行名称解析。这样做的原因是，IDispatch 接口在属性和方法调用之间没有太大区别。这是因为 Visual Basic 6 语义，其中“excel.Quit”和“excel.Quit()”具有完全相同的语义。但是，IronPython 在属性和方法之间有严格的区别，并且方法是一级对象。为了让 IronPython 知道“excel.Quit”应该调用 Quit 方法，还是只返回一个可调用对象，它需要检查类型库。如果类型库不可用，IronPython 假设它是一个方法。因此，如果 OleAut 对象有一个名为“prop”的属性，但它没有类型库，则需要在 IronPython 中编写“p = obj.prop()”来读取属性值。

具有 out 参数的方法

调用带有“out”（或 in-out）参数的方法需要显式传入“clr.Reference”的实例，如果你想获取方法调用后的更新值。请注意，带有 out 参数的 COM 方法不被认为是自动化友好的 [11]。JScript 完全不支持 out 参数。如果你确实遇到了带有 out 参数的 COM 组件，使用“clr.Reference”是一个合理的解决方法。

>>> import clr
>>> from System import Type, Activator
>>> command_type = Type.GetTypeFromProgID("ADODB.Command")
>>> command = Activator.CreateInstance(command_type)
>>> records_affected = clr.Reference[int]()
>>> command.Execute(records_affected, None, None) #doctest: +SKIP
>>> records_affected.Value
0

另一种解决方法是利用互操作程序集，使用“outParamAsReturnValue = InteropAssemblyNamespace.IComInterface(comObject)”的非绑定类实例方法语法。

import clr 和内置类型

由于一些 Python 内置类型是用 .NET 类型实现的，因此出现了这些类型是像 Python 类型还是像 .NET 类型工作的问题。答案是，默认情况下，这些类型像 Python 类型工作。但是，如果一个模块执行 import clr，这些类型既像 Python 类型又像 .NET 类型工作。例如，默认情况下，object' 没有名为 GetHashCode 的 System.Object 方法。

>>> hasattr(object, "__hash__")
True
>>> # Note that this assumes that "import clr" has not yet been executed
>>> hasattr(object, "GetHashCode") #doctest: +SKIP
False

但是，一旦你执行 import clr，object 既有 __hash__ 也有 GetHashCode

>>> import clr
>>> hasattr(object, "__hash__")
True
>>> hasattr(object, "GetHashCode")
True

逐项功能比较

LINQ 包含许多语言和 .NET 功能，IronPython 对不同功能的支持程度不同。

• C# 和 VB.NET lambda 函数 - Python 已经支持 lambda 函数。
• 匿名类型 - Python 有元组，可以像匿名类型一样使用。
• 扩展方法 - 请参阅
• 泛型方法类型参数推断 - 请参阅
• 表达式树 - 不支持。这是 DLinq 不起作用的主要原因。