相對於 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 <名稱> import *:

>>> 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

這允許統一 (Pythonic) 檢視 Python 及 .NET 型別。例如，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

詳細的轉換規則請參閱 附錄型別轉換規則。請注意，某些 Python 類型是實作為 .NET 類型，而且此類情況不需要進行轉換。請參閱 內建類型對應 來了解對應關係。

支援的部分轉換如下

方法重載

.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)，即使有兩個建構函式會採用一個參數，而且它們都不接受 浮點數 作為參數

>>> 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])

倘若要控制被呼叫的超載，可以在 方法 物件上使用 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)

待辦事項 - 使用 Type.MakeByrefType 以陣列、byref 等來為 Overloads 編製索引的範例

使用未繫結的類別實例方法

有時會希望使用未繫結類別實例方法並傳遞明確 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

待辦如果子類型有一個名稱相同但簽章不同的靜態方法，會發生什麼事？是否兩個覆寫都會可用？

呼叫泛型方法

泛型方法會公開為可以以 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 語言以值傳遞所有引數。沒有語法可以表示應以參照傳遞引數，就像 C# 和 VB.NET 等 .NET 語言可以透過 ref 和 out 關鍵字一般。IronPython 支援兩種將 ref 或 out 引數傳遞至方法的方式，一種是明確的方式，另一種是非明確的方式。

以非明確的方式傳遞引數時，引數會以一般方式傳遞至方法呼叫，且其（可能）已更新的值會隨一般傳回值（如果有）一起從方法呼叫傳回。這個方式與 Python 的多重傳回值功能很搭。 System.Collections.Generic.Dictionary 有 bool TryGetValue(K key, out value) 方法。它可以用一個引數從 IronPython 呼叫，而呼叫會傳回一個 tuple，其中第一個元素為 boolean，第二個元素為值（或如果第一個元素為 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)

以明確的方式傳遞引數時，可以傳遞 clr.Reference[T] 的實體作為 ref 或 out 引數，呼叫會設定其 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 值型別可變。待辦事項 - 範例。

例如，取用下列 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# 會在撰寫類似的程式碼 (嘗試修改剛從屬性呼叫傳回的值型別的欄位) 時產生編譯時期錯誤。

更糟的是，當嘗試透過 Line 公開的起始欄位 (亦即 “`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 執行個體不支援反射。

可以使用 未繫結-類別-執行個體-方法 語法來呼叫此類代理物件中的方法。

委派

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__ 對應到陣列和雜湊的 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_...'

在 .NET 物件上使用 __repr__/__str__

所有的 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 知道是否應該呼叫 Quit 方法，或僅傳回可呼叫物件，IronPython 需要檢查 typelib。如果沒有提供 typelib，IronPython 會假設它是一個方法。因此，如果 OleAut 物件有一個稱為「prop」的屬性但沒有 typelib，您需要在 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' 沒有 System.Object 方法，稱為 GetHashCode

>>> 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 無法運作的主要原因。