private Assembly DiscoverDynamicAssemblies(IEnumerable <ProjectItem> projectFiles, string cscToolPath)
{
var files = projectFiles.ToArray();
var extensionFiles = files.OfType(ProjectItemType.BuilderExtension);
var referenceFiles = files.OfType(ProjectItemType.Reference).ToArray();
var loggerProjectItems = files.OfType <LoggerTemplateModel>(ProjectItemType.LoggerInterface);
var compileFiles = new List <ProjectItem>();
compileFiles.AddRange(extensionFiles);
compileFiles.AddRange(loggerProjectItems);
var loaderHelperFile = CreateLoaderHelperClass();
compileFiles.Add(loaderHelperFile);
var complierHelper = new ComplierHelper();
this.PassAlongLoggers(complierHelper);
var compiledAssembly = complierHelper.Compile(cscToolPath, compileFiles, referenceFiles);
return(compiledAssembly);
}
private IExtension[] CompileAndEvaluateExtensions(Assembly dynamicAssembly, ProjectItem projectItem, IEnumerable <ProjectItem> referenceItems)
{
LogMessage($"Compiling possible logger builder extension file {projectItem?.Include ?? "in referenced dlls"}");
var extensions = new List <IExtension>();
try
{
var complierHelper = new ComplierHelper();
this.PassAlongLoggers(complierHelper);
var types = dynamicAssembly.GetTypes();
foreach (var type in types.Where(t => typeof(IExtension).IsAssignableFrom(t)))
{
var extension = (IExtension)Activator.CreateInstance(type);
extensions.Add(extension);
}
}
catch (Exception ex)
{
LogWarning($"Failed to compile/evaluate {projectItem.Include} - {ex.Message}\r\n{ex.StackTrace}");
}
return(extensions.ToArray());
}
private LoggerTemplateModel[] CompileAndEvaluateInterface(Assembly dynamicAssembly, IEnumerable <ProjectItem> projectItems)
{
var loggerFiles = projectItems.GetCSVList(p => p.Include);
LogMessage($"Compiling possible logger files {loggerFiles}");
var loggers = new List <LoggerTemplateModel>();
try
{
var complierHelper = new ComplierHelper();
this.PassAlongLoggers(complierHelper);
//var compiledAssembly = complierHelper.Compile(cscToolPath, projectItem, referenceItems);
if (dynamicAssembly != null)
{
var types = dynamicAssembly.GetTypes();
foreach (
var type in
types.Where(t => t.IsInterface && t.Name.Matches(@"^I[^\\]*Logger", StringComparison.InvariantCultureIgnoreCase, useWildcards: false)))
{
var projectItem = projectItems.FirstOrDefault(l => l.Name.Matches($"*{type.Name}.cs", StringComparison.InvariantCultureIgnoreCase, true));
if (projectItem == null)
{
LogWarning($"Could not find matching project item for type {type.Name}");
}
else
{
var include = projectItem.Include.Replace(projectItem.Name, type.Name);
var eventSourceLogger = new LoggerTemplateModel()
{
Name = type.Name,
Namespace = type.Namespace,
Include = include
};
var eventSourceEvents = new List <EventModel>();
foreach (var methodInfo in type.GetAllInterfaceMethods())
{
var eventSourceEventArguments = new List <EventArgumentModel>();
var eventSourceEvent = new EventModel()
{
Name = methodInfo.Name,
};
foreach (var parameterInfo in methodInfo.GetParameters())
{
var typeString = parameterInfo.ParameterType.GetFriendlyName();
eventSourceEventArguments.Add(new EventArgumentModel()
{
Name = parameterInfo.Name,
Type = typeString,
});
}
eventSourceEvent.Arguments = eventSourceEventArguments.ToArray();
eventSourceEvent.ReturnType = methodInfo.ReturnType.FullName != "System.Void" ? methodInfo.ReturnType?.GetFriendlyName() : null;
eventSourceEvents.Add(eventSourceEvent);
}
eventSourceLogger.Events = eventSourceEvents.ToArray();
loggers.Add(eventSourceLogger);
projectItem.Content = eventSourceLogger;
}
}
}
}
catch (Exception ex)
{
LogWarning($"Failed to compile/evaluate {loggerFiles} - {ex.Message}\r\n{ex.StackTrace}");
}
return(loggers.ToArray());
}
