public static bool TryInject(
IServiceRegistrationProvider serviceProvider,
object target,
Type attributeType,
ITrace logger = null,
Func <Type, object> instanceProvider = null,
bool tryConstructArguments = false,
bool?requireConstructorAttributes = null,
IReadOnlyCollection <Type> constructorAttributeTypes = null)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (attributeType == null)
{
throw new ArgumentNullException(nameof(attributeType));
}
if ((constructorAttributeTypes == null) ||
(constructorAttributeTypes.Count == 0))
{
constructorAttributeTypes = new[] { typeof(ServiceProviderConstructorAttribute) }
}
;
ServiceConstructorRequest request
= new ServiceConstructorRequest(logger ?? TraceSources.For(typeof(ServiceConstructorMethods)));
request.Logger.Verbose(
"Injecting '{0}' on '{1}'.",
attributeType.GetFriendlyFullName(),
target.GetType().GetFriendlyFullName());
if (ServiceConstructorMethods.invokeMember(
ServiceConstructorMethods.findMethods(target, attributeType, request.TraceStack),
true,
target,
out _,
request,
serviceProvider,
instanceProvider,
tryConstructArguments,
requireConstructorAttributes,
constructorAttributeTypes,
false))
{
request.Logger.Verbose(
"Inject result for '{0}' on '{1}' is true.",
attributeType.GetFriendlyFullName(),
target.GetType().GetFriendlyFullName());
return(true);
}
request.Logger.Info(
"Inject result for '{0}' on '{1}' is false.",
attributeType.GetFriendlyFullName(),
target.GetType().GetFriendlyFullName());
return(false);
}
public void RegisterExport(Type importType, Type exportType)
{
if (importType == null)
{
throw new ArgumentNullException(nameof(importType));
}
if (exportType == null)
{
throw new ArgumentNullException(nameof(exportType));
}
if (!typeof(TExport).IsAssignableFrom(exportType))
{
throw new ArgumentException(typeof(TExport).GetFriendlyFullName(), nameof(exportType));
}
lock (Registrations) {
if (Registrations.ContainsKey(importType))
{
throw new InvalidOperationException(
$"Cannot add duplicate registration for '{importType.GetFriendlyFullName()}'.");
}
if (!OnRegisterExport(importType, exportType))
{
return;
}
TraceSources.For(GetType())
.Verbose(
$"{nameof(ExportRegistry<TExport>.RegisterExport)}:"
+ " '{0}' for '{1}'.",
exportType.GetFriendlyFullName(),
importType.GetFriendlyFullName());
Registrations[importType] = exportType;
}
}
private void refresh(FileSystemEventArgs fileSystemEventArgs)
{
Exception exception;
lock (syncLock) {
if (isDisposed)
{
if (fileSystemEventArgs == null)
{
throw new ObjectDisposedException(ToString());
}
return;
}
disposeFileSystemWatcher();
tryCreateFileSystemWatcher(out exception);
if (exception != null)
{
TraceSources.For <DirectoryWatcher>()
.Error("Local Error for {0}: {1}.", exception, this, exception.Message);
}
else if ((fileSystemEventArgs == null) ||
!IsWatchingPath)
{
return;
}
}
Changed?.Invoke(this, new DirectoryWatcherEventArgs(fileSystemEventArgs, exception));
}
/// <summary>
/// Invokes the <see cref="TraceSources"/> factory method with a delegate
/// that adds a verbose console trace listener to all sources.
/// </summary>
/// <returns>Dispose to reset the default factory.</returns>
public static IDisposable TraceAllVerbose()
{
void Configure(SimpleTraceSource traceSource)
{
traceSource.TraceSource.TryAdd(
new Diagnostics.ConsoleTraceListener
{
Filter = new EventTypeFilter(SourceLevels.All),
});
traceSource.TraceSource.Switch.Level = SourceLevels.All;
}
void Remove(SimpleTraceSource traceSource)
=> traceSource.TraceSource.Listeners.Remove(Diagnostics.ConsoleTraceListener.DefaultName);
DelegateTraceSourceSelector selector = new DelegateTraceSourceSelector(Configure, Remove);
TraceSources.AddSelector(selector);
TraceSources.For(typeof(TestHelper))
.Verbose("TraceSources are verbose.");
void Dispose()
=> TraceSources.RemoveSelector(selector);
return(DelegateDisposable.With(Dispose));
}
/// <summary>
/// This method is virtual and implements
/// <see cref="IHandleComposed{TTarget}.HandleComposed{T}"/>.
/// This implementation invokes all participants added here.
/// Notice that each is invoked in a catch block, and this will trace exceptions,
/// AND re-throw a new <see cref="AggregateException"/> if there are
/// any exceptions.
/// </summary>
/// <param name="eventArgs"><see cref="IHandleComposed{TTarget}"/> argument.</param>
/// <exception cref="AggregateException"></exception>
public void HandleComposed <T>(ComposerEventArgs <T> eventArgs)
where T : TTarget
{
lock (Participants) {
checkDisposed();
List <Exception> exceptions = new List <Exception>(Participants.Count);
foreach (IHandleComposed <TTarget> participant
in Participants.OfType <IHandleComposed <TTarget> >())
{
try {
participant.HandleComposed(eventArgs);
} catch (Exception exception) {
TraceSources.For(GetType())
.Error(
exception,
"Participant exception invoking HandleComposed: {0}, '{1}'.",
participant,
exception.Message);
exceptions.Add(exception);
}
}
if (exceptions.Count != 0)
{
throw new AggregateException(
$"One or more exceptions was raised by a {GetType().GetFriendlyName()} participant in"
+ $" {nameof(IHandleComposed<TTarget>.HandleComposed)}.",
exceptions.EnumerateInReverse());
}
}
}
protected sealed override void WithAllParts(ContainerConfiguration target)
{
Action Mutate(MultiDictionary <CompositionHost, object> exportsList)
{
try {
CompositionHost compositionHost = target.CreateContainer();
List <object> newExports = new List <object>();
foreach (Type compositionContract in ExportTypes)
{
newExports.AddRange(compositionHost.GetExports(compositionContract));
}
Action OnMutate(List <object> list)
=> handleNewExports(list, newExports);
return(handleMutate(exportsList, OnMutate, compositionHost));
} catch (Exception exception) {
TraceSources.For <MefSingletonComposer>()
.Error(
exception,
"Catching exception refreshing Exports: {0}",
exception.Message);
throw;
}
}
exports.Mutate(Mutate)
?.Invoke();
}
/// <summary>
/// This virtual method provides the implementation for
/// <see cref="IProvideParts{TTarget}"/>.
/// This enumerates the files on the <see cref="DirectoryWatcher"/> with the
/// <see cref="SearchOption"/>, and loads each path with <see cref="TryLoadAssembly"/>.
/// This method catches and traces all exceptions; and also provides support for
/// <see cref="ProvideAssembliesOneTimeOnly"/>.
/// </summary>
public virtual void ProvideParts <T>(ProvidePartsEventArgs <T> eventArgs)
where T : ContainerConfiguration
{
List <Assembly> assemblies = new List <Assembly>();
if (DirectoryWatcher.PathExists)
{
try {
foreach (string filePath in Directory.EnumerateFiles(
DirectoryWatcher.Path,
DirectoryWatcher.Filter,
SearchOption))
{
if (TryLoadAssembly(filePath, out Assembly assembly))
{
assemblies.Add(assembly);
}
}
} catch (Exception exception) {
TraceSources.For <MefDirectoryPartWatcher>()
.Warning(
exception,
"Catching exception enumerating files in the watched directory: '{0}'.",
exception.Message);
}
}
if (assemblies.Count == 0)
{
return;
}
lock (ComposedAssemblies) {
if (ProvideAssembliesOneTimeOnly)
{
foreach (Assembly assembly in new List <Assembly>(assemblies))
{
if (!ComposedAssemblies.Contains(assembly))
{
ComposedAssemblies.Add(assembly);
}
else
{
assemblies.Remove(assembly);
}
}
if (assemblies.Count == 0)
{
return;
}
}
}
if (Conventions != null)
{
eventArgs.Target.WithAssemblies(assemblies, Conventions);
}
else
{
eventArgs.Target.WithAssemblies(assemblies);
}
}
private void trySetPropertiesFromConfigFile()
{
string configFilePath = GetConfigFileFullPath();
if (File.Exists(configFilePath))
{
try {
LogFileFactoryConfig newLogFileFactoryConfig
= LogFileFactoryConfig.LoadFromFile(configFilePath);
bool resetIsInitializing = false;
try {
lock (SyncLock) {
resetIsInitializing = !isInitializing;
isInitializing = true;
}
newLogFileFactoryConfig.SetPropertiesOn(this);
} finally {
lock (SyncLock) {
logFileFactoryConfig = newLogFileFactoryConfig;
if (resetIsInitializing)
{
isInitializing = false;
}
}
}
TraceSources.For(TraceFileFactoryAssembly)
.Info(
"Found {0} file found at '{1}' - '{2}'.",
nameof(LogFileFactoryConfig),
configFilePath,
logFileFactoryConfig);
} catch (Exception exception) {
TraceSources.For(TraceFileFactoryAssembly)
.Error(
exception,
"Invalid {0} file found at '{1}' - '{2}'.",
nameof(LogFileFactoryConfig),
configFilePath,
exception.Message);
}
}
else
{
try {
Directory.CreateDirectory(GetLogFolderPath());
LogFileFactoryConfig.CreateFrom(this, out XmlDocument xmlDocument);
File.WriteAllText(configFilePath, xmlDocument.InnerXml);
} catch (Exception exception) {
TraceSources.For(TraceFileFactoryAssembly)
.Error(
exception,
"Error writing {0} file to '{1}' - '{2}'.",
nameof(LogFileFactoryConfig),
configFilePath,
exception.Message);
}
}
}
private void handleConfigWatcherError(object sender, ErrorEventArgs e)
=> TraceSources.For <LogFileFactory>()
.Error(
e.GetException(),
"{0} error for config file watcher at '{1}' - '{2}'.",
nameof(FileSystemWatcher),
Path.Combine(GetLogFolderPath(), GetConfigFileName()),
e.GetException()
.Message);
private void traceAction(string message)
{
TraceSources.For(TraceFileFactoryAssembly)
.Warning($"########## #### {message} #### ##########");
Trace.TraceWarning(
"########## #### "
+ $"{message} For: {TraceFileFactoryAssembly.GetName().Name}."
+ " #### ##########");
FlushAll();
}
private void handleFileSystemWatcherError(object sender, ErrorEventArgs errorEventArgs)
{
Exception exception = errorEventArgs.GetException();
TraceSources.For <DirectoryWatcher>()
.Warning(
exception,
$"{nameof(FileSystemWatcher)} Error for {{0}}: {{1}}.",
this,
exception.Message);
FileSystemWatcherError?.Invoke(this, errorEventArgs);
}
private void tryCreateFileSystemWatcher(out Exception exception)
{
try {
string path = Path;
do
{
if (Directory.Exists(path))
{
break;
}
path = System.IO.Path.GetDirectoryName(PathHelper.RemoveTrailingSeparators(path));
if (!string.IsNullOrWhiteSpace(path))
{
continue;
}
throw new NotSupportedException($"Failed to create {nameof(FileSystemWatcher)} for {this}.");
} while (true);
fileSystemWatcher = PathHelper.IsSameFullPath(Path, path)
? new FileSystemWatcher
{
Path = Path,
Filter = Filter,
IncludeSubdirectories = IncludeSubdirectories,
NotifyFilter = NotifyFilter,
EnableRaisingEvents = true
}
: new FileSystemWatcher
{
Path = path,
Filter = "*",
IncludeSubdirectories = true,
NotifyFilter = NotifyFilters.LastWrite
| NotifyFilters.DirectoryName,
EnableRaisingEvents = true
};
fileSystemWatcher.Changed += handleFileSystemWatcherChanged;
fileSystemWatcher.Created += handleFileSystemWatcherChanged;
fileSystemWatcher.Deleted += handleFileSystemWatcherChanged;
fileSystemWatcher.Renamed += handleFileSystemWatcherChanged;
fileSystemWatcher.Error += handleFileSystemWatcherError;
exception = null;
} catch (Exception error) {
TraceSources.For <DirectoryWatcher>()
.Error(
error,
"Failed to refresh {0}: {1}. Not watching any folder.",
this,
error.Message);
fileSystemWatcher?.Dispose();
fileSystemWatcher = null;
exception = error;
}
}
/// <summary>
/// This protected virtual method loads each Assembly. If a delegate was provided, that
/// is invoked here; and otherwise, this loads the Assembly with <c>Assembly.LoadFrom</c>.
/// This is invoked in <see cref="ProvideParts{T}"/>. This method catches and traces all
/// exceptions.
/// </summary>
/// <param name="filePath">Not null.</param>
/// <param name="assembly">Not null if the method returns true.</param>
/// <returns>True if the out argument is not null.</returns>
protected virtual bool TryLoadAssembly(string filePath, out Assembly assembly)
{
try {
assembly = loadAssembly != null
? loadAssembly(filePath)
: Assembly.LoadFrom(filePath);
} catch (Exception exception) {
TraceSources.For <MefDirectoryPartWatcher>()
.Warning(
exception,
"Failed to load Assembly from '{0}': {1}.",
filePath,
exception.Message);
assembly = null;
}
return(assembly != null);
}
private void setupTracingUnsafe()
{
bool resetIsInitializing = false;
try {
lock (SyncLock) {
if (!isInitialized ||
isInitializing)
{
return;
}
isInitializing = true;
resetIsInitializing = true;
}
TraceSources.For(TraceFileFactoryAssembly)
.Info("Configure tracing.");
HandleBeginSetupTracing();
disposeResources();
if (ToggleLogFile)
{
lock (SyncLock) {
logFileListener = CreateFileLogTraceListener();
}
}
setupConfigFileWatcher();
if (addToTraceSources)
{
TraceSources.AddSelector(this);
}
traceAction(
LogFileListener != null
? $"{nameof(LogFileFactory)} Trace File Initialized."
: $"{nameof(LogFileFactory)} Reset With No Trace File.");
} finally {
if (resetIsInitializing)
{
lock (SyncLock) {
isInitializing = false;
}
}
}
HandleEndSetupTracing();
}
private object tryGetService(
Type serviceType,
ServiceConstructorRequest serviceConstructorRequest)
{
if (serviceType == null)
{
throw new ArgumentNullException(nameof(serviceType));
}
object service = serviceProvider.GetService(serviceType);
return(serviceType.IsInstanceOfType(service)
? service
: parentServiceRegistrationProvider != null
? parentServiceRegistrationProvider.GetService(
serviceType,
serviceConstructorRequest
?? new ServiceConstructorRequest(
TraceSources.For <ServiceRegistrationProviderWrapper>()))
: ParentServiceProvider?.GetService(serviceType));
}
private void setupConfigFileWatcher()
{
lock (SyncLock) {
if (!isInitialized)
{
return;
}
disposeConfigFileWatcher();
if (!WatchConfigFileChanges)
{
return;
}
try {
Directory.CreateDirectory(GetLogFolderPath());
configFileWatcher
= new FileSystemWatcher(
GetLogFolderPath(),
GetConfigFileName())
{
IncludeSubdirectories = false,
NotifyFilter = NotifyFilters.CreationTime
| NotifyFilters.FileName
| NotifyFilters.LastWrite,
EnableRaisingEvents = true,
};
configFileWatcher.Changed += handleConfigWatcherChangeEvent;
configFileWatcher.Created += handleConfigWatcherChangeEvent;
configFileWatcher.Deleted += handleConfigWatcherChangeEvent;
configFileWatcher.Error += handleConfigWatcherError;
} catch (Exception exception) {
disposeConfigFileWatcher();
TraceSources.For(TraceFileFactoryAssembly)
.Error(
exception,
"Exception trying to watch for {0} config file changes at '{1}' - '{2}'.",
nameof(LogFileFactoryConfig),
GetConfigFileFullPath(),
exception.Message);
}
}
}
/// <summary>
/// Static helper method is used to configure optional verbose tracing.
/// </summary>
private static void configureTracing()
{
Console.WriteLine("Verbose Tracing? (Y for Yes)");
ConsoleKey consoleKey = Console.ReadKey().Key;
Console.WriteLine();
if (consoleKey != ConsoleKey.Y)
{
return;
}
void Configure(SimpleTraceSource traceSource)
{
traceSource.TraceSource.TryAdd(
new Sc.Diagnostics.ConsoleTraceListener
{
Filter = new EventTypeFilter(SourceLevels.All),
});
traceSource.TraceSource.Switch.Level = SourceLevels.All;
}
TraceSources.AddSelector(new DelegateTraceSourceSelector(Configure));
TraceSources.For(typeof(Program))
.Verbose("TraceSources are verbose.");
}
private ServiceConstructorRequest newServiceConstructorRequest() => new ServiceConstructorRequest(TraceSources.For <BasicContainer>());
private void handleFileSystemWatcherChanged(object sender, FileSystemEventArgs fileSystemEventArgs)
{
TraceSources.For <DirectoryWatcher>()
.Verbose("Refreshing {0}.", this);
refresh(fileSystemEventArgs);
}
