python反射調用方法調用

『壹』 怎樣用反射調用一個類的方法,這個類繼承了其他類的內部類

反射出來的Class對象可以得到自己聲明的方法。和所有方法。
如果你要得到當前類聲明的方法，可以用getDeclaredMethods()
要得到所有的方法可以用getMethods()

如果要得到父類的方法，你可以先去得到父類。getSuperclass()

『貳』 python 如何調用類的方法

以numpy為例，首先創建一個對象：

In[32]:a=numpp.arange(10)

然後，a就擁有了類的方法，例如求和：

In[33]:a.sum()
Out[33]:45

也可以使用類的方法，將其應用到類的對象上，例如：

In[34]:numpp.sum(a)
Out[34]:45

『叄』 Python中如果對基礎類型進行反射，比如int、float

動態語言裡面的eval就是干這個用的

type1="int"
type2="str"

a=eval(type1+"(2222)") 這里a就是int型的2222 相當於執行a=eval("int(2222)")
b=eval(type2+("2222")) 這里b就是string型的"2222" 相當於執行b=eval("str(2222)")

另外Python偏函數特性也比較像這個，你可以搜索下看看。

『肆』 如何用反射動態調用方法

java">packagejxy.common.reflect;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.Method;

publicclassCallMethod{
publicstaticvoidmain(String[]args)throwsException{
//獲取TestClass的Class對象
ClasstestClass=Class.forName(TestClass.class.getName());

//（1）使用Class對象的newInstance方法創建一個實例，這種方法用默認構造方法創建對象
TestClassobjectA=(TestClass)testClass.newInstance();
System.out.println("Class的newInstance()方法創建默認TestClass實例:"
+objectA.toString());
//（2）使用構造方法創建實例。這就可以使用帶參數的構造方法創建實例了
Constructor[]cons=testClass.getDeclaredConstructors();
System.out.println("testClass有"+cons.length+"個構造方法");
Constructorcon=null;
for(inti=0;i<cons.length;i++){
con=cons[i];
//默認構造函數
if(con.getParameterTypes().length==0){
//調用Constructor的newInstance方法創建實例
objectA=(TestClass)con.newInstance(null);
System.out
.println("Constructor的newInstance()方法創建默認TestClass實例:"
+objectA.toString());
}else{
//帶參數的構造函數
objectA=(TestClass)con.newInstance(newObject[]{
newInteger(55),newInteger(88)});
System.out
.println("Constructor的newInstance()方法創建帶參數的TestClass實例:"
+objectA.toString());
}
}

//獲取所有方法
Method[]methods=testClass.getMethods();
//獲取某個特定的無參數的方法
MethodsaddMethod1=testClass.getMethod("sadd",null);
MethodaddMethod1=testClass.getMethod("add",null);
//獲取某個特定的有參數的方法
MethodsaddMethod2=testClass.getMethod("sadd",newClass[]{
int.class,int.class});
MethodaddMethod2=testClass.getMethod("add",newClass[]{int.class,
int.class});

//調用不帶參數的靜態方法
intresult=((Integer)saddMethod1.invoke(null,null)).intValue();
System.out.println("調用不帶參數的靜態方法sadd:"+result);
//調用帶參數的靜態方法
result=((Integer)saddMethod2.invoke(null,newObject[]{
newInteger(30),newInteger(70)})).intValue();
System.out.println("調用帶參數30,70的靜態方法sadd:"+result);

objectA=(TestClass)testClass.newInstance();
//調用不帶參數的實例方法
result=((Integer)addMethod1.invoke(objectA,null)).intValue();
System.out.println("調用不帶參數的實例方法add:"+result);
//調用帶參數的實例方法
result=((Integer)addMethod2.invoke(objectA,newObject[]{
newInteger(130),newInteger(170)})).intValue();
System.out.println("調用帶參數130,170的實例方法add:"+result);
//不能訪問私有方法
//Methodsub=testClass.getMethod("sub",null);
//System.out.println(sub.invoke(objectA,null));
}
//測試類
staticclassTestClass{
//兩個靜態屬性
staticintsa=100;
staticintsb=50;
//兩個實例屬性
inta;
intb;
//默認構造方法
publicTestClass(){
this.a=5;
this.b=10;
}
//帶參數的構造方法
publicTestClass(inta,intb){
this.a=a;
this.b=b;
}
//靜態方法，實現add功能
publicstaticintsadd(){
returnsa+sb;
}
publicstaticintsadd(inta,intb){
returna+b;
}
//實例方法，實現add功能
publicintadd(){
returnthis.a+this.b;
}
publicintadd(inta,intb){
returna+b;
}
publicStringtoString(){
return"a="+this.a+";b="+this.b;
}
//私有方法
privateintsub(){
returnthis.a-this.b;
}
}
}

