Better conversion from expression

Given an implicit conversion C₁ that converts from an expression E to a type T₁, and an implicit conversion C₂ that converts from an expression E to a type T₂, C₁ is a better conversion than C₂ if at least one of the following holds:

· E has a type S and an identity conversion exists from S to T₁ but not from S to T₂

· E is not an anonymous function and T₁ is a better conversion target than T₂ (§7.5.3.5)

· E is an anonymous function, T₁ is either a delegate type D₁ or an expression tree type Expression<D₁>, T₂ is either a delegate type D₂ or an expression tree type Expression<D₂> and one of the following holds:

o D₁ is a better conversion target than D₂

o D₁ and D₂ have identical parameter lists, and one of the following holds:

· D₁ has a return type Y₁, and D₂ has a return type Y₂, an inferred return type X exists for E in the context of that parameter list (§7.5.2.12), and the conversion from X to Y₁ is better than the conversion from X to Y₂

· D₁ has a return type Y, and D₂ is void returning

Better conversion from type

Given a conversion C₁ that converts from a type S to a type T₁, and a conversion C₂ that converts from a type S to a type T₂, C₁ is a better conversion than C₂ if at least one of the following holds:

· An identity conversion exists from S to T₁ but not from S to T₂

· T₁ is a better conversion target than T₂ (§7.5.3.5)

Better conversion target

Given two different types T₁ and T₂, T₁ is a better conversion target than T₂ if at least one of the following holds:

· An implicit conversion from T₁ to T₂ exists, and no implicit conversion from T₂ to T₁ exists

· T₁ is a signed integral type and T₂ is an unsigned integral type. Specifically:

o T₁ is sbyte and T₂ is byte, ushort, uint, or ulong

o T₁ is short and T₂ is ushort, uint, or ulong

o T₁ is int and T₂ is uint, or ulong

o T₁ is long and T₂ is ulong

Overloading in generic classes

While signatures as declared must be unique, it is possible that substitution of type arguments results in identical signatures. In such cases, the tie-breaking rules of overload resolution above will pick the most specific member.

The following examples show overloads that are valid and invalid according to this rule:

interface I1<T> {...}

interface I2<T> {...}

class G1<U>
{
int F1(U u); // Overload resulotion for G<int>.F1
int F1(int i); // will pick non-generic

void F2(I1<U> a); // Valid overload
void F2(I2<U> a);
}

class G2<U,V>
{
void F3(U u, V v); // Valid, but overload resolution for
void F3(V v, U u); // G2<int,int>.F3 will fail

void F4(U u, I1<V> v); // Valid, but overload resolution for
void F4(I1<V> v, U u); // G2<I1<int>,int>.F4 will fail

void F5(U u1, I1<V> v2); // Valid overload
void F5(V v1, U u2);

void F6(ref U u); // valid overload
void F6(out V v);
}

Дата добавления: 2015-11-16