TBARPT.Library 1.3.6

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.

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);

DynamicJoinEngine Example usage:

// Example usage demonstrating case-insensitive keys
public class Program
{
    public static void Main()
    {
        // Create objects with differently cased property names
        var departments = new List<object>
        {
            new { DepartmentId = 1, Name = "Engineering" },
            new { DepartmentId = 2, Name = "Marketing" },
            new { departmentId = 3, Name = "Finance" }  // Note lowercase 'd' in departmentId
        };
        
        // Create ExpandoObjects with differently cased property names
        var employees = new List<object>();
        
        dynamic emp1 = new ExpandoObject();
        emp1.EmployeeId = 101;
        emp1.departmentId = 1;  // Note lowercase 'd' in departmentId
        emp1.Name = "John Doe";
        employees.Add(emp1);
        
        dynamic emp2 = new ExpandoObject();
        emp2.employeeId = 102;  // Note lowercase 'e' in employeeId
        emp2.DEPARTMENTID = 1;  // Note uppercase 'DEPARTMENTID'
        emp2.Name = "Jane Smith";
        employees.Add(emp2);
        
        dynamic emp3 = new ExpandoObject();
        emp3.EmployeeId = 103;
        emp3.DepartmentId = 2;
        emp3.Name = "Bob Johnson";
        employees.Add(emp3);
        
        // Example with composite keys of differently cased property names
        var projects = new List<object>();
        
        dynamic proj1 = new ExpandoObject();
        proj1.ProjectID = "P1";  // Note uppercase 'ID'
        proj1.DepartmentId = 1;
        proj1.ProjectName = "Website Redesign";
        projects.Add(proj1);
        
        dynamic proj2 = new ExpandoObject();
        proj2.projectId = "P2";  // Note lowercase 'projectId'
        proj2.DEPARTMENTID = 1;  // Note uppercase 'DEPARTMENTID'
        proj2.ProjectName = "Mobile App";
        projects.Add(proj2);
        
        // Initialize the dynamic join engine with case-insensitive keys (default)
        var joinEngine = new DynamicJoinFramework.DynamicJoinEngine()
            .AddTable("employees", employees)
            .AddTable("departments", departments)
            .AddJoin("employees", "departments", "departmentId", "DepartmentId", 
                    DynamicJoinFramework.JoinType.Left);
        
        var results = joinEngine.Execute();
        
        Console.WriteLine("Case-insensitive join results:");
        foreach (var item in results)
        {
            Console.WriteLine("---");
            if (item is IDictionary<string, object> expandoItem)
            {
                foreach (var kvp in expandoItem)
                {
                    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
                }
            }
        }
        
        // Composite key join with case-insensitive keys
        var compositeJoinEngine = new DynamicJoinFramework.DynamicJoinEngine()
            .AddTable("employees", employees)
            .AddTable("projects", projects)
            .AddJoin("employees", "projects", "departmentId", "DEPARTMENTID", 
                    DynamicJoinFramework.JoinType.Inner);
        
        var compositeResults = compositeJoinEngine.Execute();
        
        Console.WriteLine("\nComposite key case-insensitive join results:");
        foreach (var item in compositeResults)
        {
            Console.WriteLine("---");
            if (item is IDictionary<string, object> expandoItem)
            {
                foreach (var kvp in expandoItem)
                {
                    Console.WriteLine($"{kvp.Key}: {kvp.Value}");
                }
            }
        }
        
        // Optional: Create a case-sensitive engine for comparison
        var caseSensitiveEngine = new DynamicJoinFramework.DynamicJoinEngine(caseInsensitiveKeys: false)
            .AddTable("employees", employees)
            .AddTable("departments", departments)
            .AddJoin("employees", "departments", "departmentId", "DepartmentId", 
                    DynamicJoinFramework.JoinType.Left);
        
        var sensitiveResults = caseSensitiveEngine.Execute();
        
        Console.WriteLine("\nCase-sensitive join results (for comparison):");
        Console.WriteLine($"Number of results: {sensitiveResults.Count()}"); // Should be fewer matches
    }
}