Why doesn't the generic type match the type?

Question

I have two classes: BaseClass and Person . The Person class inherits from BaseClass . Then I use the following general method.

  public static PropertyInfo GetProperty<T>(T item, Func<PropertyInfo, bool> predicate) { return GetProperty(typeof(T), predicate); } 

Inside BaseClass , I have a method that calls GetProperty

 public class BaseClass { public void DoSomething() { var property = GetProperty(new Person(), (property) => p.Name == "Name"); } } 

Then I call this method from unit test.

 var person = new Person(); person.DoSomething(); 

When typeof(T) , BaseClass returned. If I use item.GetType() , then Person returns. If I run them in the debugger, T is of type BaseClass and item is of type Person . Why does this not mean that T is typeof(Person) when it already knows that item is Person?

Edit

My example was wrong above, sorry when I call GetProperty, I pass this .

 public class BaseClass { public void DoSomething() { var property = GetProperty(this, (property) => p.Name == "Name"); } } 

Answer 1

The reason for this inference problem is that the general inference occurs at compile time and is thus identical to setting the desired type manually. If you switch to an explicit <Person> message with a call, does it cause an error at compile time?

One way is to make sure that the variable (note: NOT the Object!) You pass in explicitly refers to the Person class, as it seems in your code. Another way is to make general output happen at runtime using dyanmic :

 GetProperty(this as dynamic, (prop) => prop.Name == "Name"); 

When clicking this as dynamic it calls GetProperty<dynamic> , using the exact type of this at runtime. The problem with this approach is that the dynamics are extremely slow compared to other objects.

If your models are strictly at the same level of inheritance, you can also use static polymorphism to handle the general parameter. Thusly:

 public class BaseClass<TSelf> where TSelf : BaseClass<TSelf> public sealed class Model : BaseClass<Model> 

That way you can use TSelf as a parameter instead of T , and that will be exactly correct. The problem with this approach is that it strictly limits you to one hierarchy with one inheritance, since everything that inherits from Model will return to the original problem and will be considered as Model , since it cannot override the used general parameter by its base class.

Assuming your GetProperty function does some reflection to check the property, you might consider passing a Type object instead of using a generic one and then typeof(T) , since .GetType() much more accurate.