C# fonksiyon aşırı yükleme kuralları

Question

Fonksiyon aşırı yükleme ile ilgili kurallar nelerdir?

Aşağıdaki kod var: Birlikte yukarıdaki kodu çağırdığınızda

public T genericFunc<T>() where T : Component, new() 
{ 
    T result = new T(); 
    overloadedFunction(result); 
} 

private overloadedFunction (Component c) // catch all function 

private overloadedFunction (DerivedFromComponent dfc) // specific function 

: Ancak yakalamak Daha belirgin overloadedFunction çağrılacak bekliyoruz

genericFunc<DerivedFromComponent>(); 

tüm işlev yerine denir , bu neden?. Yukarıdaki koddan geçerken T tipi gerçekten de TüretilmişFromComponent, CLR'nin çalışma zamanında mümkün olan en iyi eşleşmeyi seçtiğini düşünmüştüm!

Answer 1

Bu yöntem, derlendiğinde, derleyici genericFunciçinde aşırı yük çözünürlüğü gerçekleştirir. Bu noktada ne tür bir argüman sağlayacağınızı bilmiyor, bu yüzden sadece aşırı yüklenmelerinizin ilkini arayabileceğini biliyor.

Örneğiniz jenerik kullanarak hayatınızı daha karmaşık hale getirir, ancak aşırı yükler her zaman derleme zamanında çözülür (dynamic kullanmadığınız varsayılarak).

basit bir örnek jenerik kullanmayan: x arasında derleme tipi sadece nesne olduğu için

void Foo(string text) { } 
void Foo(object o) {} 
... 
object x = "this is a string"; 
Foo(x); 

, ikinci aşırı çağırır.

Bunun hakkında daha fazla bilgi için, benim son article on overloading'u okuyun.

Answer 2

Jon Skeet, derleme zamanında aşırı yük çözünürlüğünün belirlendiği gerçeğine göre açıktır. Sorununun konusu olmayan ama yine de dikkat edilmesi gereken bir başka cevap daha ekleyeceğimi düşündüm.

C# 4'te, dinamik anahtar sözcük, çalışma zamanına kadar aşırı yük çözünürlüğünü ertelemek için kullanılabilir. basar aşağıdaki parçacığını göz önünde bulundurun:

Base! 
Derived! 

class Base { 
} 

class Derived : Base { 
} 

void DoSomething(Base x) { 
    Console.WriteLine("Base!"); 
} 

void DoSomething(Derived x) { 
    Console.WriteLine("Derived!"); 
} 

void DoSomething<T>() where T: Base, new() { 
    dynamic x = new T(); 
    DoSomething(x); 
} 

void Main() 
{ 
    DoSomething<Base>(); 
    DoSomething<Derived>(); 
}