public static IList<Assembly> GetAssemblies(IList<string> gacFolders, Func<string, bool> assemblyNameCondition, Func<string, bool> assemblyVersionCondition)
{
var assemblyList = new List<Assembly>();
var logger = new TraceLogger("GSoft.Dynamite", "GSoft.Dynamite", false);
try
{
foreach (string folder in gacFolders)
{
var path = Path.Combine(FolderPath, folder);
if (Directory.Exists(path))
{
string[] assemblyFolders = Directory.GetDirectories(path);
foreach (string assemblyFolder in assemblyFolders)
{
ProcessFolder(assemblyFolder, assemblyNameCondition, assemblyVersionCondition, assemblyList, logger);
}
}
}
}
catch (Exception error)
{
logger.Fatal(string.Format(CultureInfo.InvariantCulture, "GACAssemblyLocator failed to scan GAC. Error: {0}", error.ToString()));
}
return assemblyList;
}
/// <summary>
/// Registers the modules type bindings
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
protected override void Load(ContainerBuilder builder)
{
// Logging
#if DEBUG
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, true); // Logger with debug output
builder.RegisterInstance<ILogger>(logger);
#else
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, false); // Logger without debug output
builder.RegisterInstance<ILogger>(logger);
#endif
// Binding
var entitySchemaBuilder = new EntitySchemaBuilder<SharePointDataRowEntitySchema>();
var cachedBuilder = new CachedSchemaBuilder(entitySchemaBuilder, logger);
builder.RegisterType<SharePointDataRowEntitySchema>();
builder.RegisterInstance<IEntitySchemaBuilder>(cachedBuilder);
builder.RegisterType<TaxonomyValueDataRowConverter>();
builder.RegisterType<TaxonomyValueCollectionDataRowConverter>();
builder.RegisterType<TaxonomyValueConverter>();
builder.RegisterType<TaxonomyValueCollectionConverter>();
builder.RegisterType<SharePointEntityBinder>().As<ISharePointEntityBinder>().InstancePerSite(); // Singleton-per-site entity binder
// Cache
builder.RegisterType<CacheHelper>().As<ICacheHelper>();
// Definitions
builder.RegisterType<ContentTypeBuilder>();
builder.RegisterType<FieldHelper>();
// Globalization + Variations (with default en-CA as source + fr-CA as destination implementation)
builder.RegisterType<ResourceLocator>().As<IResourceLocator>(); // It's the container user's responsibility to register a IResourceLocatorConfig implementation
builder.RegisterType<MuiHelper>();
builder.RegisterType<DateHelper>();
builder.RegisterType<RegionalSettingsHelper>();
builder.RegisterType<DefaultVariationDirector>().As<IVariationDirector>();
builder.RegisterType<CanadianEnglishAndFrenchVariationBuilder>().As<IVariationBuilder>();
builder.RegisterType<VariationExpert>().As<IVariationExpert>();
// Lists
builder.RegisterType<ListHelper>();
builder.RegisterType<ListLocator>();
builder.RegisterType<ListSecurityHelper>();
// MasterPages
builder.RegisterType<MasterPageHelper>();
builder.RegisterType<ExtraMasterPageBodyCssClasses>().As<IExtraMasterPageBodyCssClasses>();
// Repositories
builder.RegisterType<FolderRepository>();
builder.RegisterType<QueryHelper>().As<IQueryHelper>();
// Security
builder.RegisterType<SecurityHelper>();
builder.RegisterType<UserHelper>();
// Serializers
builder.RegisterType<ServiceStackSerializer>().As<ISerializer>().SingleInstance();
// Setup
builder.RegisterType<FieldValueInfo>().As<IFieldValueInfo>();
builder.RegisterType<FolderInfo>().As<IFolderInfo>();
builder.RegisterType<PageInfo>().As<IPageInfo>();
builder.RegisterType<TaxonomyInfo>().As<ITaxonomyInfo>();
builder.RegisterType<TaxonomyMultiInfo>().As<ITaxonomyMultiInfo>();
builder.RegisterType<FolderMaker>().As<IFolderMaker>();
builder.RegisterType<PageCreator>();
// Taxonomy
builder.RegisterType<SiteTaxonomyCacheManager>().As<ISiteTaxonomyCacheManager>().SingleInstance();
builder.RegisterType<TaxonomyService>().As<ITaxonomyService>().InstancePerSite();
builder.RegisterType<TaxonomyHelper>();
// Timer Jobs
builder.RegisterType<TimerJobExpert>().As<ITimerJobExpert>();
// Utils
builder.RegisterType<EventReceiverHelper>();
builder.RegisterType<SearchHelper>();
builder.RegisterType<CustomActionHelper>();
builder.RegisterType<ContentOrganizerHelper>();
// Web config
builder.RegisterType<WebConfigModificationHelper>();
// Web Parts
builder.RegisterType<WebPartHelper>();
}
/// <summary>
/// Triggers ServiceLocator bootstrapping (scans the GAC for assemblies with a name
/// that matches *.ServiceLocator.DLL, by convention).
/// </summary>
/// <param name="web">The context's SPWeb. Keep null if none available.</param>
/// <param name="site">The context's SPSite. Keep null if none available.</param>
/// <param name="webApplication">The context's SPWebApplication. Keep null if none available.</param>
/// <param name="farm">The context's SPFarm. Keep null if none available.</param>
private void EnsureServiceLocatorAccessor(SPWeb web, SPSite site, SPWebApplication webApplication, SPFarm farm)
{
if (this.GetLocatorAccessor(web, site, webApplication, farm) == null)
{
lock (this.lockObject)
{
if (this.GetLocatorAccessor(web, site, webApplication, farm) == null)
{
try
{
// 1) Scan the GAC for any DLL matching the *.ServiceLocator.DLL pattern
var matchingAssemblies = GacAssemblyLocator.GetAssemblies(new List<string>() { "GAC_MSIL" }, assemblyFileName => assemblyFileName.Contains(".ServiceLocator"));
Assembly serviceLocatorAssembly = null;
Type accessorType = null;
if (matchingAssemblies.Any())
{
if (matchingAssemblies.Count > 1)
{
// 2) If more than one service locator is found, we must disambiguate. We have to use the
// contextual SPWeb, SPSite, SPWebApp or SPFarm objects and extract the preferred service
// locator assembly name setting from their property bag.
// The SPWeb's property bag is inspected first, if available, then the SPSite's RootWeb property
// bag, then the SPWebApp's, then the SPFarm's property bag as a last resort.
string contextObjectWhereDiscriminatorWasFound;
string serviceLocatorAssemblyNameDiscriminator = FindServiceLocatorAccessorTypeNameFromMostSpecificPropertyBag(web, site, webApplication, farm, out contextObjectWhereDiscriminatorWasFound);
string allServiceLocatorAssemblyNames = string.Join(";", matchingAssemblies.Select(locatorAssembly => locatorAssembly.FullName).ToArray());
string basicDisambiguationErrorMessage = string.Format(
CultureInfo.InvariantCulture,
"Failed to disambiguate between all DLLs in the GAC that match the *.ServiceLocator.DLL filename pattern. All matching assemblies in GAC: {0}.",
allServiceLocatorAssemblyNames);
if (!string.IsNullOrEmpty(serviceLocatorAssemblyNameDiscriminator))
{
// We found a ServiceLocator assembly name in one of the context's Property Bags.
serviceLocatorAssembly = matchingAssemblies.FirstOrDefault(assembly => assembly.FullName.Contains(serviceLocatorAssemblyNameDiscriminator));
if (serviceLocatorAssembly == null)
{
throw new InvalidOperationException(basicDisambiguationErrorMessage +
" The discriminator found in one of the context's Property Bags (value=" + serviceLocatorAssemblyNameDiscriminator +
", property bag location=" + contextObjectWhereDiscriminatorWasFound + ") did not match either of the " +
matchingAssemblies.Count + " ServiceLocator DLLs available in GAC. The discriminator value should match one of the DLLs so that we can determine which to use.");
}
}
else
{
// We failed to find a discriminator setting in all of the context's Property Bags
throw new InvalidOperationException(basicDisambiguationErrorMessage +
" You cannot begin injection from the root application container if more that one ServiceLocator assembly exists in the GAC." +
" You must begin injection with one of the following methods on your ISharePointServiceLocator: BeginLifetimeScope(SPFeature) or" +
" BeginLifetimeScope(SPWeb) or BeginLifetimeScope(SPSite) or BeginLifetimeScope(SPWebApplication) or BeginLifetimeScope(SPFarm)," +
" depending on your context. IMPORTANT: The property bags on the context' SPWeb, SPSite, SPWebApplication and SPFarm will be inspected" +
" (in that order) to find a value for the key '" + KeyServiceLocatorAssemblyName + "'. This discriminator value will indicate to Dynamite's" +
" AddOnProvidedServiceLocator which concrete add-on's ServiceLocator DLL to use in the current context.");
}
}
if (serviceLocatorAssembly != null)
{
// Only one matching assembly, find its accessor class
accessorType = FindServiceLocatorAccessorType(serviceLocatorAssembly);
}
else
{
// Only one ServiceLocator DLL found in GAC. There is no ambiguity: use this locator.
serviceLocatorAssembly = matchingAssemblies[0];
}
if (serviceLocatorAssembly != null)
{
// At this point we figured out the right matching assembly: find its accessor class within its types
accessorType = FindServiceLocatorAccessorType(serviceLocatorAssembly);
}
}
else
{
// Not even one DLL in GAC matches the *.ServiceLocator.DLL pattern
throw new InvalidOperationException("Failed to find any assembly in the GAC that matches the *.ServiceLocator.DLL pattern.");
}
if (accessorType != null)
{
// 3) Create the accessor instance
this.AddLocatorAccessor(web, site, webApplication, farm, (ISharePointServiceLocatorAccessor)Activator.CreateInstance(accessorType));
}
else
{
throw new InvalidOperationException("Failed to find implementation of ISharePointServiceLocatorAccessor for AddOnProvidedServiceLocator. Your ServiceLocator assembly (" + serviceLocatorAssembly.FullName + ") should expose its static container through that interface.");
}
}
catch (InvalidOperationException exception)
{
var logger = new TraceLogger("GSoft.Dynamite", "GSoft.Dynamite", false);
logger.Error(
"AddOnProvidedServiceLocator Initialization Error - An error occured while trying to find a DLL matching the pattern *ServiceLocator.dll in the GAC. The FallbackServiceLocator will be used instead as a last resort (no AddOn registration module will be registered). Exception: {0}",
exception.ToString());
// Either no assembly in the GAC matches the pattern *.ServiceLocator.DLL pattern,
// or in the matching assembly that was found, no class implements ISharePointServiceLocatorAccessor.
// In this case, use our default all-available-Dynamite-modules-only service locator
this.AddLocatorAccessor(web, site, webApplication, farm, new FallbackServiceLocator());
}
}
}
}
}
/// <summary>
/// Registers the modules type bindings
/// </summary>
/// <param name="builder">
/// The builder.
/// </param>
protected override void Load(ContainerBuilder builder)
{
// Logging
#if DEBUG
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, true); // Logger with debug output
builder.RegisterInstance<ILogger>(logger);
#else
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, false); // Logger without debug output
builder.RegisterInstance<ILogger>(logger);
#endif
// Binding
builder.RegisterType<EntitySchemaFactory>().Named<IEntitySchemaFactory>("decorated");
builder.RegisterDecorator<IEntitySchemaFactory>((c, inner) => new CachedEntitySchemaFactory(inner, c.Resolve<ILogger>()), fromKey: "decorated");
builder.RegisterType<SharePointEntityBinder>().As<ISharePointEntityBinder>().InstancePerSite(); // Singleton-per-site entity binder
builder.RegisterType<FieldValueWriter>().As<IFieldValueWriter>();
var writers = new[]
{
typeof(StringValueWriter),
typeof(BooleanValueWriter),
typeof(IntegerValueWriter),
typeof(DoubleValueWriter),
typeof(DateTimeValueWriter),
typeof(GuidValueWriter),
typeof(TaxonomyValueWriter),
typeof(TaxonomyValueCollectionWriter),
typeof(LookupValueWriter),
typeof(LookupValueCollectionWriter),
typeof(PrincipalValueWriter),
typeof(UserValueWriter),
typeof(UserValueCollectionWriter),
typeof(UrlValueWriter),
typeof(ImageValueWriter),
typeof(MediaValueWriter)
};
writers.ToList().ForEach(w => builder.RegisterType(w).As<IBaseValueWriter>().SingleInstance());
builder.RegisterType<FieldValueReader>().As<IFieldValueReader>();
var readers = new[]
{
typeof(StringValueReader),
typeof(BooleanValueReader),
typeof(IntegerValueReader),
typeof(DoubleValueReader),
typeof(DateTimeValueReader),
typeof(GuidValueReader),
typeof(TaxonomyValueReader),
typeof(TaxonomyValueCollectionReader),
typeof(LookupValueReader),
typeof(LookupValueCollectionReader),
typeof(PrincipalValueReader),
typeof(UserValueReader),
typeof(UserValueCollectionReader),
typeof(UrlValueReader),
typeof(ImageValueReader),
typeof(MediaValueReader)
};
readers.ToList().ForEach(r => builder.RegisterType(r).As<IBaseValueReader>().SingleInstance());
// Branding
builder.RegisterType<MasterPageHelper>().As<IMasterPageHelper>();
builder.RegisterType<ExtraMasterPageBodyCssClasses>().As<IExtraMasterPageBodyCssClasses>();
builder.RegisterType<ComposedLookRepository>().As<IComposedLookRepository>();
builder.RegisterType<DisplayTemplateHelper>().As<IDisplayTemplateHelper>();
builder.RegisterType<ImageRenditionHelper>().As<IImageRenditionHelper>();
// Cache
builder.RegisterType<CacheHelper>().As<ICacheHelper>();
// CAML query builder and utilities
builder.RegisterType<CamlBuilder>().As<ICamlBuilder>();
builder.RegisterType<CamlUtils>().As<ICamlUtils>();
builder.RegisterType<QueryHelper>().As<IQueryHelper>();
// Catalogs
builder.RegisterType<CatalogHelper>().As<ICatalogHelper>();
// Configuration
builder.RegisterType<PropertyBagHelper>().As<IPropertyBagHelper>();
builder.RegisterType<PropertyBagConfiguration>().As<IConfiguration>();
builder.RegisterType<WebConfigModificationHelper>().As<IWebConfigModificationHelper>();
// ContentTypes
builder.RegisterType<ContentTypeHelper>().As<IContentTypeHelper>();
// Documents
builder.RegisterType<ContentOrganizerHelper>().As<IContentOrganizerHelper>();
// Events
builder.RegisterType<EventReceiverHelper>().As<IEventReceiverHelper>();
// Fields
builder.RegisterType<FieldHelper>().As<IFieldHelper>();
builder.RegisterType<FieldLocator>().As<IFieldLocator>();
builder.RegisterType<FieldSchemaHelper>().As<IFieldSchemaHelper>();
builder.RegisterType<FieldLookupHelper>().As<IFieldLookupHelper>();
// Folders
builder.RegisterType<FolderHelper>().As<IFolderHelper>();
// Files
builder.RegisterType<FileHelper>().As<IFileHelper>();
// Globalization + Variations (with default en-CA as source + fr-CA as destination implementation)
builder.RegisterType<ResourceLocator>().As<IResourceLocator>();
// It's the container user's responsibility to register a IResourceLocatorConfig implementation
builder.RegisterType<DefaultResourceLocatorConfig>().As<IResourceLocatorConfig>();
builder.RegisterType<MuiHelper>().As<IMuiHelper>();
builder.RegisterType<VariationExpert>().As<IVariationExpert>();
builder.RegisterType<VariationHelper>().As<IVariationHelper>();
builder.RegisterType<VariationSyncHelper>().As<IVariationSyncHelper>();
// Lists
builder.RegisterType<ListHelper>().As<IListHelper>();
builder.RegisterType<ListLocator>().As<IListLocator>();
builder.RegisterType<ListSecurityHelper>().As<IListSecurityHelper>();
builder.RegisterType<PublishedLinksEditor>().As<IPublishedLinksEditor>();
// Monitoring
builder.RegisterType<AggregateTimeTracker>().As<IAggregateTimeTracker>().InstancePerSite();
// Navigation
builder.RegisterType<NavigationService>().As<INavigationService>();
builder.RegisterType<NavigationHelper>().As<INavigationHelper>();
builder.RegisterType<VariationNavigationHelper>().As<IVariationNavigationHelper>();
// Pages
builder.RegisterType<PageHelper>().As<IPageHelper>();
// Repositories
builder.RegisterType<ItemLocator>().As<IItemLocator>();
// Search
builder.RegisterType<SearchHelper>().As<ISearchHelper>();
builder.RegisterType<QueryRuleHelper>().As<IQueryRuleHelper>();
// Security
builder.RegisterType<SecurityHelper>().As<ISecurityHelper>();
builder.RegisterType<UserHelper>().As<IUserHelper>();
// Serializers
builder.RegisterType<XmlHelper>().As<IXmlHelper>();
builder.RegisterType<JsonNetSerializer>().As<ISerializer>().SingleInstance();
// Taxonomy
builder.RegisterType<PerRequestSiteTaxonomyCacheManager>().As<ISiteTaxonomyCacheManager>();
builder.RegisterType<TaxonomyService>().As<ITaxonomyService>();
//// Example of monitored (profiled) instance - a typical decorator pattern use case:
////builder.RegisterType<TaxonomyService>().Named<ITaxonomyService>("decorated").InstancePerSite();
////builder.RegisterDecorator<ITaxonomyService>((c, inner) => new MonitoredTaxonomyService(inner, c.Resolve<IAggregateTimeTracker>()), fromKey: "decorated");
builder.RegisterType<TaxonomyHelper>().As<ITaxonomyHelper>();
// Timer Jobs
builder.RegisterType<TimerJobHelper>().As<ITimerJobHelper>();
// Utils
builder.RegisterType<CustomActionHelper>().As<ICustomActionHelper>();
builder.RegisterType<CatchallExceptionHandler>().As<ICatchallExceptionHandler>();
// Web Parts
builder.RegisterType<WebPartHelper>().As<IWebPartHelper>();
// Features
builder.RegisterType<FeatureDependencyActivator>().As<IFeatureDependencyActivator>();
}
/// <summary>
/// Registers the modules type bindings
/// </summary>
/// <param name="container">The container on which to register type bindings</param>
public void Register(IUnityContainer container)
{
// Logging
#if DEBUG
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, true); // Logger with debug output
container.RegisterInstance<ILogger>(logger);
#else
var logger = new TraceLogger(this.logCategoryName, this.logCategoryName, false); // Logger without debug output
container.RegisterInstance<ILogger>(logger);
#endif
// Binding
var builder = new EntitySchemaBuilder<SharePointEntitySchema>();
var cachedBuilder = new CachedSchemaBuilder(builder, logger);
container.RegisterInstance<IEntitySchemaBuilder>(cachedBuilder);
container.RegisterType<TaxonomyValueConverter>();
container.RegisterType<TaxonomyValueCollectionConverter>();
container.RegisterType<ISharePointEntityBinder, SharePointEntityBinder>(new ContainerControlledLifetimeManager()); // Singleton entity binder
// Cache
container.RegisterType<ICacheHelper, CacheHelper>();
// Definitions
container.RegisterType<ContentTypeBuilder>();
container.RegisterType<FieldHelper>();
// Globalization + Variations (with default en-CA as source + fr-CA as destination implementation)
container.RegisterInstance<IResourceLocator>(new ResourceLocator(this.defaultResourceFileNames));
container.RegisterType<MuiHelper>();
container.RegisterType<DateHelper>();
container.RegisterType<RegionalSettingsHelper>();
container.RegisterType<IVariationDirector, DefaultVariationDirector>();
container.RegisterType<IVariationBuilder, CanadianEnglishAndFrenchVariationBuilder>();
container.RegisterType<IVariationExpert, VariationExpert>();
// Lists
container.RegisterType<ListHelper>();
container.RegisterType<ListSecurityHelper>();
// Master Pages
container.RegisterType<MasterPageHelper>();
container.RegisterType<IExtraMasterPageBodyCssClasses, ExtraMasterPageBodyCssClasses>();
// Repositories
container.RegisterType<FolderRepository>();
container.RegisterType<ListLocator>();
container.RegisterType<IQueryHelper, QueryHelper>();
// Security
container.RegisterType<SecurityHelper>();
container.RegisterType<UserHelper>();
// Setup
container.RegisterType<IFieldValueInfo, FieldValueInfo>();
container.RegisterType<IFolderInfo, FolderInfo>();
container.RegisterType<IPageInfo, PageInfo>();
container.RegisterType<ITaxonomyInfo, TaxonomyInfo>();
container.RegisterType<ITaxonomyMultiInfo, TaxonomyMultiInfo>();
container.RegisterType<IFolderMaker, FolderMaker>();
container.RegisterType<PageCreator>();
// Taxonomy
container.RegisterType<ISiteTaxonomyCacheManager, SiteTaxonomyCacheManager>();
container.RegisterType<ITaxonomyService, TaxonomyService>();
container.RegisterType<TaxonomyService>();
container.RegisterType<TaxonomyHelper>();
// Timer Jobs
container.RegisterType<ITimerJobExpert, TimerJobExpert>();
// Utilities
container.RegisterType<EventReceiverHelper>();
container.RegisterType<SearchHelper>();
container.RegisterType<CustomActionHelper>();
container.RegisterType<ContentOrganizerHelper>();
// Web config
container.RegisterType<WebConfigModificationHelper>();
// Web Parts
container.RegisterType<WebPartHelper>();
}
