23278216331

Committed 19 Mar 2026 03:19AM UTC coverage: 57.398% (+0.7%) from 56.658%

Build # 23278216331

Build Type

push

github

Committed by

pwelter34

Commit Message

Enable nullable and improve source generators

Coverage Stats

1403 of 3069 branches covered (45.72%)

Branch coverage included in aggregate %.

527 of 907 new or added lines in 58 files covered. (58.1%)

22 existing lines in 10 files now uncovered.

4288 of 6846 relevant lines covered (62.64%)

330.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

44.25

/src/FluentCommand/Reflection/TypeAccessor.cs

using System.Collections.Concurrent;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq.Expressions;
using System.Reflection;

namespace FluentCommand.Reflection;

/// <summary>
/// Provides efficient access to type reflection information, including dynamic creation, property, field, and method accessors,
/// and metadata such as table mapping. Caches accessors for performance and supports late-bound operations on types.
/// </summary>
public class TypeAccessor
{
    private static readonly ConcurrentDictionary<Type, TypeAccessor> _typeCache = new();
    private readonly ConcurrentDictionary<string, IMemberAccessor?> _memberCache = new();
    private readonly ConcurrentDictionary<int, IMethodAccessor?> _methodCache = new();
    private readonly ConcurrentDictionary<int, IMemberAccessor[]> _propertyCache = new();

    private readonly Lazy<Func<object>?> _constructor;
    private readonly Lazy<TableAttribute?> _tableAttribute;

    private readonly string? _tableName;
    private readonly string? _tableSchema;

    /// <summary>
    /// Initializes a new instance of the <see cref="TypeAccessor"/> class for the specified <see cref="Type"/>.
    /// </summary>
    /// <param name="type">The <see cref="Type"/> this accessor is for.</param>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name="type"/> is <c>null</c>.</exception>
    public TypeAccessor(Type type)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));

        Type = type;
        _constructor = new Lazy<Func<object>?>(() => ExpressionFactory.CreateConstructor(Type));
        _tableAttribute = new Lazy<TableAttribute?>(() => type.GetCustomAttribute<TableAttribute>(true));
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="TypeAccessor"/> class with pre-generated metadata,
    /// avoiding runtime reflection and expression compilation for AOT-friendly scenarios.
    /// </summary>
    /// <param name="type">The <see cref="Type"/> this accessor is for.</param>
    /// <param name="tableName">The pre-computed table name, or <c>null</c> to fall back to the type name.</param>
    /// <param name="tableSchema">The pre-computed table schema, or <c>null</c>.</param>
    /// <param name="constructor">A delegate that creates a new instance of the type, or <c>null</c> if no parameterless constructor exists.</param>
    protected TypeAccessor(
        Type type,
        string? tableName,
        string? tableSchema,
        Func<object>? constructor)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));

        Type = type;

        _tableName = tableName;
        _tableSchema = tableSchema;

#if NET6_0_OR_GREATER
        _constructor = new Lazy<Func<object>?>(constructor);
        _tableAttribute = new Lazy<TableAttribute?>((TableAttribute?)null);
#else
        _constructor = new Lazy<Func<object>?>(() => constructor);
        _tableAttribute = new Lazy<TableAttribute?>(static () => null);
