TBARPT.Library 1.0.4

Introduction

The purpose of this library is to enable Dynamic LINQ string construction and execution, as well as dynamically creating and executing queries using expression trees. This is intended to support specific applications local to our environment, though it may be useful to others. Helpers are also available for retrieving lists of properties, their types, and display names from a given type. Using ReflectionIgnore attribute will prevent a class from returing results, or individual properties from being included in the list of properties.

New in 1.0.4

Corrected issue where nullable property types were not providing the underlying type when calling GetProperties function.

Getting Started

1. Add this package and dependencies
2. Example usage:

using System.Reflection;
using TBARPT.Library;
using TBARPT.Library.Models;
using TBARPT.Repository.Repositories;

namespace TBARPT.Library.Example {
    public class Example {
        private readonly IReportRepository reportRepository;
        public Example(IReportRepository reportRepository) {
            this.reportRepository = reportRepository;
        }
        //when type is not known until runtime.
        public QueryResult GetReport(QueryRequest queryRequest, string typeName) {
            //use reflection to look up report source type
            //it is recommended to have a base query with the same method name as the class name which holds properties for the report
            Type type = Type.GetType("namespace.of.type." + typeName + ", assemblyName")
                ?? throw new ArgumentException($"Type could not be resolved: {typeName}");

            //use reflection to find queryable method
            //This should be wherever your base queries are stored
            var queryMethod = reportRepository.GetType().GetMethod(typeName, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static)
                ?? throw new ArgumentException($"Invalid Report Source: {typeName}");

            IQueryable<dynamic> baseQuery = (IQueryable<dynamic>?)queryMethod.Invoke(reportRepository, null)
                ?? throw new ArgumentException("Base query could not be resolved dynamically.");

            var reportBuilder = Activator.CreateInstance(typeof(DynamicLINQReportBuilder<>).MakeGenericType(type))
                ?? throw new MissingMethodException("Could not create instance of DynamicLINQReportBuilder");

            MethodInfo executeQuery = reportBuilder.GetType().GetMethod("GetReport")
                ?? throw new ArgumentException("GetReport method not found");

            QueryResult result = (QueryResult?)executeQuery.Invoke(reportBuilder, [baseQuery, queryRequest])
                ?? throw new Exception("Execution of query returned null.");

            return result;
        }

        //when type is known at compile time
        public static QueryResult GetReport<T>(QueryRequest queryRequest, IQueryable<T> baseQuery) {

            var reportBuilder = new DynamicLINQReportBuilder<T>();

            QueryResult result = reportBuilder.GetReport((IQueryable<dynamic>)baseQuery, queryRequest);

            return result;
        }
        //Utility to get list of properties from a type along with the display names (if set using DisplayName attribute) and types.
        //If type is not known at compile time, use reflection to get the type.
        public List<PropertyDetail> GetProperties(string className) {
            Type type = Type.GetType("namespace.of.type." + className + ", assemblyName")
                ?? throw new ArgumentException($"Report source could not be resolved: {className}");

            var helpers = Activator.CreateInstance(typeof(Helpers<>).MakeGenericType(type))
                ?? throw new MissingMethodException("Could not create instance of Helpers");

            MethodInfo getProperties = helpers.GetType().GetMethod("GetProperties")
                ?? throw new ArgumentException("GetProperties method not found");

            List<PropertyDetail> propertyDetails = (List<PropertyDetail>?)getProperties.Invoke(helpers, null) ?? [];

            return propertyDetails;
        }
        //if the type is known at compile time
        public List<PropertyDetail> GetProperties<T>(T someType) {
            var helpers = new Helpers<T>();
            List<PropertyDetail> propertyDetails = helpers.GetProperties();
            return propertyDetails;
        }
    }
}

AutoMapper Example usage:

//map individual object
DestinationType destination = AutoMapper.MapTo<DestinationType>(sourceObject);

//map individual object with property name mapping
Dictionary<string, string> propertyMap = new Dictionary<string, string> {
    { "DestinationPropertyName", "SourcePropertyName" }
};
DestinationType destination = AutoMapper.MapTo<DestinationType>(sourceObject, propertyMap);

//map list of objects
List<DestinationType> destinationList = AutoMapper.MapToList<DestinationType>(sourceObjects);

//map list of objects with property name mapping
Dictionary<string, string> propertyMap = new Dictionary<string, string> {
    { "DestinationPropertyName", "SourcePropertyName" }
};
List<DestinationType> destinationList = AutoMapper.MapToList<DestinationType>(sourceObjects, propertyMap);