『伍』 請問如何通過反射調用擴展方法

var mi=list.GetType().GetMethod("Cast");
我是先把他的代碼黏貼到控制台下運行，結果報錯找不到這個方法後來想想，對了：
接著，我馬不停蹄趕到MSDN上查閱擴展方法定義在哪個類中在System.Linq命名空間下的Enumerable靜態類中。
找到了，OK！既然這個方法對於List是擴展，那麼對於這個Enumerable類而言不等於是普通的靜態方法嗎？好，既然如此，我就直接對你靜態類中的這個靜態方法進行反射了，出工了
List<string strings = new List<string { "1", "2", "3" };
MethodInfo mi = typeof(Enumerable).GetMethod("Cast", BindingFlags.Public | BindingFlags.Static);
var list = (IEnumerable<string)mi.Invoke(null, new object[]{strings}); //這里出錯
哦，上網問問好友們，使用了一個方法：
var list = (IEnumerable<string)mi.
MakeGenericMethod(typeof(string)).
Invoke(null, new object[]{strings});
這個方法會將方法的泛型傳入反射裝置。然後進行反射調用。

『陸』 python 在類中如何讓方法之間互相調用

python 在類中方法之間互相調用的方法：
>>> class OP():
... def __init__(self,p):
... self.p=p
... def re(self):
... self.p+=1
... def s(self):
... self.re()
... print self.p
...
>>> vb=OP(2)
>>> vb.s
<bound method="" OP.s of <__main__.OP instance at 0x00E23300>>
>>> vb.s()
3
>>>

『柒』 Python如何通過字元或數字動態獲取對象的名稱或者屬性

首先通過一個例子來看一下本文中可能用到的對象和相關概念。
#coding: UTF-8
import sys # 模塊，sys指向這個模塊對象
import inspect
def foo(): pass # 函數，foo指向這個函數對象

class Cat(object): # 類，Cat指向這個類對象
def __init__(self, name='kitty'):
self.name = name
def sayHi(self): # 實例方法，sayHi指向這個方法對象，使用類或實例.sayHi訪問
print self.name, 'says Hi!' # 訪問名為name的欄位，使用實例.name訪問

cat = Cat() # cat是Cat類的實例對象

print Cat.sayHi # 使用類名訪問實例方法時，方法是未綁定的(unbound)
print cat.sayHi # 使用實例訪問實例方法時，方法是綁定的(bound)

有時候我們會碰到這樣的需求，需要執行對象的某個方法，或是需要對對象的某個欄位賦值，而方法名或是欄位名在編碼代碼時並不能確定，需要通過參數傳遞字元串的形式輸入。舉個具體的例子：當我們需要實現一個通用的DBM框架時，可能需要對數據對象的欄位賦值，但我們無法預知用到這個框架的數據對象都有些什麼欄位，換言之，我們在寫框架的時候需要通過某種機制訪問未知的屬性。
這個機制被稱為反射（反過來讓對象告訴我們他是什麼），或是自省（讓對象自己告訴我們他是什麼，好吧我承認括弧里是我瞎掰的- -#），用於實現在運行時獲取未知對象的信息。反射是個很嚇唬人的名詞，聽起來高深莫測，在一般的編程語言里反射相對其他概念來說稍顯復雜，一般來說都是作為高級主題來講；但在Python中反射非常簡單，用起來幾乎感覺不到與其他的代碼有區別，使用反射獲取到的函數和方法可以像平常一樣加上括弧直接調用，獲取到類後可以直接構造實例；不過獲取到的欄位不能直接賦值，因為拿到的其實是另一個指向同一個地方的引用，賦值只能改變當前的這個引用而已。
1. 訪問對象的屬性
以下列出了幾個內建方法，可以用來檢查或是訪問對象的屬性。這些方法可以用於任意對象而不僅僅是例子中的Cat實例對象；Python中一切都是對象。
cat = Cat('kitty')

print cat.name # 訪問實例屬性
cat.sayHi() # 調用實例方法