#endif
    }

    /// <summary>
    /// Gets the <see cref="Type"/> this accessor is for.
    /// </summary>
    /// <value>The <see cref="Type"/> this accessor is for.</value>
    public Type Type { get; }

    /// <summary>
    /// Gets the name of the type.
    /// </summary>
    /// <value>The name of the type.</value>
    public string Name => Type.Name;

    /// <summary>
    /// Gets the name of the table the class is mapped to, as specified by the <see cref="TableAttribute"/>.
    /// If not specified, returns the type name.
    /// </summary>
    /// <value>The name of the mapped table.</value>
    public string TableName => _tableName ?? _tableAttribute.Value?.Name ?? Type.Name;

    /// <summary>
    /// Gets the schema of the table the class is mapped to, as specified by the <see cref="TableAttribute"/>.
    /// </summary>
    /// <value>The schema of the mapped table, or <c>null</c> if not specified.</value>
    public string? TableSchema => _tableSchema ?? _tableAttribute.Value?.Schema;

    /// <summary>
    /// Creates a new instance of the type represented by this accessor using the default constructor.
    /// </summary>
    /// <returns>A new instance of the type.</returns>
    /// <exception cref="InvalidOperationException">Thrown if a parameterless constructor is not found.</exception>
    public object Create()
    {
        var constructor = _constructor.Value;
        if (constructor == null)
            throw new InvalidOperationException($"Could not find constructor for '{Type.Name}'.");

        return constructor.Invoke();
    }

    #region Method

    /// <summary>
    /// Finds a method with the specified <paramref name="name"/> and no parameters.
    /// </summary>
    /// <param name="name">The name of the method.</param>
    /// <returns>An <see cref="IMethodAccessor"/> for the method, or <c>null</c> if not found.</returns>
    public IMethodAccessor? FindMethod(string name)
    {
        return FindMethod(name, Type.EmptyTypes);
    }

    /// <summary>
    /// Finds a method with the specified <paramref name="name"/> and parameter types.
    /// </summary>
    /// <param name="name">The name of the method.</param>
    /// <param name="parameterTypes">The method parameter types.</param>
    /// <returns>An <see cref="IMethodAccessor"/> for the method, or <c>null</c> if not found.</returns>
    public IMethodAccessor? FindMethod(string name, params Type[] parameterTypes)
    {
        return FindMethod(name, parameterTypes, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
    }

    /// <summary>
    /// Finds a method with the specified <paramref name="name"/>, parameter types, and binding flags.
    /// </summary>
    /// <param name="name">The name of the method.</param>
    /// <param name="parameterTypes">The method parameter types.</param>
    /// <param name="flags">The binding flags to use for the search.</param>
    /// <returns>An <see cref="IMethodAccessor"/> for the method, or <c>null</c> if not found.</returns>
    public IMethodAccessor? FindMethod(string name, Type[] parameterTypes, BindingFlags flags)
    {
        int key = MethodAccessor.GetKey(name, parameterTypes);

        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_methodCache.TryGetValue(key, out var cached))
            return cached;

        return _methodCache.GetOrAdd(key, n => CreateMethodAccessor(name, parameterTypes, flags));
    }

    private MethodAccessor? CreateMethodAccessor(string name, Type[] parameters, BindingFlags flags)
    {
        var info = FindMethod(Type, name, parameters, flags);
        return info == null ? null : CreateAccessor(info);
    }

    private static MethodInfo? FindMethod(Type type, string name, Type[] parameterTypes, BindingFlags flags)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));
        if (name == null)
            throw new ArgumentNullException(nameof(name));

        if (parameterTypes == null)
            parameterTypes = Type.EmptyTypes;

        var typeInfo = type.GetTypeInfo();

        //first try full match
        var methodInfo = typeInfo.GetMethod(name, parameterTypes);
        if (methodInfo != null)
            return methodInfo;

        // next, get all that match by name
        var methodsByName = typeInfo.GetMethods(flags)
          .Where(m => m.Name == name)
          .ToList();

        if (methodsByName.Count == 0)
            return null;

        // if only one matches name, return it
        if (methodsByName.Count == 1)
            return methodsByName[0];

        // next, get all methods that match param count
        var methodsByParamCount = methodsByName
            .Where(m => m.GetParameters().Length == parameterTypes.Length)
            .ToList();

        // if only one matches with same param count, return it
        if (methodsByParamCount.Count == 1)
            return methodsByParamCount[0];

        // still no match, make best guess by greatest matching param types
        MethodInfo? current = methodsByParamCount.FirstOrDefault();
        int matchCount = 0;

        foreach (var info in methodsByParamCount)
        {
            var paramTypes = info.GetParameters()
                .Select(static p => p.ParameterType)
                .ToArray();

            // unsure which way IsAssignableFrom should be checked?
            int count = paramTypes
                .Select(static t => t.GetTypeInfo())
                .Where((t, i) => t.IsAssignableFrom(parameterTypes[i]))
                .Count();

            if (count <= matchCount)
                continue;

            current = info;
            matchCount = count;
        }

        return current;
    }

    private static MethodAccessor? CreateAccessor(MethodInfo methodInfo)
    {
        return methodInfo == null ? null : new MethodAccessor(methodInfo);
    }
    #endregion

    #region Find

    /// <summary>
    /// Searches for the public property or field with the specified name.
    /// </summary>
    /// <param name="name">The name of the property or field to find.</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property or field if found; otherwise, <c>null</c>.</returns>
    public IMemberAccessor? Find(string name)
    {
        return Find(name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
    }

    /// <summary>
    /// Searches for the specified property or field using the specified binding flags.
    /// </summary>
    /// <param name="name">The name of the property or field to find.</param>
    /// <param name="flags">A bitmask comprised of one or more <see cref="BindingFlags"/> that specify how the search is conducted.</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property or field if found; otherwise, <c>null</c>.</returns>
    public IMemberAccessor? Find(string name, BindingFlags flags)
    {
        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_memberCache.TryGetValue(name, out var cached))
            return cached;

        return _memberCache.GetOrAdd(name, n => CreateAccessor(n, flags));
    }

    private IMemberAccessor? CreateAccessor(string name, BindingFlags flags)
    {
        // first try property
        var property = FindProperty(Type, name, flags);
        if (property != null)
            return CreateAccessor(property);

        // next try field
        var field = FindField(Type, name, flags);
        if (field != null)
            return CreateAccessor(field);

        return null;
    }
    #endregion

    #region Column
    /// <summary>
    /// Searches for the public property with the specified column name.
    /// </summary>
    /// <param name="name">The name of the property or field to find.</param>
    /// <returns>An <see cref="IMemberAccessor"/> instance for the property or field if found; otherwise <c>null</c>.</returns>
    public IMemberAccessor? FindColumn(string name)
    {
        return FindColumn(name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
    }

    /// <summary>
    /// Searches for the property with the specified column name and binding flags, using <see cref="ColumnAttribute"/> if present.
    /// </summary>
    /// <param name="name">The name of the property or column to find.</param>
    /// <param name="flags">A bitmask comprised of one or more <see cref="BindingFlags"/> that specify how the search is conducted.</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property if found; otherwise, <c>null</c>.</returns>
    public IMemberAccessor? FindColumn(string name, BindingFlags flags)
    {
        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_memberCache.TryGetValue(name, out var cached))
            return cached;

        return _memberCache.GetOrAdd(name, n => CreateColumnAccessor(n, flags));
    }

    private IMemberAccessor? CreateColumnAccessor(string name, BindingFlags flags)
    {
        var typeInfo = Type.GetTypeInfo();

        foreach (var p in typeInfo.GetProperties(flags))
        {
            // try ColumnAttribute
            var columnAttribute = p.GetCustomAttribute<System.ComponentModel.DataAnnotations.Schema.ColumnAttribute>();
            if (columnAttribute != null && name.Equals(columnAttribute.Name, StringComparison.OrdinalIgnoreCase))
                return CreateAccessor(p);

            if (p.Name.Equals(name, StringComparison.OrdinalIgnoreCase))
                return CreateAccessor(p);
        }

        return null;
    }
    #endregion

    #region Property
    /// <summary>
    /// Searches for the property using a property expression.
    /// </summary>
    /// <typeparam name="T">The object type containing the property specified in the expression.</typeparam>
    /// <param name="propertyExpression">The property expression (e.g. <c>p =&gt; p.PropertyName</c>).</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property if found; otherwise, <c>null</c>.</returns>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name="propertyExpression"/> is <c>null</c>.</exception>
    /// <exception cref="ArgumentException">Thrown if the expression is not a valid property access expression.</exception>
    public IMemberAccessor? FindProperty<T>(Expression<Func<T>> propertyExpression)
    {
        if (propertyExpression == null)
            throw new ArgumentNullException(nameof(propertyExpression));

        if (propertyExpression.Body is UnaryExpression unaryExpression)
            return FindProperty(unaryExpression.Operand as MemberExpression);
        else
            return FindProperty(propertyExpression.Body as MemberExpression);
    }

    /// <summary>
    /// Searches for the property using a property expression.
    /// </summary>
    /// <typeparam name="TSource">The object type containing the property specified in the expression.</typeparam>
    /// <typeparam name="TValue">The type of the value.</typeparam>
    /// <param name="propertyExpression">The property expression (e.g. <c>p =&gt; p.PropertyName</c>).</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property if found; otherwise, <c>null</c>.</returns>
    /// <exception cref="ArgumentNullException">Thrown if <paramref name="propertyExpression"/> is <c>null</c>.</exception>
    /// <exception cref="ArgumentException">Thrown if the expression is not a valid property access expression.</exception>
    public IMemberAccessor? FindProperty<TSource, TValue>(Expression<Func<TSource, TValue>> propertyExpression)
    {
        if (propertyExpression == null)
            throw new ArgumentNullException(nameof(propertyExpression));

        if (propertyExpression.Body is UnaryExpression unaryExpression)
            return FindProperty(unaryExpression.Operand as MemberExpression);
        else
            return FindProperty(propertyExpression.Body as MemberExpression);
    }

    /// <summary>
    /// Searches for the public property with the specified name.
    /// </summary>
    /// <param name="name">The name of the property to find.</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property if found; otherwise, <c>null</c>.</returns>
    public IMemberAccessor? FindProperty(string name)
    {
        return FindProperty(name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
    }

    /// <summary>
    /// Searches for the property with the specified name and binding flags.
    /// </summary>
    /// <param name="name">The name of the property to find.</param>
    /// <param name="flags">A bitmask comprised of one or more <see cref="BindingFlags"/> that specify how the search is conducted.</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the property if found; otherwise, <c>null</c>.</returns>
    public IMemberAccessor? FindProperty(string name, BindingFlags flags)
    {
        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_memberCache.TryGetValue(name, out var cached))
            return cached;

        return _memberCache.GetOrAdd(name, n => CreatePropertyAccessor(n, flags));
    }

    /// <summary>
    /// Gets the property member accessors for the type.
    /// </summary>
    /// <returns>An <see cref="IEnumerable{IMemberAccessor}"/> for the type's properties.</returns>
    public IEnumerable<IMemberAccessor> GetProperties()
    {
        return GetProperties(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
    }

    /// <summary>
    /// Gets the property member accessors for the type using the specified binding flags.
    /// </summary>
    /// <param name="flags">A bitmask comprised of one or more <see cref="BindingFlags"/> that specify how the search is conducted.</param>
    /// <returns>An <see cref="IEnumerable{IMemberAccessor}"/> for the type's properties.</returns>
    public IEnumerable<IMemberAccessor> GetProperties(BindingFlags flags)
    {
        var key = (int)flags;

        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_propertyCache.TryGetValue(key, out var cached))
            return cached;

        return _propertyCache.GetOrAdd(key, k =>
        {
            var typeInfo = Type.GetTypeInfo();
            var properties = typeInfo.GetProperties(flags);
            return properties.Select(GetAccessor).ToArray();
        });
    }


    private IMemberAccessor GetAccessor(PropertyInfo propertyInfo)
    {
        if (propertyInfo == null)
            throw new ArgumentNullException(nameof(propertyInfo));

        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_memberCache.TryGetValue(propertyInfo.Name, out var cached) && cached != null)
            return cached;

        return _memberCache.GetOrAdd(propertyInfo.Name, n => CreateAccessor(propertyInfo))!;
    }

    private PropertyAccessor? CreatePropertyAccessor(string name, BindingFlags flags)
    {
        var info = FindProperty(Type, name, flags);
        return info == null ? null : CreateAccessor(info);
    }

    private IMemberAccessor? FindProperty(MemberExpression? memberExpression)
    {
        if (memberExpression == null)
            throw new ArgumentException("The expression is not a member access expression.", nameof(memberExpression));

        var property = memberExpression.Member as PropertyInfo;
        if (property == null)
            throw new ArgumentException("The member access expression does not access a property.", nameof(memberExpression));

        // find by name because we can't trust the PropertyInfo here as it could be from an interface or inherited class
        return FindProperty(property.Name);
    }

    private static PropertyInfo? FindProperty(Type type, string name, BindingFlags flags)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));

        if (name == null)
            throw new ArgumentNullException(nameof(name));

        var typeInfo = type.GetTypeInfo();
        // first try GetProperty
        var property = typeInfo.GetProperty(name, flags);
        if (property != null)
            return property;

        // if not found, search while ignoring case
        return typeInfo
            .GetProperties(flags)
            .FirstOrDefault(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
    }

    private static PropertyAccessor? CreateAccessor(PropertyInfo propertyInfo)
    {
        return propertyInfo == null ? null : new PropertyAccessor(propertyInfo);
    }
    #endregion

    #region Field
    /// <summary>
    /// Searches for the specified field with the specified name.
    /// </summary>
    /// <param name="name">The name of the field to find.</param>
    /// <returns>
    /// An <see cref="IMemberAccessor"/> instance for the field if found; otherwise <c>null</c>.
    /// </returns>
    public IMemberAccessor? FindField(string name)
    {
        return FindField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    }

    /// <summary>
    /// Searches for the field with the specified name and binding flags.
    /// </summary>
    /// <param name="name">The name of the field to find.</param>
    /// <param name="flags">A bitmask comprised of one or more <see cref="BindingFlags"/> that specify how the search is conducted.</param>
    /// <returns>An <see cref="IMemberAccessor"/> for the field if found; otherwise, <c>null</c>.</returns>
    public IMemberAccessor? FindField(string name, BindingFlags flags)
    {
        // fast-path: avoid closure allocation from GetOrAdd lambda on cache hits
        if (_memberCache.TryGetValue(name, out var cached))
            return cached;

        return _memberCache.GetOrAdd(name, n => CreateFieldAccessor(n, flags));
    }

    private FieldAccessor? CreateFieldAccessor(string name, BindingFlags flags)
    {
        var info = FindField(Type, name, flags);
        return info == null ? null : CreateAccessor(info);
    }

    private static FieldInfo? FindField(Type type, string name, BindingFlags flags)
    {
        if (type == null)
            throw new ArgumentNullException(nameof(type));

        if (name == null)
            throw new ArgumentNullException(nameof(name));

        // first try GetField
        var typeInfo = type.GetTypeInfo();
        var field = typeInfo.GetField(name, flags);
        if (field != null)
            return field;

        // if not found, search while ignoring case
        return typeInfo
            .GetFields(flags)
            .FirstOrDefault(f => f.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
    }

    private static FieldAccessor? CreateAccessor(FieldInfo fieldInfo)
    {
        return fieldInfo == null ? null : new FieldAccessor(fieldInfo);
    }
    #endregion


    /// <summary>
    /// Gets the <see cref="TypeAccessor"/> for the specified Type.
    /// </summary>
    /// <typeparam name="T">The Type to get the accessor for.</typeparam>
    /// <returns></returns>
    public static TypeAccessor GetAccessor<T>()
    {
        return GetAccessor(typeof(T));
    }

    /// <summary>
    /// Gets the <see cref="TypeAccessor"/> for the specified <see cref="Type"/>.
    /// </summary>
    /// <param name="type">The type to get the accessor for.</param>
    /// <returns>The <see cref="TypeAccessor"/> for the specified type.</returns>
    public static TypeAccessor GetAccessor(Type type)
    {
        // fast-path: avoid overhead of GetOrAdd on cache hits
        if (_typeCache.TryGetValue(type, out var cached))
            return cached;

        return _typeCache.GetOrAdd(type, static t => new TypeAccessor(t));
    }


    /// <summary>
    /// Registers a pre-generated <see cref="TypeAccessor"/> for the specified <see cref="Type"/>,
    /// allowing source-generated metadata to be used instead of runtime reflection.
    /// </summary>
    /// <param name="type">The type to register the accessor for.</param>
    /// <param name="accessor">The pre-generated accessor.</param>
    public static void Register(Type type, TypeAccessor accessor)
    {
        if (type == null) throw new ArgumentNullException(nameof(type));
        if (accessor == null) throw new ArgumentNullException(nameof(accessor));
        _typeCache[type] = accessor;
    }


    /// <summary>
    /// Pre-registers a member accessor by name so that subsequent lookups
    /// via <see cref="Find(string)"/>, <see cref="FindProperty(string)"/>, or <see cref="FindColumn(string)"/>
    /// return it without reflection.
    /// </summary>
    /// <param name="name">The lookup key (property name or column name).</param>
    /// <param name="accessor">The member accessor to register.</param>
    protected void RegisterMember(string name, IMemberAccessor accessor)
    {
        _memberCache.TryAdd(name, accessor);
    }

    /// <summary>
    /// Pre-registers a collection of property accessors for the specified binding flags,
    /// so that <see cref="GetProperties(BindingFlags)"/> returns them without reflection.
    /// </summary>
    /// <param name="flags">The binding flags key.</param>
    /// <param name="properties">The property accessors to register.</param>
    protected void RegisterProperties(BindingFlags flags, IEnumerable<IMemberAccessor> properties)
    {
        _propertyCache.TryAdd((int)flags, [.. properties]);
    }
}

loresoft / FluentCommand / 23278216331

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous