public void EmptyPathThrows()
{
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog();
catalog.ModulePath = string.Empty;
catalog.Load();
}
/// <summary>
/// Proporciona el contenido del catalogo de módulos.
/// </summary>
/// <returns>un nuevo Module Catalog.</returns>
/// <remarks>
/// Este metodo usa el metodo de descubrimiento de modulos para "rellenar" el catalogo de modulos
/// Esto implica establecer un evento de postcompilación en las propiedades del proyecto que copie
/// los ensamblados obtenidos en la compilación del mismo hasta el directorio donde le decimos que podra
/// encontrar dichos modulos.
/// </remarks>
protected override IModuleCatalog CreateModuleCatalog()
{
var moduleCatalog = new DirectoryModuleCatalog();
moduleCatalog.ModulePath = @".\Modules";
return(moduleCatalog);
}
protected override void ConfigureModuleCatalog()
{
Type moduleAType = typeof(ModuleA.ModuleA);
ModuleCatalog.AddModule(new ModuleInfo(moduleAType.Name, moduleAType.AssemblyQualifiedName));
Type moduleCType = typeof(ModuleC.ModuleC);
ModuleCatalog.AddModule(new ModuleInfo()
{
ModuleName = moduleCType.Name,
ModuleType = moduleCType.AssemblyQualifiedName,
InitializationMode = InitializationMode.OnDemand
});
DirectoryModuleCatalog directoryCatalog = new DirectoryModuleCatalog()
{
ModulePath = @".\DirectoryModules"
};
((AggregateModuleCatalog)ModuleCatalog).AddCatalog(directoryCatalog);
ConfigurationModuleCatalog configurationCatalog = new ConfigurationModuleCatalog();
((AggregateModuleCatalog)ModuleCatalog).AddCatalog(configurationCatalog);
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
DirectoryModuleCatalog directoryCatalog = (DirectoryModuleCatalog)moduleCatalog;
directoryCatalog.Initialize();
moduleCollection = new ObservableCollection <ModuleModel>();
TypeFilter typeFilter = new TypeFilter(InterfaceFilter);
foreach (IModuleCatalogItem item in directoryCatalog.Items)
{
ModuleInfo mi = (ModuleInfo)item;
// in .NetFrameWork we dont need to replace
Assembly asm = Assembly.LoadFrom(mi.Ref.Replace(@"file:///", ""));
foreach (Type t in asm.GetTypes())
{
Type[] myInterfaces = t.FindInterfaces(typeFilter, typeof(IModuleService).ToString());
if (myInterfaces.Length > 0)
{
IModuleService moduleService = (IModuleService)asm.CreateInstance(t.FullName);
ModuleModel module = moduleService.GetModule();
moduleCollection.Add(module);
}
}
}
}
public void ShouldGetDependantModulesFromAttribute()
{
CompilerHelper.CompileFile(@"Prism.Wpf.Tests.Mocks.Modules.MockDependencyModule.cs",
ModulesDirectory3 + @"\DependencyModule.dll");
CompilerHelper.CompileFile(@"Prism.Wpf.Tests.Mocks.Modules.MockDependantModule.cs",
ModulesDirectory3 + @"\DependantModule.dll");
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog
{
ModulePath = ModulesDirectory3
};
catalog.Load();
var modules = catalog.Modules.ToArray();
Assert.Equal(2, modules.Length);
var dependantModule = modules.First(module => module.ModuleName == "DependantModule");
var dependencyModule = modules.First(module => module.ModuleName == "DependencyModule");
Assert.NotNull(dependantModule);
Assert.NotNull(dependencyModule);
Assert.NotNull(dependantModule.DependsOn);
Assert.Single(dependantModule.DependsOn);
Assert.Equal(dependencyModule.ModuleName, dependantModule.DependsOn[0]);
}
protected override IModuleCatalog CreateModuleCatalog()
{
DirectoryModuleCatalog catelog = new DirectoryModuleCatalog();
catelog.ModulePath = @".\Modules";
return(catelog);
}
public void ShouldIgnoreAbstractClassesThatImplementIModule()
{
CompilerHelper.CleanUpDirectory(ModulesDirectory1);
CompilerHelper.CompileFile(@"Prism.Avalonia.Tests.Mocks.Modules.MockAbstractModule.cs",
ModulesDirectory1 + @"\MockAbstractModule.dll");
string filename = typeof(DirectoryModuleCatalog).Assembly.Location;
string destinationFileName = Path.Combine(ModulesDirectory1, Path.GetFileName(filename));
File.Copy(filename, destinationFileName);
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog
{
ModulePath = ModulesDirectory1
};
catalog.Load();
var modules = catalog.Modules.ToArray();
Assert.AreEqual(1, modules.Length);
Assert.AreEqual("MockInheritingModule", modules[0].ModuleName);
CompilerHelper.CleanUpDirectory(ModulesDirectory1);
}
protected override void ConfigureModuleCatalog()
{
base.ConfigureModuleCatalog();
var appCatatlog = (ApplicationModuleCatalog)ModuleCatalog;
// Module A is referenced to the project and added by code.
Type moduleAType = typeof(ModuleA.ModuleA);
appCatatlog.AddModule(new ModuleInfo(moduleAType.Name, moduleAType.AssemblyQualifiedName));
// Module B is defined in configuration AppConfig (module section).
ConfigurationModuleCatalog configurationCatalog = new ConfigurationModuleCatalog();
appCatatlog.AddCatalog(configurationCatalog);
// Module C is not defined by will be loaded from diretory.
DirectoryModuleCatalog directoryCatalog = new DirectoryModuleCatalog()
{
ModulePath = @".\Modules"
};
appCatatlog.AddCatalog(directoryCatalog);
}
/// <summary>
/// The configure module catalog.
/// </summary>
protected override void ConfigureModuleCatalog()
{
var moduleCatalog = new NuGetBasedModuleCatalog
{
AllowPrereleaseVersions = true,
};
// Module A is defined from NuGet.
moduleCatalog.AddModule(new ModuleInfo("ModuleA", "ModularityWithCatel.Desktop.ModuleA, ModularityWithCatel.Desktop.ModuleA")
{
Ref = "ModularityWithCatel.Desktop.ModuleA"
});
// Module C is defined from NuGet.
moduleCatalog.AddModule(new ModuleInfo("ModuleC", "ModularityWithCatel.Desktop.ModuleC, ModularityWithCatel.Desktop.ModuleC")
{
Ref = "ModularityWithCatel.Desktop.ModuleC", InitializationMode = InitializationMode.OnDemand
});
ModuleCatalog.Add(moduleCatalog);
// Module B and Module D are copied to a directory as part of a post-build step.
// These modules are not referenced in the project and are discovered by inspecting a directory.
// Both projects have a post-build step to copy themselves into that directory.
var directoryCatalog = new DirectoryModuleCatalog {
ModulePath = @".\DirectoryModules"
};
ModuleCatalog.Add(directoryCatalog);
// Module E and Module F are defined in configuration.
var configurationCatalog = new ConfigurationModuleCatalog();
ModuleCatalog.Add(configurationCatalog);
}
protected override void ConfigureModuleCatalog()
{
// Module A is defined in the code.
Type moduleAType = typeof(ModuleA);
ModuleCatalog.AddModule(new ModuleInfo(moduleAType.Name, moduleAType.AssemblyQualifiedName));
// Module C is defined in the code.
Type moduleCType = typeof(ModuleC);
ModuleCatalog.AddModule(new ModuleInfo()
{
ModuleName = moduleCType.Name,
ModuleType = moduleCType.AssemblyQualifiedName,
InitializationMode = InitializationMode.OnDemand
});
// Module B and Module D are copied to a directory as part of a post-build step.
// These modules are not referenced in the project and are discovered by inspecting a directory.
// Both projects have a post-build step to copy themselves into that directory.
DirectoryModuleCatalog directoryCatalog = new DirectoryModuleCatalog()
{
ModulePath = @".\DirectoryModules"
};
((AggregateModuleCatalog)ModuleCatalog).AddCatalog(directoryCatalog);
// Module E and Module F are defined in configuration.
ConfigurationModuleCatalog configurationCatalog = new ConfigurationModuleCatalog();
((AggregateModuleCatalog)ModuleCatalog).AddCatalog(configurationCatalog);
}
protected override IModuleCatalog CreateModuleCatalog()
{
var moduleCatalog = new DirectoryModuleCatalog();
moduleCatalog.ModulePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + @"\Modules\";
return(moduleCatalog);
}
public void LoadsValidAssembliesWhenInvalidDllsArePresent()
{
CompilerHelper.CompileFile(@"Microsoft.Practices.Prism.Tests.Mocks.Modules.MockModuleA.cs",
InvalidModulesDirectory + @"\MockModuleA.dll");
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog();
catalog.ModulePath = InvalidModulesDirectory;
try
{
catalog.Load();
}
catch (Exception)
{
Assert.Fail("Should not have thrown.");
}
ModuleInfo[] modules = catalog.Modules.ToArray();
Assert.IsNotNull(modules);
Assert.AreEqual(1, modules.Length);
Assert.IsNotNull(modules[0].Ref);
StringAssert.StartsWith(modules[0].Ref, "file://");
Assert.IsTrue(modules[0].Ref.Contains(@"MockModuleA.dll"));
Assert.IsNotNull(modules[0].ModuleType);
StringAssert.Contains(modules[0].ModuleType, "Microsoft.Practices.Prism.Tests.Mocks.Modules.MockModuleA");
}
public void ShouldCorrectlyEscapeRef()
{
string assemblyPath = ModulesDirectory6 + @"\Mock Module #.dll";
CompilerHelper.CompileFile(@"Prism.Avalonia.Tests.Mocks.Modules.MockModuleA.cs", assemblyPath);
string fullAssemblyPath = Path.GetFullPath(assemblyPath);
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog
{
ModulePath = ModulesDirectory6
};
catalog.Load();
var modules = catalog.Modules.ToArray();
Assert.IsNotNull(modules);
Assert.AreEqual(1, modules.Length);
Assert.IsNotNull(modules[0].Ref);
string moduleRef = modules[0].Ref;
// = new Uri(moduleRef);
Assert.IsTrue(Uri.TryCreate(moduleRef, UriKind.Absolute, out Uri moduleUri));
Assert.AreEqual(fullAssemblyPath, moduleUri.LocalPath);
}
public void ShouldGetDependantModulesFromAttribute()
{
CompilerHelper.CompileFile(@"Microsoft.Practices.Prism.Tests.Mocks.Modules.MockDependencyModule.cs",
ModulesDirectory3 + @"\DependencyModule.dll");
CompilerHelper.CompileFile(@"Microsoft.Practices.Prism.Tests.Mocks.Modules.MockDependantModule.cs",
ModulesDirectory3 + @"\DependantModule.dll");
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog();
catalog.ModulePath = ModulesDirectory3;
catalog.Load();
ModuleInfo[] modules = catalog.Modules.ToArray();
Assert.AreEqual(2, modules.Length);
var dependantModule = modules.First(module => module.ModuleName == "DependantModule");
var dependencyModule = modules.First(module => module.ModuleName == "DependencyModule");
Assert.IsNotNull(dependantModule);
Assert.IsNotNull(dependencyModule);
Assert.IsNotNull(dependantModule.DependsOn);
Assert.AreEqual(1, dependantModule.DependsOn.Count);
Assert.AreEqual(dependencyModule.ModuleName, dependantModule.DependsOn[0]);
}
protected override IModuleCatalog CreateModuleCatalog()
{
DirectoryModuleCatalog moduleCatalog = new DirectoryModuleCatalog();
moduleCatalog.ModulePath = FileDirectoryUtil.GetAssemblyDirectory();
return(moduleCatalog);
}
public void NonExistentPathThrows()
{
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog();
catalog.ModulePath = "NonExistentPath";
catalog.Load();
}
protected override IModuleCatalog CreateModuleCatalog()
{
var moduleCatelog = new DirectoryModuleCatalog();
moduleCatelog.ModulePath = ConfigurationManager.AppSettings["PathToModules"];
return(moduleCatelog);
}
public ModuleInfo[] DoEnumeration(string path)
{
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog();
catalog.ModulePath = path;
catalog.Load();
return(catalog.Modules.ToArray());
}
public void NullPathThrows()
{
var ex = Assert.Throws <InvalidOperationException>(() =>
{
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog();
catalog.Load();
});
}
protected override IModuleCatalog CreateModuleCatalog()
{
base.CreateModuleCatalog();
var moduleCatalog = new DirectoryModuleCatalog {
ModulePath = @"."
};
return(moduleCatalog);
}
/// <summary>
/// adds the <see cref="DirectoryModuleCatalog"/> to the <see cref="AggregateModuleCatalog"/>. All modules in the DirectoryModules folder will be loaded.
/// </summary>
protected override void ConfigureModuleCatalog()
{
DirectoryModuleCatalog directoryCatalog = new DirectoryModuleCatalog()
{
ModulePath = @".\DirectoryModules"
};
((AggregateModuleCatalog)ModuleCatalog).AddCatalog(directoryCatalog);
}
protected override void ConfigureModuleCatalog()
{
base.ConfigureModuleCatalog();
DirectoryModuleCatalog _directoyCatalog = this.ModuleCatalog as DirectoryModuleCatalog;
_directoyCatalog.ModulePath = AppDomain.CurrentDomain.BaseDirectory;
_directoyCatalog.Initialize();
}
protected override IModuleCatalog CreateModuleCatalog()
{
var modulePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Modules");
var catalog = new DirectoryModuleCatalog {
ModulePath = modulePath
};
return(catalog);
}
/// <summary>
/// Creating catalog of Modules from .dlls in "Modules" folder
/// </summary>
protected override IModuleCatalog CreateModuleCatalog()
{
var catalog = new DirectoryModuleCatalog()
{
ModulePath = @"./Modules"
};
return(catalog);
}
protected override IModuleCatalog CreateModuleCatalog()
{
string absolutePath = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory + "../../../Modules");
DirectoryModuleCatalog directoryModuleCatalog = new DirectoryModuleCatalog()
{
ModulePath = absolutePath
};
return(directoryModuleCatalog);
}
/// <summary>
/// Creates the <see cref="T:Microsoft.Practices.Prism.Modularity.IModuleCatalog"/> used by Prism.
/// </summary>
protected override IModuleCatalog CreateModuleCatalog()
{
var moduleCatalog = new DirectoryModuleCatalog {
ModulePath = ModulesDirectory
};
moduleCatalog.Initialize();
return(moduleCatalog);
}
/// <summary>
/// Inizializza il catalogo per la creazione dei moduli aggiuntivi
/// (si potrebbe utilizzare DirectoryModuleCatalog)
/// </summary>
protected override IModuleCatalog CreateModuleCatalog()
{
//Carica tutti i moduli definiti nello XAML
//return Microsoft.Practices.Prism.Modularity.ModuleCatalog.CreateFromXaml(
// new Uri(ModuleCatalogUri, UriKind.Relative));
var moduleCatalog = new DirectoryModuleCatalog();
moduleCatalog.ModulePath = @".\";
return(moduleCatalog);
}
/// <summary>
/// GetModuleCatalog returns the list of Modules to
/// add to the Shell. Use the DirectoryModuleCatalog
/// so that the application scans the directory for
/// Modules.
/// </summary>
/// <returns></returns>
protected override IModuleCatalog GetModuleCatalog()
{
//Create the DirectoryModuleCatalog
DirectoryModuleCatalog dmc = new DirectoryModuleCatalog();
//Set the base path of the directory
dmc.ModulePath = ".";
//Return the result
return(dmc);
}
public void EmptyPathThrows()
{
var ex = Assert.Throws <InvalidOperationException>(() =>
{
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog
{
ModulePath = string.Empty
};
catalog.Load();
});
}
public void NonExistentPathThrows()
{
var ex = Assert.Throws <InvalidOperationException>(() =>
{
DirectoryModuleCatalog catalog = new DirectoryModuleCatalog
{
ModulePath = "NonExistentPath"
};
catalog.Load();
});
}