print dir(cat) # 獲取實例的屬性名，以列表形式返回
if hasattr(cat, 'name'): # 檢查實例是否有這個屬性
setattr(cat, 'name', 'tiger') # same as: a.name = 'tiger'
print getattr(cat, 'name') # same as: print a.name

getattr(cat, 'sayHi')() # same as: cat.sayHi()

dir([obj]):
調用這個方法將返回包含obj大多數屬性名的列表（會有一些特殊的屬性不包含在內）。obj的默認值是當前的模塊對象。
hasattr(obj, attr):
這個方法用於檢查obj是否有一個名為attr的值的屬性，返回一個布爾值。
getattr(obj, attr):
調用這個方法將返回obj中名為attr值的屬性的值，例如如果attr為'bar'，則返回obj.bar。
setattr(obj, attr, val):
調用這個方法將給obj的名為attr的值的屬性賦值為val。例如如果attr為'bar'，則相當於obj.bar = val。
2. 訪問對象的元數據
當你對一個你構造的對象使用dir()時，可能會發現列表中的很多屬性並不是你定義的。這些屬性一般保存了對象的元數據，比如類的__name__屬性保存了類名。大部分這些屬性都可以修改，不過改動它們意義並不是很大；修改其中某些屬性如function.func_code還可能導致很難發現的問題，所以改改name什麼的就好了，其他的屬性不要在不了解後果的情況下修改。
接下來列出特定對象的一些特殊屬性。另外，Python的文檔中有提到部分屬性不一定會一直提供，下文中將以紅色的星號*標記，使用前你可以先打開解釋器確認一下。
2.0. 准備工作：確定對象的類型
在types模塊中定義了全部的Python內置類型，結合內置方法isinstance()就可以確定對象的具體類型了。
isinstance(object, classinfo):
檢查object是不是classinfo中列舉出的類型，返回布爾值。classinfo可以是一個具體的類型，也可以是多個類型的元組或列表。
types模塊中僅僅定義了類型，而inspect模塊中封裝了很多檢查類型的方法，比直接使用types模塊更為輕松，所以這里不給出關於types的更多介紹，如有需要可以直接查看types模塊的文檔說明。本文第3節中介紹了inspect模塊。
2.1. 模塊(mole)
__doc__: 文檔字元串。如果模塊沒有文檔，這個值是None。
*__name__: 始終是定義時的模塊名；即使你使用import .. as 為它取了別名，或是賦值給了另一個變數名。
*__dict__: 包含了模塊里可用的屬性名-屬性的字典；也就是可以使用模塊名.屬性名訪問的對象。
__file__: 包含了該模塊的文件路徑。需要注意的是內建的模塊沒有這個屬性，訪問它會拋出異常！
import fnmatch as m
print m.__doc__.splitlines()[0] # Filename matching with shell patterns.
print m.__name__ # fnmatch
print m.__file__ # /usr/lib/python2.6/fnmatch.pyc
print m.__dict__.items()[0] # ('fnmatchcase', <function fnmatchcase="" at="" 0xb73deb54="">)</function>

2.2. 類(class)
__doc__: 文檔字元串。如果類沒有文檔，這個值是None。
*__name__: 始終是定義時的類名。
*__dict__: 包含了類里可用的屬性名-屬性的字典；也就是可以使用類名.屬性名訪問的對象。
__mole__: 包含該類的定義的模塊名；需要注意，是字元串形式的模塊名而不是模塊對象。
*__bases__: 直接父類對象的元組；但不包含繼承樹更上層的其他類，比如父類的父類。
print Cat.__doc__ # None
print Cat.__name__ # Cat
print Cat.__mole__ # __main__
print Cat.__bases__ # (<type ?object?="">,)
print Cat.__dict__ # {'__mole__': '__main__', ...}</type>

2.3. 實例(instance)
實例是指類實例化以後的對象。
*__dict__: 包含了可用的屬性名-屬性字典。
*__class__: 該實例的類對象。對於類Cat，cat.__class__ == Cat 為 True。
print cat.__dict__
print cat.__class__
print cat.__class__ == Cat # True

2.4. 內建函數和方法(built-in functions and methods)
根據定義，內建的(built-in)模塊是指使用C寫的模塊，可以通過sys模塊的builtin_mole_names欄位查看都有哪些模塊是內建的。這些模塊中的函數和方法可以使用的屬性比較少，不過一般也不需要在代碼中查看它們的信息。
__doc__: 函數或方法的文檔。
__name__: 函數或方法定義時的名字。
__self__: 僅方法可用，如果是綁定的(bound)，則指向調用該方法的類（如果是類方法）或實例（如果是實例方法），否則為None。
*__mole__: 函數或方法所在的模塊名。
2.5. 函數(function)
這里特指非內建的函數。注意，在類中使用def定義的是方法，方法與函數雖然有相似的行為，但它們是不同的概念。
__doc__: 函數的文檔；另外也可以用屬性名func_doc。
__name__: 函數定義時的函數名；另外也可以用屬性名func_name。
*__mole__: 包含該函數定義的模塊名；同樣注意，是模塊名而不是模塊對象。
*__dict__: 函數的可用屬性；另外也可以用屬性名func_dict。
不要忘了函數也是對象，可以使用函數.屬性名訪問屬性（賦值時如果屬性不存在將新增一個），或使用內置函數has/get/setattr()訪問。不過，在函數中保存屬性的意義並不大。
func_defaults: 這個屬性保存了函數的參數默認值元組；因為默認值總是靠後的參數才有，所以不使用字典的形式也是可以與參數對應上的。
func_code: 這個屬性指向一個該函數對應的code對象，code對象中定義了其他的一些特殊屬性，將在下文中另外介紹。
func_globals: 這個屬性指向當前的全局命名空間而不是定義函數時的全局命名空間，用處不大，並且是只讀的。
*func_closure: 這個屬性僅當函數是一個閉包時有效，指向一個保存了所引用到的外部函數的變數cell的元組，如果該函數不是一個內部函數，則始終為None。這個屬性也是只讀的。
下面的代碼演示了func_closure：
#coding: UTF-8
def foo():
n = 1
def bar():
print n # 引用非全局的外部變數n，構造一個閉包
n = 2
return bar

closure = foo()
print closure.func_closure
# 使用dir()得知cell對象有一個cell_contents屬性可以獲得值
print closure.func_closure[0].cell_contents # 2

由這個例子可以看到，遇到未知的對象使用dir()是一個很好的主意 ：）
2.6. 方法(method)
方法雖然不是函數，但可以理解為在函數外面加了一層外殼；拿到方法里實際的函數以後，就可以使用2.5節的屬性了。
__doc__: 與函數相同。
__name__: 與函數相同。
*__mole__: 與函數相同。
im_func: 使用這個屬性可以拿到方法里實際的函數對象的引用。另外如果是2.6以上的版本，還可以使用屬性名__func__。
im_self: 如果是綁定的(bound)，則指向調用該方法的類（如果是類方法）或實例（如果是實例方法），否則為None。如果是2.6以上的版本，還可以使用屬性名__self__。
im_class: 實際調用該方法的類，或實際調用該方法的實例的類。注意不是方法的定義所在的類，如果有繼承關系的話。
im = cat.sayHi
print im.im_func
print im.im_self # cat
print im.im_class # Cat

這里討論的是一般的實例方法，另外還有兩種特殊的方法分別是類方法(classmethod)和靜態方法(staticmethod)。類方法還是方法，不過因為需要使用類名調用，所以他始終是綁定的；而靜態方法可以看成是在類的命名空間里的函數（需要使用類名調用的函數），它只能使用函數的屬性，不能使用方法的屬性。
2.7. 生成器(generator)
生成器是調用一個生成器函數(generator function)返回的對象，多用於集合對象的迭代。
__iter__: 僅僅是一個可迭代的標記。
gi_code: 生成器對應的code對象。
gi_frame: 生成器對應的frame對象。
gi_running: 生成器函數是否在執行。生成器函數在yield以後、執行yield的下一行代碼前處於frozen狀態，此時這個屬性的值為0。
next|close|send|throw: 這是幾個可調用的方法，並不包含元數據信息，如何使用可以查看生成器的相關文檔。
def gen():
for n in xrange(5):
yield n
g = gen()
print g # <generator object gen at 0x...>
print g.gi_code # <code object gen at 0x...>
print g.gi_frame # <frame object at 0x...>
print g.gi_running # 0
print g.next() # 0
print g.next() # 1
for n in g:
print n, # 2 3 4

接下來討論的是幾個不常用到的內置對象類型。這些類型在正常的編碼過程中應該很少接觸，除非你正在自己實現一個解釋器或開發環境之類。所以這里只列出一部分屬性，如果需要一份完整的屬性表或想進一步了解，可以查看文末列出的參考文檔。
2.8. 代碼塊(code)
代碼塊可以由類源代碼、函數源代碼或是一個簡單的語句代碼編譯得到。這里我們只考慮它指代一個函數時的情況；2.5節中我們曾提到可以使用函數的func_code屬性獲取到它。code的屬性全部是只讀的。
co_argcount: 普通參數的總數，不包括*參數和**參數。
co_names: 所有的參數名（包括*參數和**參數）和局部變數名的元組。
co_varnames: 所有的局部變數名的元組。
co_filename: 源代碼所在的文件名。
co_flags: 這是一個數值，每一個二進制位都包含了特定信息。較關注的是0b100(0×4)和0b1000(0×8)，如果co_flags & 0b100 != 0，說明使用了*args參數；如果co_flags & 0b1000 != 0，說明使用了**kwargs參數。另外，如果co_flags & 0b100000(0×20) != 0，則說明這是一個生成器函數(generator function)。
co = cat.sayHi.func_code
print co.co_argcount # 1
print co.co_names # ('name',)
print co.co_varnames # ('self',)
print co.co_flags & 0b100 # 0

2.9. 棧幀(frame)
棧幀表示程序運行時函數調用棧中的某一幀。函數沒有屬性可以獲取它，因為它在函數調用時才會產生，而生成器則是由函數調用返回的，所以有屬性指向棧幀。想要獲得某個函數相關的棧幀，則必須在調用這個函數且這個函數尚未返回時獲取。你可以使用sys模塊的_getframe()函數、或inspect模塊的currentframe()函數獲取當前棧幀。這里列出來的屬性全部是只讀的。
f_back: 調用棧的前一幀。
f_code: 棧幀對應的code對象。
f_locals: 用在當前棧幀時與內建函數locals()相同，但你可以先獲取其他幀然後使用這個屬性獲取那個幀的locals()。
f_globals: 用在當前棧幀時與內建函數globals()相同，但你可以先獲取其他幀……。

def add(x, y=1):
f = inspect.currentframe()
print f.f_locals # same as locals()
print f.f_back # <frame object at 0x...>
return x+y
add(2)

2.10. 追蹤(traceback)
追蹤是在出現異常時用於回溯的對象，與棧幀相反。由於異常時才會構建，而異常未捕獲時會一直向外層棧幀拋出，所以需要使用try才能見到這個對象。你可以使用sys模塊的exc_info()函數獲得它，這個函數返回一個元組，元素分別是異常類型、異常對象、追蹤。traceback的屬性全部是只讀的。
tb_next: 追蹤的下一個追蹤對象。
tb_frame: 當前追蹤對應的棧幀。
tb_lineno: 當前追蹤的行號。
def div(x, y):
try:
return x/y
except:
tb = sys.exc_info()[2] # return (exc_type, exc_value, traceback)
print tb
print tb.tb_lineno # "return x/y" 的行號
div(1, 0)

3. 使用inspect模塊
inspect模塊提供了一系列函數用於幫助使用自省。下面僅列出較常用的一些函數，想獲得全部的函數資料可以查看inspect模塊的文檔。
3.1. 檢查對象類型
is{mole|class|function|method|builtin}(obj):
檢查對象是否為模塊、類、函數、方法、內建函數或方法。
isroutine(obj):
用於檢查對象是否為函數、方法、內建函數或方法等等可調用類型。用這個方法會比多個is*()更方便，不過它的實現仍然是用了多個is*()。
im = cat.sayHi
if inspect.isroutine(im):
im()

