Question

I have implemented a strongly typed implementation of INotifyPropertyChanged, except instead of using the interface, I have added a base class to implement.

It works fine, but the bit I am struggling with is why TValue is used in the base method declaration (I did use this section from some code I found online)

NotifyPropertyUpdate<TValue>(…

BUT in the derived class, it doesn’t need to pass TValue at all!

What tells the compiler to resolve this at runtime instead of complaining at build?

Thanks,

Base class:

public class NotifyFuncPropertyChanged<T> : INotifyPropertyChanged
{
    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged;

    protected void NotifyPropertyUpdate<TValue>(Expression<Func<T, TValue>> selector)
    {
        //get memberInfo from object selection
        MemberInfo memberInfoSelection;
        Expression body = selector;
        if (body is LambdaExpression)
        {
            body = ((LambdaExpression)body).Body;
        }
        switch (body.NodeType)
        {
            case ExpressionType.MemberAccess:
                memberInfoSelection =((MemberExpression)body).Member;
                break;
            default:
                throw new InvalidOperationException();
        }

        //send notifyupdate to memberInfo
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(memberInfoSelection.Name));
        }
    }

    #endregion
}

Usage (derived class)

public class NameTest : NotifyFuncPropertyChanged<NameTest>
{
    public string Name { get; set; }

    public void TestUpdateName()
    {
        this.NotifyPropertyUpdate(x => x.Name);
    }
}

Answer 1

The C# compiler has a feature called Type inference. You can read about it in all its complexity in the language specification, in section 7.5.2, or there’s a very brief introduction here.

From the spec:

When a generic method is called without specifying type arguments, a
type inference process attempts to infer type arguments for the call. The presence of type inference allows a more convenient syntax
to be used for calling a generic method, and allows the programmer to
avoid specifying redundant type information. For example, given the
method declaration:

class Chooser
{
  static Random rand = new Random();
  public static T Choose<T>(T first, T second) {
      return (rand.Next(2) == 0)? first: second;
  }
}

it is possible to invoke the Choose method without explicitly
specifying a type argument:

int i = Chooser.Choose(5, 213);                   // Calls Choose<int>
string s = Chooser.Choose("foo", "bar");      // Calls Choose<string>

Through type inference, the type arguments int and string are
determined from the arguments to the method.