public static IEnumerable <Type> TryGetTypes(this IAssembly assembly, bool throwException, IPluginLoaderLogger logger)
{
if (assembly == null)
{
return(null);
}
// I hate using a catch but assembly doesn't have a safe way to get Types
// that don't crash.
try { return(assembly.GetTypes()); }
catch (ReflectionTypeLoadException ex)
{
foreach (var loaderException in ex.LoaderExceptions)
{
logger?.Log(loaderException);
}
if (throwException)
{
// Unwrap the exception if there is only one
if (ex.LoaderExceptions.Length == 1)
{
throw ex.LoaderExceptions[0];
}
throw ex;
}
return(ex.Types.Where(t => t != null));
}
}
public IList<IMethodInfo> FindMethods(IAssembly assembly, Type attribute)
{
var q = from t in assembly.GetTypes()
from m in t.GetMethods()
/* Pass hard coded true as a parameter, let the caller decide */
where m.GetCustomAttributes(attribute, true).Any()
select m;
return q.ToList();
}
private static IEnumerable <ICommand> CreateCommands(IAssembly assembly)
{
var count = 0;
foreach (Type type in assembly.GetTypes())
{
if (typeof(ICommand).IsAssignableFrom(type))
{
if (Activator.CreateInstance(type) is ICommand result)
{
count++;
yield return(result);
}
}
}
if (count == 0)
{
string availableTypes = string.Join(",", assembly.GetTypes().Select(t => t.FullName));
throw new ApplicationException(
$"Can't find any type which implements ICommand in {assembly} from {assembly.Location}.\n" +
$"Available types: {availableTypes}");
}
}
internal static IEnumerable <VisitorBuilder> GetVisitorContexts(IAssembly assembly, VisitorModelCommonTypeContext attributeContext, ICSharpAssembly resultAssembly, IIntermediateCliManager identityManager)
{
var visitorRelevantTypes = assembly.GetTypes().Where(t => t.Metadata.Contains(attributeContext.TargetAttribute)).ToArray();
/* Using the metadata supplied on the relevant types, group them by their distinct visitor targets.
* We'll use the distinct targets to generate concrete visitor interfaces.
* The VisitorTargetAttribute allows multiple applications, so we may have multiple possible visitors for a single type. */
var visitorContextualDetail = (from type in visitorRelevantTypes
from metadatum in type.Metadata.Where(k => k.Type == attributeContext.TargetAttribute)
let currentDetail = VisitorTargetDetail.DeriveFromMetadata(metadatum)
group type by currentDetail into distinctVisitorDetail
orderby distinctVisitorDetail.Key.TargetContext,
string.IsNullOrEmpty(distinctVisitorDetail.Key.DerivedThroughInheriting)
? string.Empty
: distinctVisitorDetail.Key.DerivedThroughInheriting,
distinctVisitorDetail.Key.ContextualVisitor,
distinctVisitorDetail.Key.YieldingVisitor
select distinctVisitorDetail).ToDictionary(k => k.Key, v => new HashSet <IType>(v));
/* Break the sets into two variations:
* 1. Visitors which are derived from other visitors */
var inheritanceBasedDetail =
visitorContextualDetail.Keys.Where(k => !string.IsNullOrEmpty(k.DerivedThroughInheriting)).ToArray();
/* 2. The concrete visitors which aren't representative of derivation. There may be overlap. */
var nonDerivedVisitors =
visitorContextualDetail.Keys.Where(k => string.IsNullOrEmpty(k.DerivedThroughInheriting)).ToArray();
var directVisitors = (from context in nonDerivedVisitors
let builder = GetVisitorFrom(context, visitorContextualDetail[context], resultAssembly)
select builder).ToDictionary(k => k.Detail, v => v);
var inheritanceTree =
(from detail in inheritanceBasedDetail
orderby detail.TargetContext, detail.DerivedThroughInheriting
/* We group by a *new* TargetVisitorDetail since we're not interested in the DerivedThroughInheriting, which would fragment the visitors. */
group detail.DerivedThroughInheriting by new VisitorTargetDetail {
TargetContext = detail.TargetContext, ContextualVisitor = detail.ContextualVisitor, YieldingVisitor = detail.YieldingVisitor
})
.ToDictionary(k => k.Key, v => v.Distinct().ToArray());
var inheritanceOnlyVisitors = new Dictionary <VisitorTargetDetail, VisitorBuilder>();
foreach (var inheritanceKey in inheritanceTree.Keys)
{
var inheritedVisitorNames = inheritanceTree[inheritanceKey];
var iovKey = new VisitorTargetDetail {
TargetContext = inheritanceKey.TargetContext, ContextualVisitor = inheritanceKey.ContextualVisitor, YieldingVisitor = inheritanceKey.YieldingVisitor
};
VisitorBuilder mainBuilder;
if (!directVisitors.TryGetValue(inheritanceKey, out mainBuilder) && !inheritanceOnlyVisitors.TryGetValue(iovKey, out mainBuilder))
{
inheritanceOnlyVisitors.Add(iovKey, mainBuilder = new VisitorBuilder(inheritanceKey));
}
var childBuilders =
(from childDetail in inheritedVisitorNames
.Select(k =>
GetRelevantDetail(nonDerivedVisitors, inheritanceKey, k))
select directVisitors.ContainsKey(childDetail)
? directVisitors[childDetail]
: inheritanceOnlyVisitors.ContainsKey(childDetail)
? inheritanceOnlyVisitors[childDetail]
: new VisitorBuilder(childDetail)).ToArray();
foreach (var childBuilder in childBuilders.Where(childBuilder => childBuilder.VisitorInterface == null))
{
inheritanceOnlyVisitors.Add(childBuilder.Detail, childBuilder);
childBuilder.ScaffoldInterface(resultAssembly);
}
if (mainBuilder.VisitorInterface == null)
{
mainBuilder.SkippedTypes =
mainBuilder.RelevantTypes =
childBuilders
.SelectMany(k => k.RelevantTypes)
.Distinct()
.ToList();
mainBuilder.ScaffoldInterface(resultAssembly);
}
mainBuilder.ChildBuilders = childBuilders;
foreach (var childBuilder in childBuilders)
{
mainBuilder.VisitorInterface.ImplementedInterfaces.Add(childBuilder.VisitorInterface);
}
}
foreach (var builder in inheritanceOnlyVisitors.Values.Concat(directVisitors.Values))
{
builder.BuildVisitor();
}
return(inheritanceOnlyVisitors
.Values
.Concat(directVisitors.Values)
.OrderBy(k => k.Detail.TargetContext)
.ThenBy(k => k.Detail.ContextualVisitor)
.ThenBy(k => k.Detail.YieldingVisitor)
.ThenBy(k => string.IsNullOrEmpty(k.Detail.DerivedThroughInheriting) ? string.Empty : k.Detail.DerivedThroughInheriting)
.ToArray());
}
public static IEnumerable <Type> Locate(IAssembly assembly) => assembly.GetTypes().Where(x => typeof(IEventReceiver).IsAssignableFrom(x) && !x.IsAbstract).ToList();