對於實現了__call__的類實例，這個方法會返回False。如果目的是只要可以直接調用就需要是True的話，不妨使用isinstance(obj, collections.Callable)這種形式。我也不知道為什麼Callable會在collections模塊中，抱歉！我猜大概是因為collections模塊中包含了很多其他的ABC(Abstract Base Class)的緣故吧：）
3.2. 獲取對象信息
getmembers(object[, predicate]):
這個方法是dir()的擴展版，它會將dir()找到的名字對應的屬性一並返回，形如[(name, value), ...]。另外，predicate是一個方法的引用，如果指定，則應當接受value作為參數並返回一個布爾值，如果為False，相應的屬性將不會返回。使用is*作為第二個參數可以過濾出指定類型的屬性。
getmole(object):
還在為第2節中的__mole__屬性只返回字元串而遺憾嗎？這個方法一定可以滿足你，它返回object的定義所在的模塊對象。
get{file|sourcefile}(object):
獲取object的定義所在的模塊的文件名|源代碼文件名（如果沒有則返回None）。用於內建的對象（內建模塊、類、函數、方法）上時會拋出TypeError異常。
get{source|sourcelines}(object):
獲取object的定義的源代碼，以字元串|字元串列表返回。代碼無法訪問時會拋出IOError異常。只能用於mole/class/function/method/code/frame/traceack對象。
getargspec(func):
僅用於方法，獲取方法聲明的參數，返回元組，分別是(普通參數名的列表, *參數名, **參數名, 默認值元組)。如果沒有值，將是空列表和3個None。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。
def add(x, y=1, *z):
return x + y + sum(z)
print inspect.getargspec(add)
#ArgSpec(args=['x', 'y'], varargs='z', keywords=None, defaults=(1,))

getargvalues(frame):
僅用於棧幀，獲取棧幀中保存的該次函數調用的參數值，返回元組，分別是(普通參數名的列表, *參數名, **參數名, 幀的locals())。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。
def add(x, y=1, *z):
print inspect.getargvalues(inspect.currentframe())
return x + y + sum(z)
add(2)
#ArgInfo(args=['x', 'y'], varargs='z', keywords=None, locals={'y': 1, 'x': 2, 'z': ()})

getcallargs(func[, *args][, **kwds]):
返回使用args和kwds調用該方法時各參數對應的值的字典。這個方法僅在2.7版本中才有。
getmro(cls):
返回一個類型元組，查找類屬性時按照這個元組中的順序。如果是新式類，與cls.__mro__結果一樣。但舊式類沒有__mro__這個屬性，直接使用這個屬性會報異常，所以這個方法還是有它的價值的。
print inspect.getmro(Cat)
#(<class '__main__.Cat'>, <type 'object'>)
print Cat.__mro__
#(<class '__main__.Cat'>, <type 'object'>)

『捌』 java 反射 方法調用

JAVA反射機制是在運行狀態中，對於任意一個類，都能夠知道這個類的所有屬性和方法；對於任意一個對象，都能夠調用它的任意一個方法和屬性；這種動態獲取的信息以及動態調用對象的方法的功能稱為java語言的反射機制。
JAVA反射（放射）機制：「程序運行時，允許改變程序結構或變數類型，這種語言稱為動態語言」。從這個觀點看，Perl，Python，Ruby是動態語言，C++，Java，C#不是動態語言。但是JAVA有著一個非常突出的動態相關機制：Reflection，用在Java身上指的是我們可以於運行時載入、探知、使用編譯期間完全未知的classes。換句話說，Java程序可以載入一個運行時才得知名稱的class，獲悉其完整構造（但不包括methods定義），並生成其對象實體、或對其fields設值、或喚起其methods。
說白了就是調用這個累的.Class方法然後調用其屬性和方法。

『玖』 如何通過反射調用類中的<泛型>方法

定義的介面：
[csharp] view plain

namespace IProgramShut

{

public interface IShut

{

/// <summary>

/// 操作名稱

/// </summary>

string OperatorName

{

get;

}

/// <summary>

/// 操作方法

/// </summary>

/// <typeparam name="T"><peparam>

/// <typeparam name="TResult"><peparam>

/// <param name="t"></param>

/// <returns></returns>

TResult Operator<T, TResult>(T t);

}

}

派生自介面的派生類：
[csharp] view plain

namespace ProgramShutDown

{

public class ProgramShutDown :IShut

{

/// <summary>

/// 顯示「關機」字樣

/// </summary>

public string OperatorName

{

get

{

return "關機";

}

}

/// <summary>

/// 關機操作

/// </summary>

/// <typeparam name="T"><peparam>

/// <typeparam name="TResult"><peparam>

/// <param name="t"></param>

/// <returns></returns>

public TResult Operator<T,TResult>(T t)

{

this.ShutDown(t.ToString());

return default(TResult);

}

/// <summary>

/// 執行關機

/// </summary>

/// <param name="second"></param>

public void ShutDown(string second)

{

Process process = new Process();

try

{

process.StartInfo.FileName = "cmd.exe";

process.StartInfo.UseShellExecute = false;

process.StartInfo.RedirectStandardInput = true;

process.StartInfo.RedirectStandardOutput = true;

process.StartInfo.RedirectStandardError = true;

process.StartInfo.CreateNoWindow = true;

process.Start();

process.StandardInput.WriteLine("shutdown -s -f -t " + second);

process.StandardInput.WriteLine("exit");

}

catch (Exception ex)

{

}

finally

{

process.Close();

process.Dispose();

process = null;

}

}

}

}

