TypeOf Enhancements

[TonyValenti]

Hi C# Team,
I would like to request a few enhancements to the "TypeOf" operator.

Often times I find myself writing code that needs a type provided. Here's a basic example:

public class ContactComboBox {

public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register("ItemsSource", typeof(IEnumerable<ContactJson>), typeof(ContactComboBox), new PropertyMetadata(null, ItemsSourcePropertyChanged));

 public IEnumerable<ContactJson> ItemsSource {
            get {
                return (IEnumerable<ContactJson>)GetValue(ItemsSourceProperty);
            }
            set {
                SetValue(ItemsSourceProperty, value);
            }
        }

}

I love how the "nameof" operator makes my code refactoring-safe. For example, I can do:

DependencyProperty.Register(nameof(ItemsSource), ...

And then my dependency property will always be registered with the same name of the exposed property, even if I refactor my code. Unfortunately, if I change the type of my property, I have a long find-and-replace job ahead of me.

I would like "typeof" to be expanded to allow me to reference other members just like "nameof" does. For example:

DependencyProperty.Register(nameof(ItemsSource), typeof(ItemsSource), typeof(this) ...

You'll notice that this has two enhancements:
typeof(member) - this enhancement allows typeof(...) to resolve to the DECLARED type of a member/variable. This is not the same as GetType() which requires an instance. For example:

long? PersonID = null; //typeof(PersonID) = long?
Person MyPerson = new Grandparent(); //typeof(MyPerson) = Person.  MyPerson.GetType() = Grandparent;

The second enhancement is:
typeof(this) . This is a special case which means "resolve to the type of the containing class". I will point out that this is not the this instance.

for example:

public class Person {
 private static type MyType = typeof(this); // resolves to Person

 public static class PersonHelpers {
   private static type MyType = typeof(this); // resolves to PersonHelpers
 }
}

[HaloFour]

TL;DR:

public class Foo {
    public int Bar { get; set; }
    public string Baz;

    public double M() {
        // existing syntax
        var t1 = typeof(Foo); // type is Foo

        // proposed syntax
        var t2 = typeof(this); // same as typeof(Foo)
        var t3 = typeof(Bar); // same as typeof(System.Int32)
        var t4 = typeof(Baz); // same as typeof(System.String)

        var t5 = typeof(M); // legal? typeof(System.Double)?
    }
}

I largely like the idea, however I have a few qualms:

1. I don't think that typeof(property) or typeof(field) will work without some kind of qualifier, e.g. typeof(this.Bar) or typeof(Foo.Bar). This will disambiguate situations where a property or field might have the same name as a type in scope. The current syntax always favors types and doesn't consider other members.

   public class A { }
   public class B {
       public int A { get; set; }
       public Type M() => typeof(A); // returns A, not int
   }

2. The syntax typeof(this) is nice shorthand, however I have a concern that there might be the expectation that it might refer to the derived type:

   public class A {
       public Type M() => typeof(this);
   }
   public class B : A {
       public Type M2() => M(); // returns typeof(A), not typeof(B)
   }

[svick]

For members, I think I would prefer memberof/infoof (#712), since it's more general. If you need the type of the ItemsSource property, you would write memberof(ItemsSource).PropertyType.

And this proposal has the same issue as memberof when it comes to methods: overloading. If you have multiple overloads of method M, what would typeof(M) return?

[iam3yal]

@svick

Well, memberof can optionally accept additional arguments that describe the method you want to pick.

Say we have the following methods:

public void M()
{
}

public void M(int x)
{
}

Now, say we want to pick M(int x) over M then it should be possible to specify that through something like this memberof(M, int).

[HaloFour]

@eyalsk

I'm a bigger fan of the syntax memberof(M(int)) personally. Either way you'd need changes to the parser since the argument isn't a valid expression today.

[iam3yal]

@HaloFour I don't mind either way but yeah but M(int) is probably better.

[jnm2]

Definitely prefer #712.

[busterwood]

I had a very similar idea, but my use-case is casting.
Taking your original example, you could use a typeof cast in the property getter:

public IEnumerable<ContactJson> ItemsSource {
    get {
        return (typeof(this.ItemsSource))GetValue(ItemsSourceProperty);
    }
    set {
        SetValue(ItemsSourceProperty, value);
    }
}

[busterwood]

I would also like to declare fields, parameters and variable using typeof, which reduces duplication of type declarations, addtionally makes refactoring easier.
For example:

class Customer {
    public int Id { get; set; }
    public List<Order> Orders { get; set; }
    ...
}

interface IRepository {
    Customer Get(typeof(Customer.Id) id);
    typeof(Customer.Orders) ReloadOrders(typeof(Customer.Id) id);
}

Basically, why not allow typeof(...) to be used anywhere a type is expected by the compiler?

[DarthVella]

@busterwood typeof() allows access to details of the type, eg. assembly information, generic attributes, etc. It does not refer to the type in any way usable as a cast operator or instance declaration.

That's not to say there is no merit to having a keyword for that functionality, but it should be opened and discussed in a different thread.

[busterwood]

okay, opened #1294