//[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());
}
