class Foo
{
    public new string ToString() => string.Empty;
}

When doing GetMethod, check flags etc.

Types loaded in a reflection-only context enforce this at runtime, but for all types it's still an optimization and possibly a security improvement.

Type.GetType and Assembly.GetType, suggest adding null check or adding throwOnError: true.

namespace RoslynSandbox
{
    using System.Reflection;
    using NUnit.Framework;

    class Foo
    {
        internal static class Bar
        {
        }
    }

    class Tests
    {
        [Test]
        public void SomeTest()
        {
            Assert.NotNull(typeof(Foo).GetNestedType(nameof(Foo.Bar), BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
        }
    }
}

The msdn docs are not awesome here:

A bitmask comprised of one or more BindingFlags that specify how the search is conducted.

Today we only check typeof(Foo).GetMethod("Bar") for simplicity.

var method = obj.GetType().GetMethod("Bar");

var type = typeof(Foo);
var method = .GetMethod("Bar");

Are two other common cases, we walk a bit and try to find out the type.

GetCustomAttribute<FooAttribute>() instead of (FooAttribute)GetCustomAttribute(typeof(FooAttribute))—I keep seeing this.

Roll our own BindingFlags

Given:

class Foo : Base
{
}

public class Base
{
    public static class PublicStatic
    {
    }

    public class Public
    {
    }

    private static class PrivateStatic
    {
    }

    private class Private
    {
    }
}

Does GetNestedType always return null?

var type = typeof(Foo).GetNestedType(nameof(Public), BindingFlags.Public | BindingFlags.FlattenHierarchy)

💭 This is .NET Core 2.1 only. If the project targets anything else, perhaps suggest creating and invoking a typed delegate in order to avoid wrapping with TargetInvocationException?

@jnm2 you know this right?

OCD analyzer for max consistency.

Also instead of Array.Empty<Type>().

Refactorings should also use this.

Example GetMethod("Foo") when there is a property named Foo

List all members in for example GetMethod() and generate name, bindingflags, types etc.

Nuget.exe does not handle the helper dlls in the package like we have them now well.

Also nasty in the sln browser:

Applies to methods (incl constructors) and properties.

Or vice versa?

• Action & Action<...>
• Func<...>
• Custom delegates.

Everything is correct here and the warning goes away when navigating to the document.

Before:

class Foo
{
    public Foo()
    {
        var methodInfo = typeof(Foo).GetMethod(nameof(this.Id)) 
                                    .Invoke(null, new object[] { 1 }); 
    }
    public T Id<T>(T value) => value;
}

After:

class Foo
{
    public Foo()
    {
        var methodInfo = typeof(Foo).GetMethod(nameof(this.Id))
                                    .MakeGenericMethod(typeof(int)) 
                                    .Invoke(null, new object[] { 1 });
    }
    public T Id<T>(T value) => value;
}

methodInfo.Invoke(null, Array.Empty<object>()) should really be methodInfo.Invoke(null, null), constructorInfo.Invoke(new object[0]) should be constructorInfo.Invoke(null), etc.

Before:

namespace RoslynSandbox
{
    using System;
    using System.Reflection;
    using System.Windows.Controls;

    class C
    {
        private static readonly Type TemplatedAdornerType = typeof(AdornedElementPlaceholder).Assembly.GetType("MS.Internal.Controls.TemplatedAdorner", throwOnError: true);
        private static readonly MethodInfo ClearChildMethod = TemplatedAdornerType.GetMethod("ClearChild");
    }
}

After:

namespace RoslynSandbox
{
    using System;
    using System.Reflection;
    using System.Windows.Controls;

    class C
    {
        private static readonly Type TemplatedAdornerType = typeof(AdornedElementPlaceholder).Assembly.GetType("MS.Internal.Controls.TemplatedAdorner", throwOnError: true);
        private static readonly Action<Adorner> ClearChildMethod = (Action<Adorner>)Delegate.CreateDelegate(typeof(Action<Adorner>), TemplatedAdornerType.GetMethod("ClearChild"), throwOnBindFailure: true);
    }
}

Also check that Activator.CreateInstance<T>() has a public default constructor?

Not sure about this one, but I picked up on this at https://github.com/dotnet/corefx/issues/23762#issuecomment-327223953 and also on a similar issue a long time ago.

GetGenericArguments() returns parameters (not arguments) if the type is a generic definition, and it returns arguments if the type is a constructed generic.

GenericTypeArguments is better if you expect the type to be constructed.
GenericTypeParameters is better if you expect the type to be a definition. It only exists after adding .GetTypeInfo() though.
If you don't have an expectation about constructed vs definition, I'm not sure how you can meaningfully use GetGenericArguments().

Before:

namespace RoslynSandbox
{
    using System.Reflection;

    class Foo
    {
        public Foo()
        {
            var methodInfo = typeof(Foo).GetMethod(nameof(this.Bar);
        }

        public static void Bar()
        {
        }
    }
}

After:

namespace RoslynSandbox
{
    using System.Reflection;

    class Foo
    {
        public Foo()
        {
            var methodInfo = typeof(Foo).GetMethod(
                nameof(this.Bar),
                BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
        }

        public static void Bar()
        {
        }
    }
}

• MakeGenericMethod
• MakeGenericType

Forms of object != null && type.IsAssignableFrom(obj.GetType()) should be replaced with type.IsInstanceOfType(obj).

• GetConstructor
• GetEvent
• GetField
• GetMember
• GetMethod
• GetNestedType
• GetProperty

Just a reminder, wrote it to only do the check when GetMethod is invoked with string name only.

For troubleshooting #44

Generic interface types may be implemented multiple times.

Refactor to .FirstOrDefault(interfaceType => interfaceType.IsGenericType && interfaceType.GetGenericTypeDefinition() == ...)

I have encountered a situation in the past where public vs private depended on the version of the framework the code was running against. (using reflection to access a private member that was later made public)

Maybe warn for types in sln?

class Foo
{
    private static readonly int Value;
}

class Bar : Foo
{
}

Before:

typeof(Bar).GetField("Value", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.FlattenHierarchy)

After:

typeof(Foo).GetField("Value", BindingFlags.NonPublic | BindingFlags.Static)

Only if no BindingFlags value is already specified.

| BindingBlags.Public should be added to preserve the previous visibility behavior.

Instead of relying on hierarchy flattening of public members and walking the inheritance chain. Also could suggest BindingFlags.DeclaredOnly for perf if that doesn't make the reflection reasoning too brittle.

Including static vs instance.

Needs ref probably a bug

Throws at runtime.