具體的調用方法：
[csharp] view plain

Type t = tsi.Tag as Type;

//1、獲取指定方法名稱的泛型方法

MethodInfo mi = t.GetMethod("Operator");

//2、創建一個對應泛型類型的非泛型反射方法

MethodInfo mi2 = mi.MakeGenericMethod(new Type[] { typeof(int), typeof(int) });

object o = Activator.CreateInstance(t);

mi2.Invoke(o, new object[] { 3000 });

其中tsi是一個ToolStripItem對象，我把通過反射獲取到的需要被調用的類的類型存在了ToolStripItem.Tag中了， MethodInfo mi =t.GetMethod("Operator")通過方法名稱獲取到泛型方法的版本，然後在獲取到的泛型方法MethodInfo mi的基礎上，通過mi的MakeGenericMethod(new Type[] { typeof(int), typeof(int) })方法，創建一個非泛型版本，其中new Type[] { typeof(int), typeof(int)}是用來替換泛型類型 T,TResult的具體類型，其中泛型方法在介面中的聲明如下：
[csharp] view plain

TResult Operator<T, TResult>(T t);

MethodInfo 類中的 MakeGenericMethod方法在NET中定義如下

[csharp] view plain

//

// 摘要:

// 用類型數組的元素替代當前泛型方法定義的類型參數，並返回表示結果構造方法的 System.Reflection.MethodInfo 對象。

//

// 參數:

// typeArguments:

// 要替換當前泛型方法定義的類型參數的類型數組。

//

// 返回結果:

// 一個 System.Reflection.MethodInfo 對象，表示通過將當前泛型方法定義的類型參數替換為 typeArguments 的元素生成的構造方法。

//

// 異常:

// System.InvalidOperationException:

// 當前 System.Reflection.MethodInfo 不表示泛型方法定義。 也就是說，System.Reflection.MethodInfo.IsGenericMethodDefinition

// 返回 false。

//

// System.ArgumentNullException:

// typeArguments 為 null。 - 或 - typeArguments 的所有元素均為 null。

//

// System.ArgumentException:

// typeArguments 中元素的數目與當前泛型方法定義的類型參數的數目不同。 - 或 - typeArguments 的某個元素不滿足為當前泛型方法定義的相應類型參數指定的約束。

//

// System.NotSupportedException:

// 不支持此方法。

public virtual MethodInfo MakeGenericMethod(params Type[] typeArguments);

第一次嘗試的時候是通過mi.Invoke直接調用的爆出了異常：無法綁定到目標方法，因其簽名或安全透明度與委託類型的簽名或安全透明度不兼容。後來查資料再是嘗試，找到了另外的調用方式。做個記錄。
再說一句：在這個例子中，想要調用的方法剛好是從介面中繼承來的，public類型的方法，在通過反射調用泛型方法的時候已經獲取到了對應類型的實例對象，原本可以直接通過實例對象調用對應的方法，但是不排除將來在實際使用的時候想要調用的是private方法，或者是派生類中特有的定義的方法，這個例子只是湊巧了。

『拾』 反射調用方法 返回自定義List列表，如何進行

usingSystem;
usingSystem.Collections.Generic;
usingSystem.Linq;
usingSystem.Text;
usingSystem.Threading.Tasks;
usingSystem.Dynamic;

namespaceConsoleApplication2
{
classProgram
{
staticvoidMain(string[]args)
{
varlist=Enumerable.Range(0,5).Select(x=>new{ID=x,Name="Name"+x.ToString()}).ToList();
objectobj=list;
varitor=obj.GetType().GetMethods().Where(x=>x.Name=="GetEnumerator").First().Invoke(obj,newobject[]{})asSystem.Collections.IEnumerator;
while(itor.MoveNext())
{
objectcurrent=itor.Current;
stringName=current.GetType().GetProperties().Where(x=>x.Name=="Name").First().GetValue(current,newobject[]{}).ToString();
Console.WriteLine(Name);
}
}
}
}