yv01p/Umbraco-CMS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

NetCore: MSDI refactor remove IFactory & IRegister (#9308)

Browse Source 
* Replace IFactory with IServiceProvider

* Replace IRegister with IServiceCollection

* Fix Rte.cshtml so the view can service locate.

* Replace Composing Lifetime with MSDI ServiceLifetime

* Remove ServiceProvider AddMultipleUnique extension

* Remove Umbraco.Web.Composing.Current.Reset and any calls

* Remove LightInject from net framework projects

* Brought back a helper for setting MediaFileSystem underlying IFileSystem
This commit is contained in:
Paul Johnson
2020-10-30 11:16:17 +00:00
committed by GitHub
parent 82a0c50a98
commit 4ae329589a
137 changed files with 895 additions and 1394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Umbraco.Infrastructure/Cache/DistributedCacheBinderComposer.cs
View File

@@ -14,7 +14,7 @@ namespace Umbraco.Web.Cache
{
base.Compose(composition);
composition.RegisterUnique<IDistributedCacheBinder, DistributedCacheBinder>();
composition.Services.AddUnique<IDistributedCacheBinder, DistributedCacheBinder>();
}
}
}

3
src/Umbraco.Infrastructure/Compose/DatabaseServerRegistrarAndMessengerComponent.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Threading;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Umbraco.Core;
using Umbraco.Core.Composing;
@@ -35,7 +36,7 @@ namespace Umbraco.Web.Compose
public sealed class DatabaseServerRegistrarAndMessengerComposer : ComponentComposer<DatabaseServerRegistrarAndMessengerComponent>, ICoreComposer
{
public static DatabaseServerMessengerOptions GetDefaultOptions(IFactory factory)
public static DatabaseServerMessengerOptions GetDefaultOptions(IServiceProvider factory)
{
return new DatabaseServerMessengerOptions
{

2
src/Umbraco.Infrastructure/Compose/NotificationsComposer.cs
View File

@@ -10,7 +10,7 @@ namespace Umbraco.Web.Compose
{
base.Compose(composition);
composition.RegisterUnique<NotificationsComponent.Notifier>();
composition.Services.AddUnique<NotificationsComponent.Notifier>();
}
}
}

2
src/Umbraco.Infrastructure/Composing/CompositionExtensions/CoreMappingProfiles.cs
View File

@@ -15,7 +15,7 @@ namespace Umbraco.Core.Composing.CompositionExtensions
/// <returns></returns>
public static Composition ComposeCoreMappingProfiles(this Composition composition)
{
composition.RegisterUnique<UmbracoMapper>();
composition.Services.AddUnique<UmbracoMapper>();
composition.WithCollectionBuilder<MapDefinitionCollectionBuilder>()
.Add<IdentityMapDefinition>()

25
src/Umbraco.Infrastructure/Composing/CompositionExtensions/FileSystems.cs
View File

@@ -1,4 +1,5 @@
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Umbraco.Core.Configuration.Models;
using Umbraco.Core.Hosting;
@@ -14,10 +15,13 @@ namespace Umbraco.Core.Composing.CompositionExtensions
* HOW TO REPLACE THE MEDIA UNDERLYING FILESYSTEM
* ----------------------------------------------
*
* composition.RegisterUnique<IMediaFileSystem>(factoryMethod);
* Create an implementation of IFileSystem and register it as the underlying filesystem for
* MediaFileSystem with the following extension on composition.
*
* composition.RegisterUnique<IMediaFileSystem, TImplementation>();
* composition.SetMediaFileSystem(factory => FactoryMethodToReturnYourImplementation())
*
* Alternatively you can just register an Implementation of IMediaFileSystem, however the
* extension above ensures that your IFileSystem implementation is wrapped by the "ShadowWrapper".
*
* WHAT IS SHADOWING
* -----------------
@@ -27,7 +31,6 @@ namespace Umbraco.Core.Composing.CompositionExtensions
* compared to creating your own physical filesystem, ensures that your filesystem
* would participate into such transactions.
*
*
*/
public static Composition ComposeFileSystems(this Composition composition)
@@ -36,16 +39,15 @@ namespace Umbraco.Core.Composing.CompositionExtensions
// it needs to be registered (not only the interface) because it provides additional
// functionality eg for scoping, and is injected in the scope provider - whereas the
// interface is really for end-users to get access to filesystems.
composition.RegisterUnique(factory => factory.CreateInstance<Core.IO.FileSystems>(factory));
composition.Services.AddUnique(factory => factory.CreateInstance<Core.IO.FileSystems>(factory));
// register IFileSystems, which gives access too all filesystems
composition.RegisterUnique<IFileSystems>(factory => factory.GetRequiredService<Core.IO.FileSystems>());
composition.Services.AddUnique<IFileSystems>(factory => factory.GetRequiredService<Core.IO.FileSystems>());
// register the scheme for media paths
composition.RegisterUnique<IMediaPathScheme, UniqueMediaPathScheme>();
composition.Services.AddUnique<IMediaPathScheme, UniqueMediaPathScheme>();
// register the default IMediaFileSystem implementation
composition.RegisterUnique<IMediaFileSystem>(factory =>
composition.SetMediaFileSystem(factory =>
{
var ioHelper = factory.GetRequiredService<IIOHelper>();
var hostingEnvironment = factory.GetRequiredService<IHostingEnvironment>();
@@ -54,10 +56,7 @@ namespace Umbraco.Core.Composing.CompositionExtensions
var rootPath = hostingEnvironment.MapPathWebRoot(globalSettings.UmbracoMediaPath);
var rootUrl = hostingEnvironment.ToAbsolute(globalSettings.UmbracoMediaPath);
var inner = new PhysicalFileSystem(ioHelper, hostingEnvironment, logger, rootPath, rootUrl);
var fileSystems = factory.GetRequiredService<IO.FileSystems>();
return fileSystems.GetFileSystem<MediaFileSystem>(inner);
return new PhysicalFileSystem(ioHelper, hostingEnvironment, logger, rootPath, rootUrl);
});
return composition;

2
src/Umbraco.Infrastructure/Composing/CompositionExtensions/Installer.cs
View File

@@ -28,7 +28,7 @@ namespace Umbraco.Web.Composing.CompositionExtensions
composition.Services.AddScoped<InstallSetupStep,CompleteInstallStep>();
composition.Services.AddTransient<InstallStepCollection>();
composition.RegisterUnique<InstallHelper>();
composition.Services.AddUnique<InstallHelper>();
return composition;
}

78
src/Umbraco.Infrastructure/Composing/CompositionExtensions/Repositories.cs
View File

@@ -11,45 +11,45 @@ namespace Umbraco.Core.Composing.CompositionExtensions
public static Composition ComposeRepositories(this Composition composition)
{
// repositories
composition.RegisterUnique<IAuditRepository, AuditRepository>();
composition.RegisterUnique<IAuditEntryRepository, AuditEntryRepository>();
composition.RegisterUnique<IContentTypeRepository, ContentTypeRepository>();
composition.RegisterUnique<IDataTypeContainerRepository, DataTypeContainerRepository>();
composition.RegisterUnique<IDataTypeRepository, DataTypeRepository>();
composition.RegisterUnique<IDictionaryRepository, DictionaryRepository>();
composition.RegisterUnique<IDocumentBlueprintRepository, DocumentBlueprintRepository>();
composition.RegisterUnique<IDocumentRepository, DocumentRepository>();
composition.RegisterUnique<IDocumentTypeContainerRepository, DocumentTypeContainerRepository>();
composition.RegisterUnique<IDomainRepository, DomainRepository>();
composition.RegisterUnique<IEntityRepository, EntityRepository>();
composition.RegisterUnique<IExternalLoginRepository, ExternalLoginRepository>();
composition.RegisterUnique<ILanguageRepository, LanguageRepository>();
composition.RegisterUnique<IMacroRepository, MacroRepository>();
composition.RegisterUnique<IMediaRepository, MediaRepository>();
composition.RegisterUnique<IMediaTypeContainerRepository, MediaTypeContainerRepository>();
composition.RegisterUnique<IMediaTypeRepository, MediaTypeRepository>();
composition.RegisterUnique<IMemberGroupRepository, MemberGroupRepository>();
composition.RegisterUnique<IMemberRepository, MemberRepository>();
composition.RegisterUnique<IMemberTypeRepository, MemberTypeRepository>();
composition.RegisterUnique<INotificationsRepository, NotificationsRepository>();
composition.RegisterUnique<IPublicAccessRepository, PublicAccessRepository>();
composition.RegisterUnique<IRedirectUrlRepository, RedirectUrlRepository>();
composition.RegisterUnique<IRelationRepository, RelationRepository>();
composition.RegisterUnique<IRelationTypeRepository, RelationTypeRepository>();
composition.RegisterUnique<IServerRegistrationRepository, ServerRegistrationRepository>();
composition.RegisterUnique<ITagRepository, TagRepository>();
composition.RegisterUnique<ITemplateRepository, TemplateRepository>();
composition.RegisterUnique<IUserGroupRepository, UserGroupRepository>();
composition.RegisterUnique<IUserRepository, UserRepository>();
composition.RegisterUnique<IConsentRepository, ConsentRepository>();
composition.RegisterUnique<IPartialViewMacroRepository, PartialViewMacroRepository>();
composition.RegisterUnique<IPartialViewRepository, PartialViewRepository>();
composition.RegisterUnique<IScriptRepository, ScriptRepository>();
composition.RegisterUnique<IStylesheetRepository, StylesheetRepository>();
composition.RegisterUnique<IContentTypeCommonRepository, ContentTypeCommonRepository>();
composition.RegisterUnique<IKeyValueRepository, KeyValueRepository>();
composition.RegisterUnique<IInstallationRepository, InstallationRepository>();
composition.RegisterUnique<IUpgradeCheckRepository, UpgradeCheckRepository>();
composition.Services.AddUnique<IAuditRepository, AuditRepository>();
composition.Services.AddUnique<IAuditEntryRepository, AuditEntryRepository>();
composition.Services.AddUnique<IContentTypeRepository, ContentTypeRepository>();
composition.Services.AddUnique<IDataTypeContainerRepository, DataTypeContainerRepository>();
composition.Services.AddUnique<IDataTypeRepository, DataTypeRepository>();
composition.Services.AddUnique<IDictionaryRepository, DictionaryRepository>();
composition.Services.AddUnique<IDocumentBlueprintRepository, DocumentBlueprintRepository>();
composition.Services.AddUnique<IDocumentRepository, DocumentRepository>();
composition.Services.AddUnique<IDocumentTypeContainerRepository, DocumentTypeContainerRepository>();
composition.Services.AddUnique<IDomainRepository, DomainRepository>();
composition.Services.AddUnique<IEntityRepository, EntityRepository>();
composition.Services.AddUnique<IExternalLoginRepository, ExternalLoginRepository>();
composition.Services.AddUnique<ILanguageRepository, LanguageRepository>();
composition.Services.AddUnique<IMacroRepository, MacroRepository>();
composition.Services.AddUnique<IMediaRepository, MediaRepository>();
composition.Services.AddUnique<IMediaTypeContainerRepository, MediaTypeContainerRepository>();
composition.Services.AddUnique<IMediaTypeRepository, MediaTypeRepository>();
composition.Services.AddUnique<IMemberGroupRepository, MemberGroupRepository>();
composition.Services.AddUnique<IMemberRepository, MemberRepository>();
composition.Services.AddUnique<IMemberTypeRepository, MemberTypeRepository>();
composition.Services.AddUnique<INotificationsRepository, NotificationsRepository>();
composition.Services.AddUnique<IPublicAccessRepository, PublicAccessRepository>();
composition.Services.AddUnique<IRedirectUrlRepository, RedirectUrlRepository>();
composition.Services.AddUnique<IRelationRepository, RelationRepository>();
composition.Services.AddUnique<IRelationTypeRepository, RelationTypeRepository>();
composition.Services.AddUnique<IServerRegistrationRepository, ServerRegistrationRepository>();
composition.Services.AddUnique<ITagRepository, TagRepository>();
composition.Services.AddUnique<ITemplateRepository, TemplateRepository>();
composition.Services.AddUnique<IUserGroupRepository, UserGroupRepository>();
composition.Services.AddUnique<IUserRepository, UserRepository>();
composition.Services.AddUnique<IConsentRepository, ConsentRepository>();
composition.Services.AddUnique<IPartialViewMacroRepository, PartialViewMacroRepository>();
composition.Services.AddUnique<IPartialViewRepository, PartialViewRepository>();
composition.Services.AddUnique<IScriptRepository, ScriptRepository>();
composition.Services.AddUnique<IStylesheetRepository, StylesheetRepository>();
composition.Services.AddUnique<IContentTypeCommonRepository, ContentTypeCommonRepository>();
composition.Services.AddUnique<IKeyValueRepository, KeyValueRepository>();
composition.Services.AddUnique<IInstallationRepository, InstallationRepository>();
composition.Services.AddUnique<IUpgradeCheckRepository, UpgradeCheckRepository>();
return composition;
}

87
src/Umbraco.Infrastructure/Composing/CompositionExtensions/Services.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using System.Linq;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Logging;
using Umbraco.Core.Cache;
@@ -22,58 +23,58 @@ namespace Umbraco.Core.Composing.CompositionExtensions
{
// register a transient messages factory, which will be replaced by the web
// boot manager when running in a web context
composition.RegisterUnique<IEventMessagesFactory, TransientEventMessagesFactory>();
composition.Services.AddUnique<IEventMessagesFactory, TransientEventMessagesFactory>();
// register the service context
composition.RegisterUnique<ServiceContext>();
composition.Services.AddUnique<ServiceContext>();
// register the special idk map
composition.RegisterUnique<IIdKeyMap, IdKeyMap>();
composition.Services.AddUnique<IIdKeyMap, IdKeyMap>();
// register the services
composition.RegisterUnique<IPropertyValidationService, PropertyValidationService>();
composition.RegisterUnique<IKeyValueService, KeyValueService>();
composition.RegisterUnique<IPublicAccessService, PublicAccessService>();
composition.RegisterUnique<IDomainService, DomainService>();
composition.RegisterUnique<IAuditService, AuditService>();
composition.RegisterUnique<ITagService, TagService>();
composition.RegisterUnique<IContentService, ContentService>();
composition.RegisterUnique<IUserService, UserService>();
composition.RegisterUnique<IMemberService, MemberService>();
composition.RegisterUnique<IMediaService, MediaService>();
composition.RegisterUnique<IContentTypeService, ContentTypeService>();
composition.RegisterUnique<IContentTypeBaseServiceProvider, ContentTypeBaseServiceProvider>();
composition.RegisterUnique<IMediaTypeService, MediaTypeService>();
composition.RegisterUnique<IDataTypeService, DataTypeService>();
composition.RegisterUnique<IFileService, FileService>();
composition.RegisterUnique<ILocalizationService, LocalizationService>();
composition.RegisterUnique<IPackagingService, PackagingService>();
composition.RegisterUnique<IServerRegistrationService, ServerRegistrationService>();
composition.RegisterUnique<IEntityService, EntityService>();
composition.RegisterUnique<IRelationService, RelationService>();
composition.RegisterUnique<IMacroService, MacroService>();
composition.RegisterUnique<IMemberTypeService, MemberTypeService>();
composition.RegisterUnique<IMemberGroupService, MemberGroupService>();
composition.RegisterUnique<INotificationService, NotificationService>();
composition.RegisterUnique<IExternalLoginService, ExternalLoginService>();
composition.RegisterUnique<IRedirectUrlService, RedirectUrlService>();
composition.RegisterUnique<IConsentService, ConsentService>();
composition.Register<LocalizedTextServiceFileSources>(SourcesFactory);
composition.RegisterUnique<ILocalizedTextService>(factory => new LocalizedTextService(
composition.Services.AddUnique<IPropertyValidationService, PropertyValidationService>();
composition.Services.AddUnique<IKeyValueService, KeyValueService>();
composition.Services.AddUnique<IPublicAccessService, PublicAccessService>();
composition.Services.AddUnique<IDomainService, DomainService>();
composition.Services.AddUnique<IAuditService, AuditService>();
composition.Services.AddUnique<ITagService, TagService>();
composition.Services.AddUnique<IContentService, ContentService>();
composition.Services.AddUnique<IUserService, UserService>();
composition.Services.AddUnique<IMemberService, MemberService>();
composition.Services.AddUnique<IMediaService, MediaService>();
composition.Services.AddUnique<IContentTypeService, ContentTypeService>();
composition.Services.AddUnique<IContentTypeBaseServiceProvider, ContentTypeBaseServiceProvider>();
composition.Services.AddUnique<IMediaTypeService, MediaTypeService>();
composition.Services.AddUnique<IDataTypeService, DataTypeService>();
composition.Services.AddUnique<IFileService, FileService>();
composition.Services.AddUnique<ILocalizationService, LocalizationService>();
composition.Services.AddUnique<IPackagingService, PackagingService>();
composition.Services.AddUnique<IServerRegistrationService, ServerRegistrationService>();
composition.Services.AddUnique<IEntityService, EntityService>();
composition.Services.AddUnique<IRelationService, RelationService>();
composition.Services.AddUnique<IMacroService, MacroService>();
composition.Services.AddUnique<IMemberTypeService, MemberTypeService>();
composition.Services.AddUnique<IMemberGroupService, MemberGroupService>();
composition.Services.AddUnique<INotificationService, NotificationService>();
composition.Services.AddUnique<IExternalLoginService, ExternalLoginService>();
composition.Services.AddUnique<IRedirectUrlService, RedirectUrlService>();
composition.Services.AddUnique<IConsentService, ConsentService>();
composition.Services.AddTransient<LocalizedTextServiceFileSources>(SourcesFactory);
composition.Services.AddUnique<ILocalizedTextService>(factory => new LocalizedTextService(
factory.GetRequiredService<Lazy<LocalizedTextServiceFileSources>>(),
factory.GetRequiredService<ILogger<LocalizedTextService>>()));
composition.RegisterUnique<IEntityXmlSerializer, EntityXmlSerializer>();
composition.Services.AddUnique<IEntityXmlSerializer, EntityXmlSerializer>();
composition.RegisterUnique<IPackageActionRunner, PackageActionRunner>();
composition.Services.AddUnique<IPackageActionRunner, PackageActionRunner>();
composition.RegisterUnique<ConflictingPackageData>();
composition.RegisterUnique<CompiledPackageXmlParser>();
composition.RegisterUnique<ICreatedPackagesRepository>(factory => CreatePackageRepository(factory, "createdPackages.config"));
composition.RegisterUnique<IInstalledPackagesRepository>(factory => CreatePackageRepository(factory, "installedPackages.config"));
composition.RegisterUnique<PackageDataInstallation>();
composition.RegisterUnique<PackageFileInstallation>();
composition.RegisterUnique<IPackageInstallation, PackageInstallation>();
composition.Services.AddUnique<ConflictingPackageData>();
composition.Services.AddUnique<CompiledPackageXmlParser>();
composition.Services.AddUnique<ICreatedPackagesRepository>(factory => CreatePackageRepository(factory, "createdPackages.config"));
composition.Services.AddUnique<IInstalledPackagesRepository>(factory => CreatePackageRepository(factory, "installedPackages.config"));
composition.Services.AddUnique<PackageDataInstallation>();
composition.Services.AddUnique<PackageFileInstallation>();
composition.Services.AddUnique<IPackageInstallation, PackageInstallation>();
return composition;
}
@@ -84,7 +85,7 @@ namespace Umbraco.Core.Composing.CompositionExtensions
/// <param name="factory"></param>
/// <param name="packageRepoFileName"></param>
/// <returns></returns>
private static PackagesRepository CreatePackageRepository(IFactory factory, string packageRepoFileName)
private static PackagesRepository CreatePackageRepository(IServiceProvider factory, string packageRepoFileName)
=> new PackagesRepository(
factory.GetRequiredService<IContentService>(),
factory.GetRequiredService<IContentTypeService>(),
@@ -99,7 +100,7 @@ namespace Umbraco.Core.Composing.CompositionExtensions
factory.GetRequiredService<IOptions<GlobalSettings>>(),
packageRepoFileName);
private static LocalizedTextServiceFileSources SourcesFactory(IFactory container)
private static LocalizedTextServiceFileSources SourcesFactory(IServiceProvider container)
{
var hostingEnvironment = container.GetRequiredService<IHostingEnvironment>();
var globalSettings = container.GetRequiredService<IOptions<GlobalSettings>>().Value;

82
src/Umbraco.Infrastructure/CompositionExtensions.cs
View File

@@ -1,4 +1,5 @@
using System;
using Microsoft.Extensions.DependencyInjection;
using Umbraco.Core.Cache;
using Umbraco.Core.Composing;
using Umbraco.Core.Dictionary;
@@ -111,9 +112,9 @@ namespace Umbraco.Core
/// <typeparam name="T">The type of the factory.</typeparam>
/// <param name="composition">The composition.</param>
public static void SetCultureDictionaryFactory<T>(this Composition composition)
where T : ICultureDictionaryFactory
where T : class, ICultureDictionaryFactory
{
composition.RegisterUnique<ICultureDictionaryFactory, T>();
composition.Services.AddUnique<ICultureDictionaryFactory, T>();
}
/// <summary>
@@ -121,9 +122,9 @@ namespace Umbraco.Core
/// </summary>
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating a culture dictionary factory.</param>
public static void SetCultureDictionaryFactory(this Composition composition, Func<IFactory, ICultureDictionaryFactory> factory)
public static void SetCultureDictionaryFactory(this Composition composition, Func<IServiceProvider, ICultureDictionaryFactory> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -133,7 +134,7 @@ namespace Umbraco.Core
/// <param name="factory">A factory.</param>
public static void SetCultureDictionaryFactory(this Composition composition, ICultureDictionaryFactory factory)
{
composition.RegisterUnique(_ => factory);
composition.Services.AddUnique(_ => factory);
}
/// <summary>
@@ -142,9 +143,9 @@ namespace Umbraco.Core
/// <typeparam name="T">The type of the factory.</typeparam>
/// <param name="composition">The composition.</param>
public static void SetPublishedContentModelFactory<T>(this Composition composition)
where T : IPublishedModelFactory
where T : class, IPublishedModelFactory
{
composition.RegisterUnique<IPublishedModelFactory, T>();
composition.Services.AddUnique<IPublishedModelFactory, T>();
}
/// <summary>
@@ -152,9 +153,9 @@ namespace Umbraco.Core
/// </summary>
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating a published content model factory.</param>
public static void SetPublishedContentModelFactory(this Composition composition, Func<IFactory, IPublishedModelFactory> factory)
public static void SetPublishedContentModelFactory(this Composition composition, Func<IServiceProvider, IPublishedModelFactory> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -164,7 +165,7 @@ namespace Umbraco.Core
/// <param name="factory">A published content model factory.</param>
public static void SetPublishedContentModelFactory(this Composition composition, IPublishedModelFactory factory)
{
composition.RegisterUnique(_ => factory);
composition.Services.AddUnique(_ => factory);
}
/// <summary>
@@ -173,9 +174,9 @@ namespace Umbraco.Core
/// <typeparam name="T">The type of the server registrar.</typeparam>
/// <param name="composition">The composition.</param>
public static void SetServerRegistrar<T>(this Composition composition)
where T : IServerRegistrar
where T : class, IServerRegistrar
{
composition.RegisterUnique<IServerRegistrar, T>();
composition.Services.AddUnique<IServerRegistrar, T>();
}
/// <summary>
@@ -183,9 +184,9 @@ namespace Umbraco.Core
/// </summary>
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating a server registrar.</param>
public static void SetServerRegistrar(this Composition composition, Func<IFactory, IServerRegistrar> factory)
public static void SetServerRegistrar(this Composition composition, Func<IServiceProvider, IServerRegistrar> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -195,7 +196,7 @@ namespace Umbraco.Core
/// <param name="registrar">A server registrar.</param>
public static void SetServerRegistrar(this Composition composition, IServerRegistrar registrar)
{
composition.RegisterUnique(_ => registrar);
composition.Services.AddUnique(_ => registrar);
}
/// <summary>
@@ -204,9 +205,9 @@ namespace Umbraco.Core
/// <typeparam name="T">The type of the server registrar.</typeparam>
/// <param name="composition">The composition.</param>
public static void SetServerMessenger<T>(this Composition composition)
where T : IServerMessenger
where T : class, IServerMessenger
{
composition.RegisterUnique<IServerMessenger, T>();
composition.Services.AddUnique<IServerMessenger, T>();
}
/// <summary>
@@ -214,9 +215,9 @@ namespace Umbraco.Core
/// </summary>
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating a server messenger.</param>
public static void SetServerMessenger(this Composition composition, Func<IFactory, IServerMessenger> factory)
public static void SetServerMessenger(this Composition composition, Func<IServiceProvider, IServerMessenger> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -226,7 +227,7 @@ namespace Umbraco.Core
/// <param name="registrar">A server messenger.</param>
public static void SetServerMessenger(this Composition composition, IServerMessenger registrar)
{
composition.RegisterUnique(_ => registrar);
composition.Services.AddUnique(_ => registrar);
}
/// <summary>
@@ -235,9 +236,9 @@ namespace Umbraco.Core
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating the options.</param>
/// <remarks>Use DatabaseServerRegistrarAndMessengerComposer.GetDefaultOptions to get the options that Umbraco would use by default.</remarks>
public static void SetDatabaseServerMessengerOptions(this Composition composition, Func<IFactory, DatabaseServerMessengerOptions> factory)
public static void SetDatabaseServerMessengerOptions(this Composition composition, Func<IServiceProvider, DatabaseServerMessengerOptions> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -248,7 +249,7 @@ namespace Umbraco.Core
/// <remarks>Use DatabaseServerRegistrarAndMessengerComposer.GetDefaultOptions to get the options that Umbraco would use by default.</remarks>
public static void SetDatabaseServerMessengerOptions(this Composition composition, DatabaseServerMessengerOptions options)
{
composition.RegisterUnique(_ => options);
composition.Services.AddUnique(_ => options);
}
/// <summary>
@@ -257,9 +258,9 @@ namespace Umbraco.Core
/// <typeparam name="T">The type of the short string helper.</typeparam>
/// <param name="composition">The composition.</param>
public static void SetShortStringHelper<T>(this Composition composition)
where T : IShortStringHelper
where T : class, IShortStringHelper
{
composition.RegisterUnique<IShortStringHelper, T>();
composition.Services.AddUnique<IShortStringHelper, T>();
}
/// <summary>
@@ -267,9 +268,9 @@ namespace Umbraco.Core
/// </summary>
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating a short string helper.</param>
public static void SetShortStringHelper(this Composition composition, Func<IFactory, IShortStringHelper> factory)
public static void SetShortStringHelper(this Composition composition, Func<IServiceProvider, IShortStringHelper> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -279,18 +280,33 @@ namespace Umbraco.Core
/// <param name="helper">A short string helper.</param>
public static void SetShortStringHelper(this Composition composition, IShortStringHelper helper)
{
composition.RegisterUnique(_ => helper);
composition.Services.AddUnique(_ => helper);
}
/// <summary>
/// Sets the underlying media filesystem.
/// </summary>
/// <param name="composition">A composition.</param>
/// <param name="filesystemFactory">A filesystem factory.</param>
/// <remarks>
/// Using this helper will ensure that your IFileSystem implementation is wrapped by the ShadowWrapper
/// </remarks>
public static void SetMediaFileSystem(this Composition composition, Func<IServiceProvider, IFileSystem> filesystemFactory)
=> composition.Services.AddUnique<IMediaFileSystem>(factory =>
{
var fileSystems = factory.GetRequiredService<IO.FileSystems>();
return fileSystems.GetFileSystem<MediaFileSystem>(filesystemFactory(factory));
});
/// <summary>
/// Sets the log viewer.
/// </summary>
/// <typeparam name="T">The type of the log viewer.</typeparam>
/// <param name="composition">The composition.</param>
public static void SetLogViewer<T>(this Composition composition)
where T : ILogViewer
where T : class, ILogViewer
{
composition.RegisterUnique<ILogViewer, T>();
composition.Services.AddUnique<ILogViewer, T>();
}
/// <summary>
@@ -298,9 +314,9 @@ namespace Umbraco.Core
/// </summary>
/// <param name="composition">The composition.</param>
/// <param name="factory">A function creating a log viewer.</param>
public static void SetLogViewer(this Composition composition, Func<IFactory, ILogViewer> factory)
public static void SetLogViewer(this Composition composition, Func<IServiceProvider, ILogViewer> factory)
{
composition.RegisterUnique(factory);
composition.Services.AddUnique(factory);
}
/// <summary>
@@ -310,7 +326,7 @@ namespace Umbraco.Core
/// <param name="helper">A log viewer.</param>
public static void SetLogViewer(this Composition composition, ILogViewer viewer)
{
composition.RegisterUnique(_ => viewer);
composition.Services.AddUnique(_ => viewer);
}
#endregion

39
src/Umbraco.Infrastructure/CompositionExtensions_Essentials.cs
View File

@@ -1,4 +1,5 @@
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Umbraco.Core.Cache;
using Umbraco.Core.Composing;
using Umbraco.Core.Configuration;
@@ -38,24 +39,24 @@ namespace Umbraco.Core
IHostingEnvironment hostingEnvironment,
IBackOfficeInfo backOfficeInfo)
{
composition.RegisterUnique(logger);
composition.RegisterUnique(loggerFactory);
composition.RegisterUnique(profiler);
composition.RegisterUnique(profilingLogger);
composition.RegisterUnique(mainDom);
composition.RegisterUnique(appCaches);
composition.RegisterUnique(appCaches.RequestCache);
composition.RegisterUnique(databaseFactory);
composition.RegisterUnique(factory => factory.GetRequiredService<IUmbracoDatabaseFactory>().SqlContext);
composition.RegisterUnique(typeLoader);
composition.RegisterUnique(state);
composition.RegisterUnique(typeFinder);
composition.RegisterUnique(ioHelper);
composition.RegisterUnique(umbracoVersion);
composition.RegisterUnique(dbProviderFactoryCreator);
composition.RegisterUnique(factory => factory.GetRequiredService<IUmbracoDatabaseFactory>().BulkSqlInsertProvider);
composition.RegisterUnique(hostingEnvironment);
composition.RegisterUnique(backOfficeInfo);
composition.Services.AddUnique(logger);
composition.Services.AddUnique(loggerFactory);
composition.Services.AddUnique(profiler);
composition.Services.AddUnique(profilingLogger);
composition.Services.AddUnique(mainDom);
composition.Services.AddUnique(appCaches);
composition.Services.AddUnique(appCaches.RequestCache);
composition.Services.AddUnique(databaseFactory);
composition.Services.AddUnique(factory => factory.GetRequiredService<IUmbracoDatabaseFactory>().SqlContext);
composition.Services.AddUnique(typeLoader);
composition.Services.AddUnique(state);
composition.Services.AddUnique(typeFinder);
composition.Services.AddUnique(ioHelper);
composition.Services.AddUnique(umbracoVersion);
composition.Services.AddUnique(dbProviderFactoryCreator);
composition.Services.AddUnique(factory => factory.GetRequiredService<IUmbracoDatabaseFactory>().BulkSqlInsertProvider);
composition.Services.AddUnique(hostingEnvironment);
composition.Services.AddUnique(backOfficeInfo);
}
}
}

8
src/Umbraco.Infrastructure/Logging/Serilog/SerilogComposer.cs
View File

@@ -12,10 +12,10 @@ namespace Umbraco.Infrastructure.Logging.Serilog
{
public void Compose(Composition composition)
{
composition.RegisterUnique<ThreadAbortExceptionEnricher>();
composition.RegisterUnique<HttpSessionIdEnricher>();
composition.RegisterUnique<HttpRequestNumberEnricher>();
composition.RegisterUnique<HttpRequestIdEnricher>();
composition.Services.AddUnique<ThreadAbortExceptionEnricher>();
composition.Services.AddUnique<HttpSessionIdEnricher>();
composition.Services.AddUnique<HttpRequestNumberEnricher>();
composition.Services.AddUnique<HttpRequestIdEnricher>();
}
}
}

5
src/Umbraco.Infrastructure/Logging/Viewer/LogViewerComposer.cs
View File

@@ -1,4 +1,5 @@
using System.IO;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Serilog;
using Umbraco.Core.Composing;
@@ -12,9 +13,9 @@ namespace Umbraco.Core.Logging.Viewer
{
public void Compose(Composition composition)
{
composition.RegisterUnique<ILogViewerConfig, LogViewerConfig>();
composition.Services.AddUnique<ILogViewerConfig, LogViewerConfig>();
composition.SetLogViewer<SerilogJsonLogViewer>();
composition.RegisterUnique<ILogViewer>(factory =>
composition.Services.AddUnique<ILogViewer>(factory =>
{
return new SerilogJsonLogViewer(factory.GetRequiredService<ILogger<SerilogJsonLogViewer>>(),

4
src/Umbraco.Infrastructure/Migrations/MigrationBuilder.cs
View File

@@ -5,9 +5,9 @@ namespace Umbraco.Core.Migrations
{
public class MigrationBuilder : IMigrationBuilder
{
private readonly IFactory _container;
private readonly IServiceProvider _container;
public MigrationBuilder(IFactory container)
public MigrationBuilder(IServiceProvider container)
{
_container = container;
}

9
src/Umbraco.Infrastructure/Persistence/Mappers/MapperCollectionBuilder.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Concurrent;
using Microsoft.Extensions.DependencyInjection;
using Umbraco.Core.Composing;
using Umbraco.Infrastructure.Persistence.Mappers;
@@ -9,9 +10,9 @@ namespace Umbraco.Core.Persistence.Mappers
{
protected override MapperCollectionBuilder This => this;
public override void RegisterWith(IRegister register)
public override void RegisterWith(IServiceCollection services)
{
base.RegisterWith(register);
base.RegisterWith(services);
// default initializer registers
// - service MapperCollectionBuilder, returns MapperCollectionBuilder
@@ -19,8 +20,8 @@ namespace Umbraco.Core.Persistence.Mappers
// we want to register extra
// - service IMapperCollection, returns MappersCollectionBuilder's collection
register.Register<MapperConfigurationStore>(Lifetime.Singleton);
register.Register<IMapperCollection>(factory => factory.GetRequiredService<MapperCollection>());
services.AddSingleton<MapperConfigurationStore>();
services.AddSingleton<IMapperCollection>(factory => factory.GetRequiredService<MapperCollection>());
}
public MapperCollectionBuilder AddCoreMappers()

120
src/Umbraco.Infrastructure/Runtime/CoreInitialComposer.cs
View File

@@ -86,20 +86,20 @@ namespace Umbraco.Core.Runtime
composition.Mappers().AddCoreMappers();
// register the scope provider
composition.RegisterUnique<ScopeProvider>(); // implements both IScopeProvider and IScopeAccessor
composition.RegisterUnique<IScopeProvider>(f => f.GetRequiredService<ScopeProvider>());
composition.RegisterUnique<IScopeAccessor>(f => f.GetRequiredService<ScopeProvider>());
composition.Services.AddUnique<ScopeProvider>(); // implements both IScopeProvider and IScopeAccessor
composition.Services.AddUnique<IScopeProvider>(f => f.GetRequiredService<ScopeProvider>());
composition.Services.AddUnique<IScopeAccessor>(f => f.GetRequiredService<ScopeProvider>());
composition.RegisterUnique<IJsonSerializer, JsonNetSerializer>();
composition.RegisterUnique<IMenuItemCollectionFactory, MenuItemCollectionFactory>();
composition.RegisterUnique<InstallStatusTracker>();
composition.Services.AddUnique<IJsonSerializer, JsonNetSerializer>();
composition.Services.AddUnique<IMenuItemCollectionFactory, MenuItemCollectionFactory>();
composition.Services.AddUnique<InstallStatusTracker>();
// register database builder
// *not* a singleton, don't want to keep it around
composition.Services.AddTransient<DatabaseBuilder>();
// register manifest parser, will be injected in collection builders where needed
composition.RegisterUnique<IManifestParser, ManifestParser>();
composition.Services.AddUnique<IManifestParser, ManifestParser>();
// register our predefined validators
composition.ManifestValueValidators()
@@ -121,15 +121,15 @@ namespace Umbraco.Core.Runtime
.Add<FileUploadPropertyEditor>()
.Add<ImageCropperPropertyEditor>();
composition.RegisterUnique<PropertyEditorCollection>();
composition.RegisterUnique<ParameterEditorCollection>();
composition.Services.AddUnique<PropertyEditorCollection>();
composition.Services.AddUnique<ParameterEditorCollection>();
// Used to determine if a datatype/editor should be storing/tracking
// references to media item/s
composition.DataValueReferenceFactories();
// register a server registrar, by default it's the db registrar
composition.RegisterUnique<IServerRegistrar>(f =>
composition.Services.AddUnique<IServerRegistrar>(f =>
{
var globalSettings = f.GetRequiredService<IOptions<GlobalSettings>>().Value;
@@ -146,7 +146,7 @@ namespace Umbraco.Core.Runtime
// by default we'll use the database server messenger with default options (no callbacks),
// this will be overridden by the db thing in the corresponding components in the web
// project
composition.RegisterUnique<IServerMessenger>(factory
composition.Services.AddUnique<IServerMessenger>(factory
=> new DatabaseServerMessenger(
factory.GetRequiredService<IMainDom>(),
factory.GetRequiredService<IScopeProvider>(),
@@ -168,56 +168,56 @@ namespace Umbraco.Core.Runtime
composition.PropertyValueConverters()
.Append(composition.TypeLoader.GetTypes<IPropertyValueConverter>());
composition.RegisterUnique<IPublishedContentTypeFactory, PublishedContentTypeFactory>();
composition.Services.AddUnique<IPublishedContentTypeFactory, PublishedContentTypeFactory>();
composition.RegisterUnique<IShortStringHelper>(factory
composition.Services.AddUnique<IShortStringHelper>(factory
=> new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(factory.GetRequiredService<IOptions<RequestHandlerSettings>>().Value)));
composition.UrlSegmentProviders()
.Append<DefaultUrlSegmentProvider>();
composition.RegisterUnique<IMigrationBuilder>(factory => new MigrationBuilder(factory));
composition.Services.AddUnique<IMigrationBuilder>(factory => new MigrationBuilder(factory));
// by default, register a noop factory
composition.RegisterUnique<IPublishedModelFactory, NoopPublishedModelFactory>();
composition.Services.AddUnique<IPublishedModelFactory, NoopPublishedModelFactory>();
// by default
composition.RegisterUnique<IPublishedSnapshotRebuilder, PublishedSnapshotRebuilder>();
composition.Services.AddUnique<IPublishedSnapshotRebuilder, PublishedSnapshotRebuilder>();
composition.SetCultureDictionaryFactory<DefaultCultureDictionaryFactory>();
composition.Register(f => f.GetRequiredService<ICultureDictionaryFactory>().CreateDictionary(), Lifetime.Singleton);
composition.RegisterUnique<UriUtility>();
composition.Services.AddSingleton(f => f.GetRequiredService<ICultureDictionaryFactory>().CreateDictionary());
composition.Services.AddUnique<UriUtility>();
// register the published snapshot accessor - the "current" published snapshot is in the umbraco context
composition.RegisterUnique<IPublishedSnapshotAccessor, UmbracoContextPublishedSnapshotAccessor>();
composition.Services.AddUnique<IPublishedSnapshotAccessor, UmbracoContextPublishedSnapshotAccessor>();
composition.RegisterUnique<IVariationContextAccessor, HybridVariationContextAccessor>();
composition.Services.AddUnique<IVariationContextAccessor, HybridVariationContextAccessor>();
composition.RegisterUnique<IDashboardService, DashboardService>();
composition.Services.AddUnique<IDashboardService, DashboardService>();
// register core CMS dashboards and 3rd party types - will be ordered by weight attribute & merged with package.manifest dashboards
composition.Dashboards()
.Add(composition.TypeLoader.GetTypes<IDashboard>());
// will be injected in controllers when needed to invoke rest endpoints on Our
composition.RegisterUnique<IInstallationService, InstallationService>();
composition.RegisterUnique<IUpgradeService, UpgradeService>();
composition.Services.AddUnique<IInstallationService, InstallationService>();
composition.Services.AddUnique<IUpgradeService, UpgradeService>();
// Grid config is not a real config file as we know them
composition.RegisterUnique<IGridConfig, GridConfig>();
composition.Services.AddUnique<IGridConfig, GridConfig>();
// Config manipulator
composition.RegisterUnique<IConfigManipulator, JsonConfigManipulator>();
composition.Services.AddUnique<IConfigManipulator, JsonConfigManipulator>();
// register the umbraco context factory
// composition.RegisterUnique<IUmbracoContextFactory, UmbracoContextFactory>();
composition.RegisterUnique<IPublishedUrlProvider, UrlProvider>();
// composition.Services.AddUnique<IUmbracoContextFactory, UmbracoContextFactory>();
composition.Services.AddUnique<IPublishedUrlProvider, UrlProvider>();
composition.RegisterUnique<HtmlLocalLinkParser>();
composition.RegisterUnique<HtmlImageSourceParser>();
composition.RegisterUnique<HtmlUrlParser>();
composition.RegisterUnique<RichTextEditorPastedImages>();
composition.RegisterUnique<BlockEditorConverter>();
composition.Services.AddUnique<HtmlLocalLinkParser>();
composition.Services.AddUnique<HtmlImageSourceParser>();
composition.Services.AddUnique<HtmlUrlParser>();
composition.Services.AddUnique<RichTextEditorPastedImages>();
composition.Services.AddUnique<BlockEditorConverter>();
// both TinyMceValueConverter (in Core) and RteMacroRenderingValueConverter (in Web) will be
// discovered when CoreBootManager configures the converters. We HAVE to remove one of them
@@ -236,14 +236,14 @@ namespace Umbraco.Core.Runtime
composition.MediaUrlProviders()
.Append<DefaultMediaUrlProvider>();
composition.RegisterUnique<ISiteDomainHelper, SiteDomainHelper>();
composition.Services.AddUnique<ISiteDomainHelper, SiteDomainHelper>();
// register properties fallback
composition.RegisterUnique<IPublishedValueFallback, PublishedValueFallback>();
composition.Services.AddUnique<IPublishedValueFallback, PublishedValueFallback>();
composition.RegisterUnique<IImageUrlGenerator, ImageSharpImageUrlGenerator>();
composition.Services.AddUnique<IImageUrlGenerator, ImageSharpImageUrlGenerator>();
composition.RegisterUnique<UmbracoFeatures>();
composition.Services.AddUnique<UmbracoFeatures>();
composition.Actions()
.Add(() => composition.TypeLoader.GetTypes<IAction>());
@@ -255,7 +255,7 @@ namespace Umbraco.Core.Runtime
composition.TourFilters();
// replace with web implementation
composition.RegisterUnique<IPublishedSnapshotRebuilder, PublishedSnapshotRebuilder>();
composition.Services.AddUnique<IPublishedSnapshotRebuilder, PublishedSnapshotRebuilder>();
// register OEmbed providers - no type scanning - all explicit opt-in of adding types
// note: IEmbedProvider is not IDiscoverable - think about it if going for type scanning
@@ -297,7 +297,7 @@ namespace Umbraco.Core.Runtime
.Append<ContentTypeTemplatesContentAppFactory>();
// register published router
composition.RegisterUnique<IPublishedRouter, PublishedRouter>();
composition.Services.AddUnique<IPublishedRouter, PublishedRouter>();
// register *all* checks, except those marked [HideFromTypeFinder] of course
composition.HealthChecks()
@@ -307,7 +307,7 @@ namespace Umbraco.Core.Runtime
composition.WithCollectionBuilder<HealthCheckNotificationMethodCollectionBuilder>()
.Add(() => composition.TypeLoader.GetTypes<IHealthCheckNotificationMethod>());
composition.RegisterUnique<IContentLastChanceFinder, ContentFinderByConfigured404>();
composition.Services.AddUnique<IContentLastChanceFinder, ContentFinderByConfigured404>();
composition.ContentFinders()
// all built-in finders in the correct order,
@@ -325,52 +325,52 @@ namespace Umbraco.Core.Runtime
.Add(() => composition.TypeLoader.GetTypes<ISearchableTree>());
// replace some services
composition.RegisterUnique<IEventMessagesFactory, DefaultEventMessagesFactory>();
composition.RegisterUnique<IEventMessagesAccessor, HybridEventMessagesAccessor>();
composition.RegisterUnique<ITreeService, TreeService>();
composition.RegisterUnique<ISectionService, SectionService>();
composition.RegisterUnique<IEmailSender, EmailSender>();
composition.Services.AddUnique<IEventMessagesFactory, DefaultEventMessagesFactory>();
composition.Services.AddUnique<IEventMessagesAccessor, HybridEventMessagesAccessor>();
composition.Services.AddUnique<ITreeService, TreeService>();
composition.Services.AddUnique<ISectionService, SectionService>();
composition.Services.AddUnique<IEmailSender, EmailSender>();
composition.RegisterUnique<IExamineManager, ExamineManager>();
composition.Services.AddUnique<IExamineManager, ExamineManager>();
// register distributed cache
composition.RegisterUnique(f => new DistributedCache(f.GetRequiredService<IServerMessenger>(), f.GetRequiredService<CacheRefresherCollection>()));
composition.Services.AddUnique(f => new DistributedCache(f.GetRequiredService<IServerMessenger>(), f.GetRequiredService<CacheRefresherCollection>()));
composition.Services.AddScoped<ITagQuery, TagQuery>();
composition.RegisterUnique<HtmlLocalLinkParser>();
composition.RegisterUnique<HtmlUrlParser>();
composition.RegisterUnique<HtmlImageSourceParser>();
composition.RegisterUnique<RichTextEditorPastedImages>();
composition.Services.AddUnique<HtmlLocalLinkParser>();
composition.Services.AddUnique<HtmlUrlParser>();
composition.Services.AddUnique<HtmlImageSourceParser>();
composition.Services.AddUnique<RichTextEditorPastedImages>();
composition.RegisterUnique<IUmbracoTreeSearcherFields, UmbracoTreeSearcherFields>();
composition.Register<IPublishedContentQuery>(factory =>
composition.Services.AddUnique<IUmbracoTreeSearcherFields, UmbracoTreeSearcherFields>();
composition.Services.AddScoped<IPublishedContentQuery>(factory =>
{
var umbCtx = factory.GetRequiredService<IUmbracoContextAccessor>();
return new PublishedContentQuery(umbCtx.UmbracoContext.PublishedSnapshot, factory.GetRequiredService<IVariationContextAccessor>(), factory.GetRequiredService<IExamineManager>());
}, Lifetime.Request);
});
composition.RegisterUnique<IPublishedUrlProvider, UrlProvider>();
composition.Services.AddUnique<IPublishedUrlProvider, UrlProvider>();
// register the http context and umbraco context accessors
// we *should* use the HttpContextUmbracoContextAccessor, however there are cases when
// we have no http context, eg when booting Umbraco or in background threads, so instead
// let's use an hybrid accessor that can fall back to a ThreadStatic context.
composition.RegisterUnique<IUmbracoContextAccessor, HybridUmbracoContextAccessor>();
composition.Services.AddUnique<IUmbracoContextAccessor, HybridUmbracoContextAccessor>();
// register accessors for cultures
composition.RegisterUnique<IDefaultCultureAccessor, DefaultCultureAccessor>();
composition.Services.AddUnique<IDefaultCultureAccessor, DefaultCultureAccessor>();
composition.Services.AddSingleton<IFilePermissionHelper, FilePermissionHelper>();
composition.RegisterUnique<IUmbracoComponentRenderer, UmbracoComponentRenderer>();
composition.Services.AddUnique<IUmbracoComponentRenderer, UmbracoComponentRenderer>();
// Register noop versions for examine to be overridden by examine
composition.RegisterUnique<IUmbracoIndexesCreator, NoopUmbracoIndexesCreator>();
composition.RegisterUnique<IBackOfficeExamineSearcher, NoopBackOfficeExamineSearcher>();
composition.Services.AddUnique<IUmbracoIndexesCreator, NoopUmbracoIndexesCreator>();
composition.Services.AddUnique<IBackOfficeExamineSearcher, NoopBackOfficeExamineSearcher>();
composition.RegisterUnique<UploadAutoFillProperties>();
composition.Services.AddUnique<UploadAutoFillProperties>();
}
}
}

3
src/Umbraco.Infrastructure/Runtime/CoreRuntime.cs
View File

@@ -16,7 +16,6 @@ using Umbraco.Core.IO;
using Umbraco.Core.Logging;
using Umbraco.Core.Persistence;
using Umbraco.Core.Persistence.Mappers;
using Umbraco.Infrastructure.Composing;
namespace Umbraco.Core.Runtime
{
@@ -185,7 +184,7 @@ namespace Umbraco.Core.Runtime
composition.RegisterEssentials(Logger, RuntimeLoggerFactory, Profiler, ProfilingLogger, MainDom, AppCaches, databaseFactory, typeLoader, _state, TypeFinder, IOHelper, UmbracoVersion, DbProviderFactoryCreator, HostingEnvironment, BackOfficeInfo);
// register ourselves (TODO: Should we put this in RegisterEssentials?)
composition.Register<IRuntime>(_ => this, Lifetime.Singleton);
composition.Services.AddSingleton<IRuntime>(_ => this);
// run handlers
OnRuntimeEssentials(composition, AppCaches, typeLoader, databaseFactory);

14
src/Umbraco.Infrastructure/Search/ExamineComposer.cs
View File

@@ -29,9 +29,9 @@ namespace Umbraco.Web.Search
composition.Services.AddSingleton<MediaIndexPopulator>();
composition.Services.AddSingleton<IndexRebuilder>();
composition.RegisterUnique<IUmbracoIndexConfig, UmbracoIndexConfig>();
composition.RegisterUnique<IIndexDiagnosticsFactory, IndexDiagnosticsFactory>();
composition.RegisterUnique<IPublishedContentValueSetBuilder>(factory =>
composition.Services.AddUnique<IUmbracoIndexConfig, UmbracoIndexConfig>();
composition.Services.AddUnique<IIndexDiagnosticsFactory, IndexDiagnosticsFactory>();
composition.Services.AddUnique<IPublishedContentValueSetBuilder>(factory =>
new ContentValueSetBuilder(
factory.GetRequiredService<PropertyEditorCollection>(),
factory.GetRequiredService<UrlSegmentProviderCollection>(),
@@ -39,7 +39,7 @@ namespace Umbraco.Web.Search
factory.GetRequiredService<IShortStringHelper>(),
factory.GetRequiredService<IScopeProvider>(),
true));
composition.RegisterUnique<IContentValueSetBuilder>(factory =>
composition.Services.AddUnique<IContentValueSetBuilder>(factory =>
new ContentValueSetBuilder(
factory.GetRequiredService<PropertyEditorCollection>(),
factory.GetRequiredService<UrlSegmentProviderCollection>(),
@@ -47,9 +47,9 @@ namespace Umbraco.Web.Search
factory.GetRequiredService<IShortStringHelper>(),
factory.GetRequiredService<IScopeProvider>(),
false));
composition.RegisterUnique<IValueSetBuilder<IMedia>, MediaValueSetBuilder>();
composition.RegisterUnique<IValueSetBuilder<IMember>, MemberValueSetBuilder>();
composition.RegisterUnique<BackgroundIndexRebuilder>();
composition.Services.AddUnique<IValueSetBuilder<IMedia>, MediaValueSetBuilder>();
composition.Services.AddUnique<IValueSetBuilder<IMember>, MemberValueSetBuilder>();
composition.Services.AddUnique<BackgroundIndexRebuilder>();
}
}
}

5
src/Umbraco.Infrastructure/Search/SearchableTreeCollectionBuilder.cs
View File

@@ -1,4 +1,5 @@
using Umbraco.Core.Composing;
using Microsoft.Extensions.DependencyInjection;
using Umbraco.Core.Composing;
using Umbraco.Web.Trees;
namespace Umbraco.Web.Search
@@ -8,6 +9,6 @@ namespace Umbraco.Web.Search
protected override SearchableTreeCollectionBuilder This => this;
//per request because generally an instance of ISearchableTree is a controller
protected override Lifetime CollectionLifetime => Lifetime.Request;
protected override ServiceLifetime CollectionLifetime => ServiceLifetime.Scoped;
}
}

2
src/Umbraco.Infrastructure/WebAssets/WebAssetsComposer.cs
View File

@@ -8,7 +8,7 @@ namespace Umbraco.Web.WebAssets
public override void Compose(Composition composition)
{
base.Compose(composition);
composition.RegisterUnique<BackOfficeWebAssets>();
composition.Services.AddUnique<BackOfficeWebAssets>();
}
}
}