How to skip indexer properties in FastMember?

Question

I am using FastMember to dynamically read property values of certain types. Something like this:

TypeAccessor accessor = TypeAccessor.Create(type);
return accessor.GetMembers().Where(m => m.CanRead).Select(m => accessor[item, m.Name]);

But I would like to omit indexers. m here is type of Member, but it doesnt seem to have a way to check if Member is an indexer or not.

Is this functionality really not there?

Answer 1

No. Member type has limited information exposed about the type and is sealed and does not provide ways for extensibility. You can switch completely from using the library and manually cache the reflection or do some workarounds (a "bad" way - use reflection to access Member's private readonly MemberInfo member;). I would suggest a helper class, something like the following:

public static class IndexerHelper
{
    private static readonly ConcurrentDictionary<Type, string?> IndexerNames = new();

    public static bool IsIndexer(Type t, string name)
    {
        var indexerName = GetIndexerName(t);
        return indexerName is not null && indexerName == name;
    }
    
    internal static string? GetIndexerName(Type t)
    {
        if (t is { IsGenericType: true, IsGenericTypeDefinition: false })
        {
            t = t.GetGenericTypeDefinition();
        }
        // TODO - handle arrays?
        return IndexerNames.GetOrAdd(t, type => t.GetProperties()
            .SingleOrDefault(pi => pi.GetIndexParameters().Any())?.Name);
    }
}

And usage:

var type = typeof(Dictionary<int, object>);
TypeAccessor accessor = TypeAccessor.Create(type);

var members = accessor.GetMembers()
    .Where(m => m.CanRead && !IndexerHelper.IsIndexer(type, m.Name))
    .ToList();

Though you will need to pass around instance of Type in addition to the accessor itself.

Also you can fork the library and expose required data and/or create PR to it.

Answer 2

Most pragmatic way for you would be account for a fact that indexer internally is a property with well known name Item and additional parameter. If you work with regular, not obfuscated assemblies, you can filter out members with this name like this:

TypeAccessor accessor = TypeAccessor.Create(type);
return accessor.GetMembers().Where(m => m.CanRead && m.Name != "Item" && !m.GetAttribute(typeof(System.Runtime.CompilerServices.IndexerName), false)).Select(m => accessor[item, m.Name]);

Also Item property is reserved for C# as written in spec. https://learn.microsoft.com/en-Us/dotnet/csharp/language-reference/language-specification/classes#143104-member-names-reserved-for-indexers

Even if you can declare property with name Item, you cannot declare both property Item and indexer in the same class. Try this snippet.

public string Item { get; set; }
public string this[int x] { get => ""; set { } } // error here

This is long time implementation detail and unlikely it will ever change.

And if you at to be precise you may take a look at this PR. https://github.com/mgravell/fast-member/pull/102

Answer 3

After clarifying in comments that using FastMember is not a constraint I provide an answer using another library. I understand that you consider it a bit too broad, as its Reflection API is just one of the several other features it offers. Its 'broadness' has a simple reason: this way the library has no 3rd party references at all, but it's still allowed even for its fairly specialized APIs (such as reflection or serialization) to use all of the core components like high performance collections, etc.

As for getting property accessors for the non-indexer properties only, the solution is simple: as PropertyAccessors can be obtained by regular PropertyInfo instances you can simply perform the filtering on the actual properties:

var simpleProperties = type.GetTypeInfo().DeclaredProperties.Where(
    p => p.CanRead // readable properties
    && !p.GetMethod.IsStatic // instance properties
    && p.GetMethod.GetParameters().Length == 0); // non-indexers

// getting the PropertyAccessors for them:
return simpleProperties.Select(pi => PropertyAccessor.GetAccessor(pi));

The approach of getting/setting properties is a bit different. FastMember expects accessing the properties by name, whereas my library provides PropertyInfo-like accessors for each properties. In fact, you can also use the Reflector class if you want to access the properties by name but that class is more about convenience rather than performance.

See this online example for some usage test and comparisons with FastMember.

While creating the example and tried FastMember I realized that both libraries have pros and cons. For example, non-generic access is faster by FastMember than by my library. On the other hand, FastMember supports instance public properties and fields only (even if you specify allowNonPublicAccessors: true), whereas my library can access any kind of members of any visibility, including methods, constructors and static members.