private static CompositionContainer CreateDirectoryCatalog(string directoryPath, bool recursive)
{
if (!Directory.Exists(directoryPath))
{
throw new DirectoryNotFoundException("Runtime Action directory not found: " + directoryPath);
}
var aggregate = new AggregateCatalog();
var searchPattern = "*.dll";
try
{
if (recursive)
{
var q = from dir in Directory.EnumerateDirectories(directoryPath, "*", SearchOption.AllDirectories)
select new DirectoryCatalog(dir, searchPattern);
q.ToList().ForEach(catalog => aggregate.Catalogs.Add(catalog));
}
else
{
aggregate.Catalogs.Add(new DirectoryCatalog(directoryPath, searchPattern));
}
}
catch (ReflectionTypeLoadException tLException)
{
MefHelper.ThrowReflectionTypeLoadException(tLException);
}
return(new CompositionContainer(aggregate));
}
/// <summary>
/// This method would take the call object
/// and determine what kind of call to be made to which object
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
///
public HttpResponseMessage Post(CallObject obj)
{
try
{
switch (obj.CallType)
{
case "obj":
return(this.Request.CreateResponse(HttpStatusCode.OK));
case "service":
return(this.Request.CreateResponse(HttpStatusCode.OK));
default:
return(DefaultProcess(obj));
}
}
catch (Exception ex)
{
MefHelper.Error(ex);
return(this.Request.CreateErrorResponse(HttpStatusCode.BadRequest, new HttpError(ex, true)));
// return this.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex);
}
}
public void RegisterInstance_InstanceNull()
{
var helper = new MefHelper();
var container = new CompositionContainer();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.RegisterInstance(container, typeof(ITestInterface), null));
}
public void RegisterType_Valid()
{
var helper = new MefHelper();
var container = new CompositionContainer();
ExceptionTester.CallMethodAndExpectException <NotSupportedException>(() => helper.RegisterType(container, typeof(ITestInterface), typeof(TestClass1), RegistrationType.Singleton));
}
public void RegisterType_ImplementingTypeNull()
{
var helper = new MefHelper();
var container = new CompositionContainer();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.RegisterType(container, typeof(ITestInterface), null, RegistrationType.Singleton));
}
public void RegisterInstance_InvalidContainer()
{
var helper = new MefHelper();
var container = new object();
ExceptionTester.CallMethodAndExpectException <NotSupportedException>(() => helper.RegisterInstance(container, typeof(ITestInterface), new TestClass1()));
}
public void ResolveType_InterfaceTypeNull()
{
var helper = new MefHelper();
var container = new CompositionContainer();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.ResolveType(container, null));
}
public void GetRegistrationInfo_InvalidContainer()
{
var helper = new MefHelper();
var container = new object();
ExceptionTester.CallMethodAndExpectException <NotSupportedException>(() => helper.GetRegistrationInfo(container, typeof(ITestInterface)));
}
public void IsValidContainer_InvalidContainer()
{
var helper = new MefHelper();
var container = new object();
Assert.IsFalse(helper.IsValidContainer(container));
}
public void ResolveType_ContainerWithoutTypeRegistered()
{
var helper = new MefHelper();
var container = new CompositionContainer();
ExceptionTester.CallMethodAndExpectException <NotSupportedException>(() => helper.ResolveType(container, typeof(ITestInterface)));
}
public void GetRegistrationInfo_InterfaceTypeNull()
{
var helper = new MefHelper();
var container = new CompositionContainer();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.GetRegistrationInfo(container, null));
}
public void IsValidContainer_ValidContainer()
{
var helper = new MefHelper();
var container = new CompositionContainer();
Assert.IsTrue(helper.IsValidContainer(container));
}
public void ResolveType_InvalidContainer()
{
var helper = new MefHelper();
var container = new object();
ExceptionTester.CallMethodAndExpectException <NotSupportedException>(() => helper.ResolveType(container, typeof(ITestInterface)));
}
public void GetRegistrationInfo_ContainerWithoutTypeRegistered()
{
var helper = new MefHelper();
var container = new CompositionContainer();
Assert.IsNull(helper.GetRegistrationInfo(container, typeof(ITestInterface)));
}
public void GetRegistrationInfo_ContainerWithSingletonTypeRegistered()
{
var helper = new MefHelper();
var container = new CompositionContainer();
container.RegisterType(typeof(ITestInterface), typeof(TestClass1));
var registrationInfo = helper.GetRegistrationInfo(container, typeof(ITestInterface));
Assert.AreEqual(typeof(ITestInterface), registrationInfo.DeclaringType);
Assert.AreEqual(RegistrationType.Singleton, registrationInfo.RegistrationType);
}
public void RegisterInstance_Valid()
{
var helper = new MefHelper();
var instance = new TestClass1()
{
Name = "test"
};
var container = new CompositionContainer();
Assert.IsFalse(container.GetRegistrationInfo(typeof(ITestInterface)));
helper.RegisterInstance(container, typeof(ITestInterface), instance);
Assert.IsTrue(container.GetRegistrationInfo(typeof(ITestInterface)));
Assert.AreEqual(instance, container.ResolveType <ITestInterface>());
}
public IEnumerable <IReportRuntimeAction> GetRuntimeActions()
{
IEnumerable <IReportRuntimeAction> result = null;
try
{
var exports = _container.GetExports <IReportRuntimeAction>();
result = (from export in exports
select export.Value).ToList();
}
catch (ReflectionTypeLoadException tLException)
{
MefHelper.ThrowReflectionTypeLoadException(tLException);
}
return(result);
}
public void Configuration(IAppBuilder app)
{
HttpConfiguration config = new HttpConfiguration();
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ConfigureOAuth(app);
MefHelper.Initialize(new ApplicationCatalog());
WebApiConfig.Register(config);
app.UseCors(CorsOptions.AllowAll);
app.UseWebApi(config);
}
/// <summary>
/// Gets the history storage.
/// </summary>
/// <param name="reportConfiguration">The report configuration.</param>
/// <returns>
/// The history storage or <code>null</code> if no storage exists.
/// </returns>
public IHistoryStorage GetHistoryStorage(ReportConfiguration reportConfiguration)
{
var storages = MefHelper.LoadInstancesOfType <IHistoryStorage>().ToArray();
if (storages.Length == 1)
{
return(storages[0]);
}
else if (storages.Length > 1)
{
Logger.WarnFormat(Resources.SeveralCustomHistoryStorages);
}
else if (reportConfiguration.HistoryDirectory != null)
{
return(new FileHistoryStorage(reportConfiguration.HistoryDirectory));
}
return(null);
}
public void ResolveType_Singleton()
{
var helper = new MefHelper();
var container = new CompositionContainer();
container.RegisterType <ITestInterface, TestClass1>();
var resolvedInstance1 = helper.ResolveType(container, typeof(ITestInterface));
Assert.IsNotNull(resolvedInstance1);
Assert.IsInstanceOfType(resolvedInstance1, typeof(TestClass1));
var resolvedInstance2 = helper.ResolveType(container, typeof(ITestInterface));
Assert.IsNotNull(resolvedInstance2);
Assert.IsInstanceOfType(resolvedInstance2, typeof(TestClass1));
Assert.IsTrue(ReferenceEquals(resolvedInstance1, resolvedInstance2));
}
public void ResolveType_Transient()
{
var helper = new MefHelper();
var container = new CompositionContainer();
container.RegisterType <ITestInterface, TestClass1>();
var resolvedInstance1 = helper.ResolveType(container, typeof(ITestInterface));
Assert.IsNotNull(resolvedInstance1);
Assert.IsInstanceOfType(resolvedInstance1, typeof(TestClass1));
var resolvedInstance2 = helper.ResolveType(container, typeof(ITestInterface));
Assert.IsNotNull(resolvedInstance2);
Assert.IsInstanceOfType(resolvedInstance2, typeof(TestClass1));
// Note that MEF does not support transient types
Assert.IsTrue(ReferenceEquals(resolvedInstance1, resolvedInstance2));
}
protected override void Configure()
{
var catalog = MefHelper.SafeDirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory);
AssemblySource.Instance.Select(x => new AssemblyCatalog(x))
.OfType <ComposablePartCatalog>()
.ToList().ForEach((c) => {
catalog.Catalogs.Add(c);
});
GlobalData.MefContainer = new CompositionContainer(catalog);
// GlobalData.MefContainer = new CompositionContainer(catalog,CompositionOptions.DisableSilentRejection);//// container = CompositionHost.Initialize(catalog);
var batch = new CompositionBatch();
batch.AddExportedValue <IWindowManager>(new WindowManager());
batch.AddExportedValue <IEventAggregator>(new EventAggregator());
//batch.AddExportedValue<IWindowManager>(new ScreenLifetimeManagerViewModel());
//batch.AddExportedValue<IEventAggregator>(new WebBoxViewModel());
batch.AddExportedValue(GlobalData.MefContainer);
////batch.AddExportedValue(container);
////batch.AddExportedValue(catalog);
//this.Container.ComposeParts(this);
GlobalData.MefContainer.Compose(batch);//// container.Compose(batch);
//EFLogger.EFLogger.Init();
Coroutine.Completed += (s, e) => {
if (e.Error != null)
{
MessageBox.Show(e.Error.Message);
}
};
}
protected override void Configure()
{
var catalog = MefHelper.SafeDirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory);
AssemblySource.Instance.Select(x => new AssemblyCatalog(x))
.OfType <ComposablePartCatalog>()
.ToList().ForEach((c) => {
catalog.Catalogs.Add(c);
});
GlobalData.MefContainer = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
var batch = new CompositionBatch();
batch.AddExportedValue <IWindowManager>(new WindowManager());
batch.AddExportedValue <IEventAggregator>(new EventAggregator());
batch.AddExportedValue(GlobalData.MefContainer);
//this.Container.ComposeParts(this);
GlobalData.MefContainer.Compose(batch);
EFLogger.EFLogger.Init();
}
public void RegisterInstance_ContainerNull()
{
var helper = new MefHelper();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.RegisterInstance(null, typeof(ITestInterface), new TestClass1()));
}
public void IsValidContainer_Null()
{
var helper = new MefHelper();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.IsValidContainer(null));
}
public void ResolveType_ContainerNull()
{
var helper = new MefHelper();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.ResolveType(null, typeof(ITestInterface)));
}
private static IConnectionProvider ComposeProvider(string extension)
{
return(MefHelper.Compose <IConnectionProvider>(extension));
}
public void RegisterType_ContainerNull()
{
var helper = new MefHelper();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.RegisterType(null, typeof(ITestInterface), typeof(TestClass1), RegistrationType.Singleton));
}
public void GetRegistrationInfo_ContainerNull()
{
var helper = new MefHelper();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => helper.GetRegistrationInfo(null, typeof(ITestInterface)));
}
public PowerShellConsoleLauncher(IAlbumRepository albumRepository, MefHelper mefHelper)
{
_albumRepository = albumRepository;
_mefHelper = mefHelper;
}
public PowerShellConsoleLauncher(IAlbumRepository albumRepository, MefHelper mefHelper)
{
_albumRepository = albumRepository;
_mefHelper = mefHelper;
}
