11990621989

Committed 23 Nov 2024 09:39PM UTC coverage: 81.332% (-0.7%) from 82.068%

Build # 11990621989

Build Type

push

github

Committed by

JaCraig

Commit Message

fix: Add discard operators and update method signatures

The changes primarily involve adding discard operators (`_ =`) to the results of method calls that return values which are not used. This is done to explicitly indicate that the return values are intentionally ignored. Additionally, the `Aspects` property initialization has been changed from `new ConcurrentBag<IAspect>()` to an empty array `[]`, and the `GetAssembliesSimple` method's parameter `type` has been made nullable (`Type?`). Other changes include modifying method calls to include null checks and using the null-forgiving operator (`!`) where necessary.

Run Details

222 of 316 branches covered (70.25%)

Branch coverage included in aggregate %.

35 of 37 new or added lines in 1 file covered. (94.59%)

4 existing lines in 1 file now uncovered.

401 of 450 relevant lines covered (89.11%)

2329058.6 hits per line

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

88.35

/Aspectus/Aspectus.cs

﻿/*
Copyright 2016 James Craig

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

using Aspectus.CodeGen;
using Aspectus.HelperFunctions;
using Aspectus.Interfaces;
using Fast.Activator;
using Microsoft.CodeAnalysis;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.ObjectPool;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Aspectus
{
    /// <summary>
    /// AOP interface manager
    /// </summary>
    public class Aspectus
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Aspectus"/> class.
        /// </summary>
        /// <param name="compiler">The compiler.</param>
        /// <param name="aspects">The aspects.</param>
        /// <param name="modules">The modules.</param>
        /// <param name="logger">Serilog based log object</param>
        /// <param name="objectPool">The object pool.</param>
        /// <exception cref="ArgumentNullException">logger</exception>
        public Aspectus(Compiler compiler, IEnumerable<IAspect> aspects, IEnumerable<IAOPModule> modules, ILogger<Aspectus>? logger, ObjectPool<StringBuilder>? objectPool)
        {
            Logger = logger;
            aspects ??= Array.Empty<IAspect>();
            modules ??= Array.Empty<IAOPModule>();
            Compiler = compiler ?? new Compiler(objectPool);
            if (Aspects.IsEmpty)
                _ = Aspects.Add(aspects);
            _ = modules.ForEach(x => x.Setup(this));
            ObjectPool = objectPool;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Aspectus"/> class.
        /// </summary>
        /// <param name="compiler">The compiler.</param>
        /// <param name="aspects">The aspects.</param>
        /// <param name="modules">The modules.</param>
        public Aspectus(Compiler compiler, IEnumerable<IAspect> aspects, IEnumerable<IAOPModule> modules)
            : this(compiler, aspects, modules, null, null)
        {
        }

        /// <summary>
        /// The list of aspects that are being used
        /// </summary>
        private ConcurrentBag<IAspect> Aspects { get; } = [];

        /// <summary>
        /// Gets the system's compiler
        /// </summary>
        private Compiler? Compiler { get; set; }

        /// <summary>
        /// Logging object
        /// </summary>
        private ILogger? Logger { get; }

        /// <summary>
        /// Gets the object pool.
        /// </summary>
        /// <value>The object pool.</value>
        private ObjectPool<StringBuilder>? ObjectPool { get; }

        /// <summary>
        /// Dictionary containing generated types and associates it with original type
        /// </summary>
        private readonly ConcurrentDictionary<Type, Type> _Classes = new();

        /// <summary>
        /// Creates an object of the specified base type, registering the type if necessary
        /// </summary>
        /// <typeparam name="T">The base type</typeparam>
        /// <returns>Returns an object of the specified base type</returns>
        public T Create<T>() => (T)Create(typeof(T))!;

        /// <summary>
        /// Creates an object of the specified base type, registering the type if necessary
        /// </summary>
        /// <param name="baseType">The base type</param>
        /// <returns>Returns an object of the specified base type</returns>
        public object? Create(Type baseType)
        {
            if (baseType is null)
                return null;
            if (!_Classes.ContainsKey(baseType))
                Setup(baseType);
            if (!_Classes.ContainsKey(baseType) || _Classes[baseType] is null)
                return GetInstance(baseType);
            var ReturnObject = GetInstance(_Classes[baseType]);
            if (ReturnObject is null)
                return ReturnObject;
            if (_Classes[baseType] != baseType)
            {
                foreach (IAspect Aspect in Aspects)
                {
                    Aspect.Setup(ReturnObject);
                }
            }
            return ReturnObject;
        }

        /// <summary>
        /// Cleans up items in this instance.
        /// </summary>
        public void FinalizeSetup()
        {
            Compiler?.Dispose();
            Compiler = null;
        }

        /// <summary>
        /// Sets up all types from the assembly that it can
        /// </summary>
        /// <param name="assemblies">Assembly to set up</param>
        public void Setup(params Assembly[] assemblies)
        {
            if (assemblies is null || assemblies.Length == 0)
                return;
            Setup(FilterTypesToSetup(assemblies.SelectMany(x => x.ExportedTypes)));
        }

        /// <summary>
        /// Sets up a type so it can be used in the system later
        /// </summary>
        /// <param name="types">The types.</param>
        public void Setup(params Type[] types)
        {
            if (Compiler is null)
                return;
            IEnumerable<Type> TempTypes = FilterTypesToSetup(types);
            if (!TempTypes.Any())
            {
                for (var x = 0; x < types.Length; ++x)
                {
                    _ = _Classes.AddOrUpdate(types[x], types[x], (y, _) => y);
                }
                return;
            }
            var TempAssemblies = new List<Assembly>();
            GetAssemblies(typeof(object), TempAssemblies);
            GetAssemblies(typeof(Enumerable), TempAssemblies);

            var Usings = new List<string>
            {
                "System",
                "System.Collections.Generic",
                "System.Linq",
                "System.Text",
                "System.Threading.Tasks"
            };
            _ = Aspects.ForEach(x => Usings.AddIfUnique(x.Usings));

            var InterfacesUsed = new List<Type>();
            _ = Aspects.ForEach(x => InterfacesUsed.AddRange(x.InterfacesUsing ?? Array.Empty<Type>()));

            StringBuilder Builder = ObjectPool?.Get() ?? new StringBuilder();

            foreach (Type TempType in TempTypes)
            {
                Logger?.LogDebug("Generating type for {0}", TempType.GetName(ObjectPool));
                GetAssemblies(TempType, TempAssemblies);

                var Namespace = "AspectusGeneratedTypes.C" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
                var ClassName = TempType.Name + "Derived";
                _ = Builder.AppendLine(Setup(TempType, Namespace, ClassName, Usings, InterfacesUsed, TempAssemblies));
            }
            try
            {
                List<MetadataReference> MetadataReferences = GetFinalAssemblies(TempAssemblies);
                _ = Aspects.ForEach(x => MetadataReferences.AddIfUnique((z, y) => z.Display == y.Display, x.AssembliesUsing.ToArray()));
                IEnumerable<Type> Types = Compiler.Create(Builder.ToString(), Usings, MetadataReferences.ToArray())
                                                    .Compile()
                                                    .LoadAssembly();
                foreach (Type TempType in TempTypes)
                {
                    Type? Value = Types.FirstOrDefault(x => x.BaseType == TempType);
                    if (Value is null)
                        continue;
                    _ = _Classes.AddOrUpdate(TempType, Value, (x, _) => x);
                }
            }
            catch (Exception Ex)
            {
                Logger?.LogError(Ex, "Error compiling code");
                foreach (Type TempType in TempTypes)
                {
                    _ = _Classes.AddOrUpdate(TempType,
                        TempType,
                        (x, _) => x);
                }
            }
            ObjectPool?.Return(Builder);
        }

        /// <summary>
        /// Outputs manager info as a string
        /// </summary>
        /// <returns>String version of the manager</returns>
        public override string ToString() => "AOP registered classes: " + _Classes.Keys.ToString(x => x.Name) + "\r\n";

        /// <summary>
        /// Gets the assemblies.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="assembliesUsing">The assemblies using.</param>
        private static void GetAssemblies(Type type, List<Assembly> assembliesUsing)
        {
            Type? TempType = type;
            while (TempType != null)
            {
                _ = assembliesUsing.AddIfUnique(TempType.Assembly);
                _ = TempType.GetInterfaces().ForEach(x => GetAssembliesSimple(x, assembliesUsing));
                _ = TempType.GetEvents().ForEach(x => GetAssembliesSimple(x.EventHandlerType, assembliesUsing));
                _ = TempType.GetFields().ForEach(x => GetAssembliesSimple(x.FieldType, assembliesUsing));
                _ = TempType.GetProperties().ForEach(x => GetAssembliesSimple(x.PropertyType, assembliesUsing));
                _ = TempType.GetMethods().ForEach(x =>
                {
                    GetAssembliesSimple(x.ReturnType, assembliesUsing);
                    _ = x.GetParameters().ForEach(y => GetAssembliesSimple(y.ParameterType, assembliesUsing));
                });
                TempType = TempType.BaseType;
                if (TempType == typeof(object))
                    break;
            }
        }

        /// <summary>
        /// Gets the assemblies simple.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="assembliesUsing">The assemblies using.</param>
        private static void GetAssembliesSimple(Type? type, List<Assembly> assembliesUsing)
        {
            Type? TempType = type;
            while (TempType != null)
            {
                _ = assembliesUsing.AddIfUnique((z, y) => z.Location == y.Location, TempType.Assembly);
                _ = TempType.GetInterfaces().ForEach(x => GetAssembliesSimple(x, assembliesUsing));
                TempType = TempType.BaseType;
                if (TempType == typeof(object))
                    break;
            }
        }

        /// <summary>
        /// Gets the final assemblies.
        /// </summary>
        /// <param name="assembliesUsing">The assemblies using.</param>
        /// <returns>The final assemblies</returns>
        private static List<MetadataReference> GetFinalAssemblies(List<Assembly> assembliesUsing)
        {
            _ = assembliesUsing.AddIfUnique((z, y) => z.Location == y.Location, assembliesUsing
                                                    .SelectMany(x => x.GetReferencedAssemblies())
                                                    .Select(Assembly.Load).ToArray());
            string[] Load = [
                "mscorlib.dll",
                "netstandard.dll"
            ];
            var ReturnList = assembliesUsing.ForEach(x => (MetadataReference)MetadataReference.CreateFromFile(x.Location))
                                  .ToList();
            foreach (var Directory in assembliesUsing.Select(x => new FileInfo(x.Location).DirectoryName).Distinct())
            {
                foreach (FileInfo? DLL in new DirectoryInfo(Directory!)
                                            .EnumerateFiles("*.dll")
                                            .Where(x => Load.Contains(x.Name)))
                {
                    PortableExecutableReference TempAssembly = MetadataReference.CreateFromFile(DLL.FullName);
                    _ = ReturnList.AddIfUnique((z, y) => z.Display == y.Display, TempAssembly);
                }
            }
            return ReturnList;
        }

        /// <summary>
        /// Gets an instance of the object.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns>The object.</returns>
        private static object? GetInstance(Type type) => FastActivator.CreateInstance(type);

        /// <summary>
        /// Determines whether this instance can setup the specified types.
        /// </summary>
        /// <param name="enumerable">The list of types</param>
        /// <returns>The types that can be set up</returns>
        private Type[] FilterTypesToSetup(IEnumerable<Type> enumerable)
        {
            enumerable ??= Array.Empty<Type>();
            return enumerable.Where(x =>
            {
                Type TempTypeInfo = x;
                return !_Classes.ContainsKey(x)
                        && !TempTypeInfo.ContainsGenericParameters
                        && TempTypeInfo.IsClass
                        && (TempTypeInfo.IsPublic || TempTypeInfo.IsNestedPublic)
                        && !TempTypeInfo.IsSealed
                        && TempTypeInfo.IsVisible
                        && x.HasDefaultConstructor()
                        && !string.IsNullOrEmpty(x.Namespace);
            })
            .ToArray();
        }

        /// <summary>
        /// Setups the specified type.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="namespaceUsing">The namespace.</param>
        /// <param name="className">Name of the class.</param>
        /// <param name="usings">The usings.</param>
        /// <param name="interfaces">The interfaces.</param>
        /// <param name="assembliesUsing">The assemblies using.</param>
        /// <returns></returns>
        private string Setup(Type type,
            string namespaceUsing,
            string className,
            List<string> usings,
            List<Type> interfaces,
            List<Assembly> assembliesUsing)
        {
            StringBuilder Builder = ObjectPool?.Get() ?? new StringBuilder();
            _ = Builder.AppendLineFormat(@"namespace {1}
{{
    {0}

    public class {2} : {3}{4} {5}
    {{
", usings.ToString(x => "using " + x + ";", "\r\n"),
 namespaceUsing,
 className,
 type.FullName.Replace("+", ".", StringComparison.Ordinal),
 interfaces.Count > 0 ? "," : string.Empty, interfaces.ToString(x => x.FullName.Replace("+", ".", StringComparison.Ordinal)));
            if (type.HasDefaultConstructor())
            {
                _ = Builder.AppendLineFormat(@"
        public {0}()
            :base()
        {{
            ",
               type.Name + "Derived");
                _ = Aspects.ForEach(x => Builder.AppendLine(x.SetupDefaultConstructor(type)));
                _ = Builder.AppendLineFormat(@"
        }}");
            }

            _ = Aspects.ForEach(x => Builder.AppendLine(x.SetupInterfaces(type)));

            Type? TempType = type;
            var MethodsAlreadyDone = new List<string>();
            while (TempType != null)
            {
                for (int i = 0, MaxLength = TempType.GetProperties().Length; i < MaxLength; i++)
                {
                    PropertyInfo Property = TempType.GetProperties()[i];
                    MethodInfo? GetMethodInfo = Property.GetMethod;
                    MethodInfo? SetMethodInfo = Property.SetMethod;
                    if (!MethodsAlreadyDone.Contains("get_" + Property.Name)
                        && !MethodsAlreadyDone.Contains("set_" + Property.Name)
                        && GetMethodInfo?.IsVirtual == true
                        && SetMethodInfo?.IsPublic == true
                        && !GetMethodInfo.IsFinal
                        && Property.GetIndexParameters().Length == 0)
                    {
                        GetAssemblies(Property.PropertyType, assembliesUsing);
                        _ = Builder.AppendLineFormat(@"
        public override {0} {1}
        {{
            get
            {{
                {2}
            }}
            set
            {{
                {3}
            }}
        }}",
                                                    Property.PropertyType.GetName(ObjectPool),
                                                    Property.Name,
                                                    SetupMethod(type, GetMethodInfo, true),
                                                    SetupMethod(type, SetMethodInfo, true));
                        MethodsAlreadyDone.Add(GetMethodInfo.Name);
                        MethodsAlreadyDone.Add(SetMethodInfo.Name);
                    }
                    else if (!MethodsAlreadyDone.Contains("get_" + Property.Name)
                        && GetMethodInfo?.IsVirtual == true
                        && SetMethodInfo is null
                        && !GetMethodInfo.IsFinal
                        && Property.GetIndexParameters().Length == 0)
                    {
                        GetAssemblies(Property.PropertyType, assembliesUsing);
                        _ = Builder.AppendLineFormat(@"
        public override {0} {1}
        {{
            get
            {{
                {2}
            }}
        }}",
                                                    Property.PropertyType.GetName(ObjectPool),
                                                    Property.Name,
                                                    SetupMethod(type, GetMethodInfo, true));
                        MethodsAlreadyDone.Add(GetMethodInfo.Name);
                    }
                    else
                    {
                        if (GetMethodInfo != null)
                            MethodsAlreadyDone.Add(GetMethodInfo.Name);
                        if (SetMethodInfo != null)
                            MethodsAlreadyDone.Add(SetMethodInfo.Name);
                    }
                }

                for (int i = 0, MaxLength = TempType.GetMethods().Length; i < MaxLength; i++)
                {
                    MethodInfo Method = TempType.GetMethods()[i];
                    const string MethodAttribute = "public";
                    if (!MethodsAlreadyDone.Contains(Method.Name)
                        && Method.IsVirtual
                        && !Method.IsFinal
                        && !Method.IsPrivate
                        && !Method.Name.StartsWith("add_", StringComparison.OrdinalIgnoreCase)
                        && !Method.Name.StartsWith("remove_", StringComparison.OrdinalIgnoreCase)
                        && !Method.IsGenericMethod)
                    {
                        GetAssemblies(Method.ReturnType, assembliesUsing);
                        _ = Method.GetParameters().ForEach(x => GetAssemblies(x.ParameterType, assembliesUsing));
                        var Static = Method.IsStatic ? "static " : string.Empty;
                        _ = Builder.AppendLineFormat(@"
        {4} override {0} {1}({2})
        {{
            {3}
        }}",
                                                    Static + Method.ReturnType.GetName(ObjectPool),
                                                    Method.Name,
                                                    Method.GetParameters().ToString(x => (x.IsOut ? "out " : string.Empty) + x.ParameterType.GetName(ObjectPool) + " " + x.Name),
                                                    SetupMethod(type, Method, false),
                                                    MethodAttribute);
                        MethodsAlreadyDone.Add(Method.Name);
                    }
                }

                TempType = TempType.BaseType;
                if (TempType == typeof(object))
                    break;
            }
            _ = Builder.AppendLine(@"   }
}");
            var ReturnValue = Builder.ToString();
            ObjectPool?.Return(Builder);
            return ReturnValue;
        }

        private string SetupMethod(Type type, MethodInfo methodInfo, bool isProperty)
        {
            if (methodInfo is null)
                return string.Empty;
            StringBuilder Builder = ObjectPool?.Get() ?? new StringBuilder();
            var BaseMethodName = methodInfo.Name.Replace("get_", string.Empty, StringComparison.Ordinal).Replace("set_", string.Empty, StringComparison.Ordinal);
            var ReturnValue = methodInfo.ReturnType != typeof(void) ? "FinalReturnValue" : string.Empty;
            var BaseCall = string.Empty;
            BaseCall = isProperty
                ? string.IsNullOrEmpty(ReturnValue) ? "base." + BaseMethodName : ReturnValue + "=base." + BaseMethodName
                : string.IsNullOrEmpty(ReturnValue) ? "base." + BaseMethodName + "(" : ReturnValue + "=base." + BaseMethodName + "(";
            ParameterInfo[] Parameters = methodInfo.GetParameters();
            if (isProperty)
            {
                BaseCall += Parameters.Length > 0 ? "=" + Parameters.ToString(x => x.Name) + ";" : ";";
            }
            else
            {
                BaseCall += Parameters.Length > 0 ? Parameters.ToString(x => (x.IsOut ? "out " : string.Empty) + x.Name) : string.Empty;
                BaseCall += ");\r\n";
            }
            _ = Builder.AppendLineFormat(@"
                try
                {{
                    {0}
                    {1}
                    {2}
                    {3}
                    {4}
                }}
                catch(Exception CaughtException)
                {{
                    {5}
                    throw;
                }}",
                methodInfo.ReturnType != typeof(void) ? methodInfo.ReturnType.GetName(ObjectPool) + " " + ReturnValue + ";" : string.Empty,
                Aspects.ForEach(x => x.SetupStartMethod(methodInfo, type)).ToString(x => x, "\r\n"),
                BaseCall,
                Aspects.ForEach(x => x.SetupEndMethod(methodInfo, type, ReturnValue)).ToString(x => x, "\r\n"),
                string.IsNullOrEmpty(ReturnValue) ? string.Empty : "return " + ReturnValue + ";",
                Aspects.ForEach(x => x.SetupExceptionMethod(methodInfo, type)).ToString(x => x, "\r\n"));
            var ReturnVal = Builder.ToString();
            ObjectPool?.Return(Builder);
            return ReturnVal;
        }
    }
}

1	/*
2	Copyright 2016 James Craig
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	using Aspectus.CodeGen;
18	using Aspectus.HelperFunctions;
19	using Aspectus.Interfaces;
20	using Fast.Activator;
21	using Microsoft.CodeAnalysis;
22	using Microsoft.Extensions.Logging;
23	using Microsoft.Extensions.ObjectPool;
24	using System;
25	using System.Collections.Concurrent;
26	using System.Collections.Generic;
27	using System.Globalization;
28	using System.IO;
29	using System.Linq;
30	using System.Reflection;
31	using System.Text;
32
33	namespace Aspectus
34	{
35	/// <summary>
36	/// AOP interface manager
37	/// </summary>
38	public class Aspectus
39	{
40	/// <summary>
41	/// Initializes a new instance of the <see cref="Aspectus"/> class.
42	/// </summary>
43	/// <param name="compiler">The compiler.</param>
44	/// <param name="aspects">The aspects.</param>
45	/// <param name="modules">The modules.</param>
46	/// <param name="logger">Serilog based log object</param>
47	/// <param name="objectPool">The object pool.</param>
48	/// <exception cref="ArgumentNullException">logger</exception>
49	public Aspectus(Compiler compiler, IEnumerable<IAspect> aspects, IEnumerable<IAOPModule> modules, ILogger<Aspectus>? logger, ObjectPool<StringBuilder>? objectPool)	22✔
50	{
51	Logger = logger;	22✔
52	aspects ??= Array.Empty<IAspect>();	22!
53	modules ??= Array.Empty<IAOPModule>();	22!
54	Compiler = compiler ?? new Compiler(objectPool);	22!
55	if (Aspects.IsEmpty)	22✔
56	_ = Aspects.Add(aspects);	22✔
57	_ = modules.ForEach(x => x.Setup(this));	67✔
58	ObjectPool = objectPool;	22✔
59	}	22✔
60
61	/// <summary>
62	/// Initializes a new instance of the <see cref="Aspectus"/> class.
63	/// </summary>
64	/// <param name="compiler">The compiler.</param>
65	/// <param name="aspects">The aspects.</param>
66	/// <param name="modules">The modules.</param>
67	public Aspectus(Compiler compiler, IEnumerable<IAspect> aspects, IEnumerable<IAOPModule> modules)
68	: this(compiler, aspects, modules, null, null)	1✔
69	{
70	}	1✔
71
72	/// <summary>
73	/// The list of aspects that are being used
74	/// </summary>
75	private ConcurrentBag<IAspect> Aspects { get; } = [];	691✔
76
77	/// <summary>
78	/// Gets the system's compiler
79	/// </summary>
80	private Compiler? Compiler { get; set; }	49✔
81
82	/// <summary>
83	/// Logging object
84	/// </summary>
85	private ILogger? Logger { get; }	26✔
86
87	/// <summary>
88	/// Gets the object pool.
89	/// </summary>
90	/// <value>The object pool.</value>
91	private ObjectPool<StringBuilder>? ObjectPool { get; }	714✔
92
93	/// <summary>
94	/// Dictionary containing generated types and associates it with original type
95	/// </summary>
96	private readonly ConcurrentDictionary<Type, Type> _Classes = new();	22✔
97
98	/// <summary>
99	/// Creates an object of the specified base type, registering the type if necessary
100	/// </summary>
101	/// <typeparam name="T">The base type</typeparam>
102	/// <returns>Returns an object of the specified base type</returns>
103	public T Create<T>() => (T)Create(typeof(T))!;	1✔
104
105	/// <summary>
106	/// Creates an object of the specified base type, registering the type if necessary
107	/// </summary>
108	/// <param name="baseType">The base type</param>
109	/// <returns>Returns an object of the specified base type</returns>
110	public object? Create(Type baseType)
111	{
112	if (baseType is null)	12!
113	return null;	×
114	if (!_Classes.ContainsKey(baseType))	12✔
115	Setup(baseType);	5✔
116	if (!_Classes.ContainsKey(baseType) \|\| _Classes[baseType] is null)	12✔
117	return GetInstance(baseType);	2✔
118	var ReturnObject = GetInstance(_Classes[baseType]);	10✔
119	if (ReturnObject is null)	10!
120	return ReturnObject;	×
121	if (_Classes[baseType] != baseType)	10✔
122	{
123	foreach (IAspect Aspect in Aspects)	28✔
124	{
125	Aspect.Setup(ReturnObject);	7✔
126	}
127	}
128	return ReturnObject;	10✔
129	}
130
131	/// <summary>
132	/// Cleans up items in this instance.
133	/// </summary>
134	public void FinalizeSetup()
135	{
136	Compiler?.Dispose();	3!
137	Compiler = null;	3✔
138	}	3✔
139
140	/// <summary>
141	/// Sets up all types from the assembly that it can
142	/// </summary>
143	/// <param name="assemblies">Assembly to set up</param>
144	public void Setup(params Assembly[] assemblies)
145	{
146	if (assemblies is null \|\| assemblies.Length == 0)	1!
147	return;	×
148	Setup(FilterTypesToSetup(assemblies.SelectMany(x => x.ExportedTypes)));	2✔
149	}	1✔
150
151	/// <summary>
152	/// Sets up a type so it can be used in the system later
153	/// </summary>
154	/// <param name="types">The types.</param>
155	public void Setup(params Type[] types)
156	{
157	if (Compiler is null)	12✔
158	return;	3✔
159	IEnumerable<Type> TempTypes = FilterTypesToSetup(types);	9✔
160	if (!TempTypes.Any())	9!
161	{
162	for (var x = 0; x < types.Length; ++x)	×
163	{
NEW 164	_ = _Classes.AddOrUpdate(types[x], types[x], (y, _) => y);	×
165	}
166	return;	×
167	}
168	var TempAssemblies = new List<Assembly>();	9✔
169	GetAssemblies(typeof(object), TempAssemblies);	9✔
170	GetAssemblies(typeof(Enumerable), TempAssemblies);	9✔
171
172	var Usings = new List<string>	9✔
173	{	9✔
174	"System",	9✔
175	"System.Collections.Generic",	9✔
176	"System.Linq",	9✔
177	"System.Text",	9✔
178	"System.Threading.Tasks"	9✔
179	};	9✔
180	_ = Aspects.ForEach(x => Usings.AddIfUnique(x.Usings));	22✔
181
182	var InterfacesUsed = new List<Type>();	9✔
183	_ = Aspects.ForEach(x => InterfacesUsed.AddRange(x.InterfacesUsing ?? Array.Empty<Type>()));	22!
184
185	StringBuilder Builder = ObjectPool?.Get() ?? new StringBuilder();	9!
186
187	foreach (Type TempType in TempTypes)	60✔
188	{
189	Logger?.LogDebug("Generating type for {0}", TempType.GetName(ObjectPool));	21!
190	GetAssemblies(TempType, TempAssemblies);	21✔
191
192	var Namespace = "AspectusGeneratedTypes.C" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);	21✔
193	var ClassName = TempType.Name + "Derived";	21✔
194	_ = Builder.AppendLine(Setup(TempType, Namespace, ClassName, Usings, InterfacesUsed, TempAssemblies));	21✔
195	}
196	try
197	{
198	List<MetadataReference> MetadataReferences = GetFinalAssemblies(TempAssemblies);	9✔
199	_ = Aspects.ForEach(x => MetadataReferences.AddIfUnique((z, y) => z.Display == y.Display, x.AssembliesUsing.ToArray()));	418✔
200	IEnumerable<Type> Types = Compiler.Create(Builder.ToString(), Usings, MetadataReferences.ToArray())	9✔
201	.Compile()	9✔
202	.LoadAssembly();	9✔
203	foreach (Type TempType in TempTypes)	24✔
204	{
205	Type? Value = Types.FirstOrDefault(x => x.BaseType == TempType);	20✔
206	if (Value is null)	8✔
207	continue;
208	_ = _Classes.AddOrUpdate(TempType, Value, (x, _) => x);	8✔
209	}
210	}	4✔
211	catch (Exception Ex)	5✔
212	{
213	Logger?.LogError(Ex, "Error compiling code");	5!
214	foreach (Type TempType in TempTypes)	36✔
215	{
216	_ = _Classes.AddOrUpdate(TempType,	13✔
217	TempType,	13✔
218	(x, _) => x);	13✔
219	}
220	}	5✔
221	ObjectPool?.Return(Builder);	9!
222	}	9✔
223
224	/// <summary>
225	/// Outputs manager info as a string
226	/// </summary>
227	/// <returns>String version of the manager</returns>
228	public override string ToString() => "AOP registered classes: " + _Classes.Keys.ToString(x => x.Name) + "\r\n";	1✔
229
230	/// <summary>
231	/// Gets the assemblies.
232	/// </summary>
233	/// <param name="type">The type.</param>
234	/// <param name="assembliesUsing">The assemblies using.</param>
235	private static void GetAssemblies(Type type, List<Assembly> assembliesUsing)
236	{
237	Type? TempType = type;	183✔
238	while (TempType != null)	287✔
239	{
240	_ = assembliesUsing.AddIfUnique(TempType.Assembly);	257✔
241	_ = TempType.GetInterfaces().ForEach(x => GetAssembliesSimple(x, assembliesUsing));	2,586✔
242	_ = TempType.GetEvents().ForEach(x => GetAssembliesSimple(x.EventHandlerType, assembliesUsing));	257✔
243	_ = TempType.GetFields().ForEach(x => GetAssembliesSimple(x.FieldType, assembliesUsing));	557✔
244	_ = TempType.GetProperties().ForEach(x => GetAssembliesSimple(x.PropertyType, assembliesUsing));	444✔
245	_ = TempType.GetMethods().ForEach(x =>	257✔
246	{	257✔
247	GetAssembliesSimple(x.ReturnType, assembliesUsing);	13,550✔
248	_ = x.GetParameters().ForEach(y => GetAssembliesSimple(y.ParameterType, assembliesUsing));	37,063✔
249	});	13,807✔
250	TempType = TempType.BaseType;	257✔
251	if (TempType == typeof(object))	257✔
252	break;
253	}
254	}	183✔
255
256	/// <summary>
257	/// Gets the assemblies simple.
258	/// </summary>
259	/// <param name="type">The type.</param>
260	/// <param name="assembliesUsing">The assemblies using.</param>
261	private static void GetAssembliesSimple(Type? type, List<Assembly> assembliesUsing)
262	{
263	Type? TempType = type;	30,802,071✔
264	while (TempType != null)	61,598,232✔
265	{
266	_ = assembliesUsing.AddIfUnique((z, y) => z.Location == y.Location, TempType.Assembly);	61,654,953✔
267	_ = TempType.GetInterfaces().ForEach(x => GetAssembliesSimple(x, assembliesUsing));	61,589,326✔
268	TempType = TempType.BaseType;	30,827,134✔
269	if (TempType == typeof(object))	30,827,134✔
270	break;
271	}
272	}	30,802,071✔
273
274	/// <summary>
275	/// Gets the final assemblies.
276	/// </summary>
277	/// <param name="assembliesUsing">The assemblies using.</param>
278	/// <returns>The final assemblies</returns>
279	private static List<MetadataReference> GetFinalAssemblies(List<Assembly> assembliesUsing)
280	{
281	_ = assembliesUsing.AddIfUnique((z, y) => z.Location == y.Location, assembliesUsing	3,862✔
282	.SelectMany(x => x.GetReferencedAssemblies())	32✔
283	.Select(Assembly.Load).ToArray());	9✔
284	string[] Load = [	9✔
285	"mscorlib.dll",	9✔
286	"netstandard.dll"	9✔
287	];	9✔
288	var ReturnList = assembliesUsing.ForEach(x => (MetadataReference)MetadataReference.CreateFromFile(x.Location))	254✔
289	.ToList();	9✔
290	foreach (var Directory in assembliesUsing.Select(x => new FileInfo(x.Location).DirectoryName).Distinct())	299✔
291	{
292	foreach (FileInfo? DLL in new DirectoryInfo(Directory!)	72✔
293	.EnumerateFiles("*.dll")	18✔
294	.Where(x => Load.Contains(x.Name)))	1,863✔
295	{
296	PortableExecutableReference TempAssembly = MetadataReference.CreateFromFile(DLL.FullName);	18✔
297	_ = ReturnList.AddIfUnique((z, y) => z.Display == y.Display, TempAssembly);	509✔
298	}
299	}
300	return ReturnList;	9✔
301	}
302
303	/// <summary>
304	/// Gets an instance of the object.
305	/// </summary>
306	/// <param name="type">The type.</param>
307	/// <returns>The object.</returns>
308	private static object? GetInstance(Type type) => FastActivator.CreateInstance(type);	12✔
309
310	/// <summary>
311	/// Determines whether this instance can setup the specified types.
312	/// </summary>
313	/// <param name="enumerable">The list of types</param>
314	/// <returns>The types that can be set up</returns>
315	private Type[] FilterTypesToSetup(IEnumerable<Type> enumerable)
316	{
317	enumerable ??= Array.Empty<Type>();	10!
318	return enumerable.Where(x =>	10✔
319	{	10✔
320	Type TempTypeInfo = x;	31✔
321	return !_Classes.ContainsKey(x)	31✔
322	&& !TempTypeInfo.ContainsGenericParameters	31✔
323	&& TempTypeInfo.IsClass	31✔
324	&& (TempTypeInfo.IsPublic \|\| TempTypeInfo.IsNestedPublic)	31✔
325	&& !TempTypeInfo.IsSealed	31✔
326	&& TempTypeInfo.IsVisible	31✔
327	&& x.HasDefaultConstructor()	31✔
328	&& !string.IsNullOrEmpty(x.Namespace);	31✔
329	})	10✔
330	.ToArray();	10✔
331	}
332
333	/// <summary>
334	/// Setups the specified type.
335	/// </summary>
336	/// <param name="type">The type.</param>
337	/// <param name="namespaceUsing">The namespace.</param>
338	/// <param name="className">Name of the class.</param>
339	/// <param name="usings">The usings.</param>
340	/// <param name="interfaces">The interfaces.</param>
341	/// <param name="assembliesUsing">The assemblies using.</param>
342	/// <returns></returns>
343	private string Setup(Type type,
344	string namespaceUsing,
345	string className,
346	List<string> usings,
347	List<Type> interfaces,
348	List<Assembly> assembliesUsing)
349	{
350	StringBuilder Builder = ObjectPool?.Get() ?? new StringBuilder();	21!
351	_ = Builder.AppendLineFormat(@"namespace {1}	21✔
352	{{	21✔
353	{0}	21✔
354		21✔
355	public class {2} : {3}{4} {5}	21✔
356	{{	21✔
357	", usings.ToString(x => "using " + x + ";", "\r\n"),	105✔
358	namespaceUsing,	21✔
359	className,	21✔
360	type.FullName.Replace("+", ".", StringComparison.Ordinal),	21✔
361	interfaces.Count > 0 ? "," : string.Empty, interfaces.ToString(x => x.FullName.Replace("+", ".", StringComparison.Ordinal)));	29✔
362	if (type.HasDefaultConstructor())	21✔
363	{
364	_ = Builder.AppendLineFormat(@"	21✔
365	public {0}()	21✔
366	:base()	21✔
367	{{	21✔
368	",	21✔
369	type.Name + "Derived");	21✔
370	_ = Aspects.ForEach(x => Builder.AppendLine(x.SetupDefaultConstructor(type)));	41✔
371	_ = Builder.AppendLineFormat(@"	21✔
372	}}");	21✔
373	}
374
375	_ = Aspects.ForEach(x => Builder.AppendLine(x.SetupInterfaces(type)));	41✔
376
377	Type? TempType = type;	21✔
378	var MethodsAlreadyDone = new List<string>();	21✔
379	while (TempType != null)	23✔
380	{
381	for (int i = 0, MaxLength = TempType.GetProperties().Length; i < MaxLength; i++)	209✔
382	{
383	PropertyInfo Property = TempType.GetProperties()[i];	70✔
384	MethodInfo? GetMethodInfo = Property.GetMethod;	70✔
385	MethodInfo? SetMethodInfo = Property.SetMethod;	70✔
386	if (!MethodsAlreadyDone.Contains("get_" + Property.Name)	70✔
387	&& !MethodsAlreadyDone.Contains("set_" + Property.Name)	70✔
388	&& GetMethodInfo?.IsVirtual == true	70✔
389	&& SetMethodInfo?.IsPublic == true	70✔
390	&& !GetMethodInfo.IsFinal	70✔
391	&& Property.GetIndexParameters().Length == 0)	70✔
392	{
393	GetAssemblies(Property.PropertyType, assembliesUsing);	60✔
394	_ = Builder.AppendLineFormat(@"	60✔
395	public override {0} {1}	60✔
396	{{	60✔
397	get	60✔
398	{{	60✔
399	{2}	60✔
400	}}	60✔
401	set	60✔
402	{{	60✔
403	{3}	60✔
404	}}	60✔
405	}}",	60✔
406	Property.PropertyType.GetName(ObjectPool),	60✔
407	Property.Name,	60✔
408	SetupMethod(type, GetMethodInfo, true),	60✔
409	SetupMethod(type, SetMethodInfo, true));	60✔
410	MethodsAlreadyDone.Add(GetMethodInfo.Name);	60✔
411	MethodsAlreadyDone.Add(SetMethodInfo.Name);	60✔
412	}
413	else if (!MethodsAlreadyDone.Contains("get_" + Property.Name)	10!
414	&& GetMethodInfo?.IsVirtual == true	10✔
415	&& SetMethodInfo is null	10✔
416	&& !GetMethodInfo.IsFinal	10✔
417	&& Property.GetIndexParameters().Length == 0)	10✔
418	{
419	GetAssemblies(Property.PropertyType, assembliesUsing);	×
NEW 420	_ = Builder.AppendLineFormat(@"	×
421	public override {0} {1}	×
422	{{	×
423	get	×
424	{{	×
425	{2}	×
426	}}	×
427	}}",	×
428	Property.PropertyType.GetName(ObjectPool),	×
429	Property.Name,	×
430	SetupMethod(type, GetMethodInfo, true));	×
431	MethodsAlreadyDone.Add(GetMethodInfo.Name);	×
432	}
433	else
434	{
435	if (GetMethodInfo != null)	10✔
436	MethodsAlreadyDone.Add(GetMethodInfo.Name);	10✔
437	if (SetMethodInfo != null)	10!
438	MethodsAlreadyDone.Add(SetMethodInfo.Name);	×
439	}
440	}
441
442	for (int i = 0, MaxLength = TempType.GetMethods().Length; i < MaxLength; i++)	589✔
443	{
444	MethodInfo Method = TempType.GetMethods()[i];	260✔
445	const string MethodAttribute = "public";
446	if (!MethodsAlreadyDone.Contains(Method.Name)	260✔
447	&& Method.IsVirtual	260✔
448	&& !Method.IsFinal	260✔
449	&& !Method.IsPrivate	260✔
450	&& !Method.Name.StartsWith("add_", StringComparison.OrdinalIgnoreCase)	260✔
451	&& !Method.Name.StartsWith("remove_", StringComparison.OrdinalIgnoreCase)	260✔
452	&& !Method.IsGenericMethod)	260✔
453	{
454	GetAssemblies(Method.ReturnType, assembliesUsing);	63✔
455	_ = Method.GetParameters().ForEach(x => GetAssemblies(x.ParameterType, assembliesUsing));	84✔
456	var Static = Method.IsStatic ? "static " : string.Empty;	63!
457	_ = Builder.AppendLineFormat(@"	63✔
458	{4} override {0} {1}({2})	63✔
459	{{	63✔
460	{3}	63✔
461	}}",	63✔
462	Static + Method.ReturnType.GetName(ObjectPool),	63✔
463	Method.Name,	63✔
464	Method.GetParameters().ToString(x => (x.IsOut ? "out " : string.Empty) + x.ParameterType.GetName(ObjectPool) + " " + x.Name),	21!
465	SetupMethod(type, Method, false),	63✔
466	MethodAttribute);	63✔
467	MethodsAlreadyDone.Add(Method.Name);	63✔
468	}
469	}
470
471	TempType = TempType.BaseType;	23✔
472	if (TempType == typeof(object))	23✔
473	break;
474	}
475	_ = Builder.AppendLine(@" }	21✔
476	}");	21✔
477	var ReturnValue = Builder.ToString();	21✔
478	ObjectPool?.Return(Builder);	21!
479	return ReturnValue;	21✔
480	}
481
482	private string SetupMethod(Type type, MethodInfo methodInfo, bool isProperty)
483	{
484	if (methodInfo is null)	183!
485	return string.Empty;	×
486	StringBuilder Builder = ObjectPool?.Get() ?? new StringBuilder();	183!
487	var BaseMethodName = methodInfo.Name.Replace("get_", string.Empty, StringComparison.Ordinal).Replace("set_", string.Empty, StringComparison.Ordinal);	183✔
488	var ReturnValue = methodInfo.ReturnType != typeof(void) ? "FinalReturnValue" : string.Empty;	183✔
489	var BaseCall = string.Empty;	183✔
490	BaseCall = isProperty	183!
491	? string.IsNullOrEmpty(ReturnValue) ? "base." + BaseMethodName : ReturnValue + "=base." + BaseMethodName	183✔
492	: string.IsNullOrEmpty(ReturnValue) ? "base." + BaseMethodName + "(" : ReturnValue + "=base." + BaseMethodName + "(";	183✔
493	ParameterInfo[] Parameters = methodInfo.GetParameters();	183✔
494	if (isProperty)	183✔
495	{
496	BaseCall += Parameters.Length > 0 ? "=" + Parameters.ToString(x => x.Name) + ";" : ";";	180✔
497	}
498	else
499	{
500	BaseCall += Parameters.Length > 0 ? Parameters.ToString(x => (x.IsOut ? "out " : string.Empty) + x.Name) : string.Empty;	84!
501	BaseCall += ");\r\n";	63✔
502	}
503	_ = Builder.AppendLineFormat(@"	183✔
504	try	183✔
505	{{	183✔
506	{0}	183✔
507	{1}	183✔
508	{2}	183✔
509	{3}	183✔
510	{4}	183✔
511	}}	183✔
512	catch(Exception CaughtException)	183✔
513	{{	183✔
514	{5}	183✔
515	throw;	183✔
516	}}",	183✔
517	methodInfo.ReturnType != typeof(void) ? methodInfo.ReturnType.GetName(ObjectPool) + " " + ReturnValue + ";" : string.Empty,	183✔
518	Aspects.ForEach(x => x.SetupStartMethod(methodInfo, type)).ToString(x => x, "\r\n"),	440✔
519	BaseCall,	183✔
520	Aspects.ForEach(x => x.SetupEndMethod(methodInfo, type, ReturnValue)).ToString(x => x, "\r\n"),	440✔
521	string.IsNullOrEmpty(ReturnValue) ? string.Empty : "return " + ReturnValue + ";",	183✔
522	Aspects.ForEach(x => x.SetupExceptionMethod(methodInfo, type)).ToString(x => x, "\r\n"));	623✔
523	var ReturnVal = Builder.ToString();	183✔
524	ObjectPool?.Return(Builder);	183!
525	return ReturnVal;	183✔
526	}
527	}
528	}

JaCraig / Aspectus / 11990621989

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