public void CheckInheritance()
{
MarkupOpenGenericFactory openGenericFactory = MarkupOpenGenericFactory.Create(typeof(Foo), typeof(IFoo <,>));
var sut = openGenericFactory.Create <IFoo <string, string> >();
sut.Hello("hello").Should().Be("hello");
}
public void CheckInverseInheritance()
{
MarkupOpenGenericFactory openGenericFactory2 = MarkupOpenGenericFactory.Create(typeof(Foo), typeof(IFoo2 <,>));
var sut2 = openGenericFactory2.Create <IFoo2 <string, string> >();
var actual = sut2.Hello("hello");
sut2.Hello("hello").Should().Be("hello");
}
public void Discover(IEnumerable <Type> types)
{
var queryTypes = types
.SelectMany(t => t.FindOpenInterfaces(typeof(IQuery <,>)))
.ToArray();
var queryHandlerOpenType = typeof(IQueryHandler <, ,>);
var specificImplementations = types
.Where(x => x.ImplementsOpenInterface(queryHandlerOpenType))
.Select(x => new
{
HandlerType = x,
ImplementedInterfaces = x.FindOpenInterfaces(queryHandlerOpenType)
});
var markedWithConventionsImplementations = types
.WithAttribute <MarkupAttribute>(x => x.ServiceType == queryHandlerOpenType)
.Select(x => MarkupOpenGenericFactory.Create(x, queryHandlerOpenType).MarkupType)
.Select(x => new
{
HandlerType = x,
ImplementedInterfaces = x.FindOpenInterfaces(queryHandlerOpenType)
});
var queryHandlerTypes = specificImplementations.Union(markedWithConventionsImplementations).ToArray();
var projectionTypes = types
.Where(t => t.ImplementsOpenInterface(typeof(IProjection <>)) && !t.IsAbstract)
.ToArray();
var partitionerStreamIndex = types.Where(x => x.ImplementsOpenInterface(typeof(IProjectionStreamPartitioner <>)) && !x.IsAbstract)
.ToDictionary(x => x.FindOpenInterfaces(typeof(IProjectionStreamPartitioner <>)).Single().GetGenericArguments()[0]);
var partitionerQueryIndex = types.Where(x => x.ImplementsOpenInterface(typeof(IQueryPartitioner <>)) && !x.IsAbstract)
.ToDictionary(x => x.FindOpenInterfaces(typeof(IQueryPartitioner <>)).Single().GetGenericArguments()[0]);
List <ProjectionInfo> projectionInfos = new List <ProjectionInfo>();
foreach (var projectionType in projectionTypes)
{
var concreteProjectionTypes = projectionType.FindOpenInterfaces(typeof(IProjection <>)).ToArray();
foreach (var ct in concreteProjectionTypes)
{
var genericArgs = ct.GetGenericArguments();
Type modelType = genericArgs[0];
projectionInfos.Add(new ProjectionInfo()
{
ModelType = modelType,
ProjectionType = projectionType
});
}
}
foreach (var queryHandlerType in queryHandlerTypes)
{
foreach (var queryInterface in queryHandlerType.ImplementedInterfaces)
{
var genericArgs = queryInterface.GetGenericArguments();
Type queryType = genericArgs[0];
Type modelType = genericArgs[1];
Type resultType = genericArgs[2];
foreach (var pi in projectionInfos.Where(x => x.ModelType == modelType))
{
Register(queryType,
modelType,
pi.ProjectionType,
queryHandlerType.HandlerType,
resultType,
partitionerStreamIndex.ContainsKey(pi.ProjectionType) ? new [] { partitionerStreamIndex[pi.ProjectionType] } : Array.Empty <Type>(),
partitionerQueryIndex.ContainsKey(queryType) ? new[] { partitionerQueryIndex[queryType] } : Array.Empty <Type>()
);
}
}
}
foreach (var type in queryTypes)
{
var genericArgs = type.GetGenericArguments();
Type modelType = genericArgs[0];
Type resultType = genericArgs[1];
if (!_queryTypeIndex.ContainsKey(type))
{
Debug.WriteLine($"Could not find QueryHandler for {type.Name}.");
}
}
}
