//[TestMethod] public void GenericResolverDemo() { InitializeGenericResolver(); var repository = GenericResolver <IRepository> .Resolve(); repository.Save("my item"); }
public void ResolveFullDomainGenericJobsTest() { var assemblyPaths = CompilationPipeline.GetAssemblies(AssembliesType.Player) .Select(a => a.outputPath); var jobResolver = new GenericResolver(assemblyPaths); var resolvedJobs = jobResolver.ResolveGenericJobs(); jobResolver.Dispose(); }
public void ResolveGenericJobsTest() { var assemblyPaths = CecilTypeUtility.GetAssemblyPaths(new[] { "Stackray.TestGenericJobs.dll" }); var jobResolver = new GenericResolver(assemblyPaths); var resolvedJobs = jobResolver.ResolveGenericJobs(); jobResolver.Dispose(); Assert.True(resolvedJobs.Count() == GenericJobs <bool, bool> .CONCRETE_UNIQUE_JOB_ENTRIES); }
public void GetGenericJobsCallsTest() { var assemblyPaths = CecilTypeUtility.GetAssemblyPaths(new[] { "Stackray.TestGenericJobs.dll" }); var jobResolver = new GenericResolver(assemblyPaths); var genericJobs = jobResolver.GetGenericJobCalls(); jobResolver.Dispose(); Assert.True(genericJobs.Count() == GenericJobs <bool, bool> .GENERIC_UNIQUE_JOB_ENTRIES); }
/// <summary> /// Resolves the generic values for a specified type. /// </summary> /// <param name="expectedTypes">Parameter types from method definition.</param> /// <param name="actualTypes">Argument types from method invocation site. </param> /// <param name="genericDefs">Generic parameters from method definition.</param> /// <param name="hints">Extra hints that are specified explicitly.</param> /// <param name="lambdaResolver"> /// Callback for Lambda`T resolution. /// Passed arguments are: /// 1. Lambda's position in the argument list (to find a corresponding NodeBase) /// 2. Already resolved list of types /// Return value is the inferred type of lambda return. /// </param> public static Type[] ResolveMethodGenericsByArgs(Type[] expectedTypes, Type[] actualTypes, Type[] genericDefs, Type[] hints = null, LambdaResolver lambdaResolver = null) { if (hints != null && hints.Length != genericDefs.Length) { throw new ArgumentException("hints"); } var resolver = new GenericResolver(genericDefs, hints, lambdaResolver); return(resolver.Resolve(expectedTypes, actualTypes)); }
public void ResolveGenericCascadeCallTest() { var assemblyPaths = CecilTypeUtility.GetAssemblyPaths(new[] { "Stackray.TestGenericCascadeCall.dll" }); var jobResolver = new GenericResolver(assemblyPaths); var resolvedJobs = jobResolver.ResolveGenericJobs(); jobResolver.Dispose(); Assert.True( resolvedJobs.Count() == 1 && (resolvedJobs.First() as GenericInstanceType).GenericArguments.Count == 1 && (resolvedJobs.First() as GenericInstanceType).GenericArguments.First().Name == typeof(int).Name); }
public void ResolveGenericSystemsTest() { var assemblyPaths = CecilTypeUtility.GetAssemblyPaths(new[] { "Stackray.TestGenericSystems.dll" }); var jobResolver = new GenericResolver(assemblyPaths); var resolvedJobs = jobResolver.ResolveGenericJobs(); jobResolver.Dispose(); Assert.True( resolvedJobs.Count() == 2 && resolvedJobs.Any(job => (job as GenericInstanceType).GenericArguments.First().Name == typeof(int).Name) && resolvedJobs.Any(job => (job as GenericInstanceType).GenericArguments.First().Name == typeof(double).Name)); }
public void DetectGenericJobTest() { var jobCount = 0; var assemblyPath = CecilTypeUtility.GetAssemblyPaths(new[] { "Stackray.TestGenericJobs.dll" }).Single(); using (var assembly = AssemblyDefinition.ReadAssembly(assemblyPath)) { var genericJobTypes = GenericResolver.GetGenericJobCalls(assembly) .Select(c => CecilTypeUtility.GetType(c.Type)) .ToArray(); jobCount = genericJobTypes.Length; } Assert.True(jobCount == GenericJobs <bool, bool> .GENERIC_JOB_ENTRIES); }
public static void Compile() { var watch = System.Diagnostics.Stopwatch.StartNew(); var assemblyToInjectPath = Path.GetFullPath(TempStagingManaged + MainAssemblyFileName); var injectedTypes = GenericResolver.InjectTypes(BufferGroupUtility.CreatePossibleTypes() .Union(BufferGroupUtility.GetFixedBufferProperties()), assemblyToInjectPath, $"Concrete{nameof(Renderer)}"); watch.Stop(); var log = $"{nameof(Stackray)}.{nameof(Renderer)} - {watch.ElapsedMilliseconds * 0.001f}s to inject {injectedTypes.Count()} concrete types in assembly '{Path.GetFullPath(assemblyToInjectPath)}'"; Debug.Log(log); log += "\n" + string.Join("\n", injectedTypes); WriteLog(log); }
public static GenericResolver Merge(GenericResolver resolver1, GenericResolver resolver2) { if (resolver1 == null) { return(resolver2); } if (resolver2 == null) { return(resolver1); } List <Type> types = new List <Type>(); types.AddRange(resolver1.KnownTypes); types.AddRange(resolver2.KnownTypes); return(new GenericResolver(types.ToArray())); }
public void WriteNewAssemblyInjectionTest() { var writeAssemblyPath = AssembliesPath + "TestConcreteAssembly.dll"; var assemblyPaths = CecilTypeUtility.GetAssemblyPaths(new[] { "Stackray.TestGenericJobs.dll" }); var jobResolver = new GenericResolver(assemblyPaths); var resolvedJobs = jobResolver.ResolveGenericJobs(); jobResolver.Dispose(); var outputAssembly = CecilTypeUtility.CreateAssembly("TestConcreteJobs", resolvedJobs); outputAssembly.Write(writeAssemblyPath); var assembly = AssemblyDefinition.ReadAssembly(writeAssemblyPath); var methods = CecilTypeUtility.GetMethodDefinitions(assembly).Where(m => m.FullName.Contains("TestConcreteJobs")); assembly.Dispose(); Assert.True(methods.Any()); }
/// <summary> /// Resolves the generic values for a specified type. /// </summary> /// <param name="expectedTypes">Parameter types from method definition.</param> /// <param name="actualTypes">Argument types from method invocation site. </param> /// <param name="genericDefs">Generic parameters from method definition.</param> /// <param name="hints">Extra hints that are specified explicitly.</param> /// <param name="lambdaResolver"> /// Callback for Lambda`T resolution. /// Passed arguments are: /// 1. Lambda's position in the argument list (to find a corresponding NodeBase) /// 2. Already resolved list of types /// Return value is the inferred type of lambda return. /// </param> /// <returns></returns> public static Type[] ResolveMethodGenericsByArgs(Type[] expectedTypes, Type[] actualTypes, Type[] genericDefs, Type[] hints = null, LambdaResolver lambdaResolver = null) { if(hints != null && hints.Length != genericDefs.Length) throw new ArgumentException("hints"); var resolver = new GenericResolver(genericDefs, hints, lambdaResolver); return resolver.Resolve(expectedTypes, actualTypes); }
public void InitializeGenericResolver() { GenericResolver <ICustomDbContext> .SetResolver(() => new CustomDbContext()); GenericResolver <IRepository> .SetResolver(() => GenericResolver <Repository> .Resolve()); }