Avoid async await Task.FromResult, plus some other minor tweaks (#19597)

Henr1k80 · web-flow · commit 1f28f1043a5d · 2025-06-30T14:15:22.000+02:00
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/PublishedCache/RebuildPublishedCacheController.cs b/src/Umbraco.Cms.Api.Management/Controllers/PublishedCache/RebuildPublishedCacheController.cs
@@ -15,7 +15,7 @@ public class RebuildPublishedCacheController : PublishedCacheControllerBase
     [HttpPost("rebuild")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(StatusCodes.Status200OK)]
-    public async Task<IActionResult> Rebuild(CancellationToken cancellationToken)
+    public Task<IActionResult> Rebuild(CancellationToken cancellationToken)
     {
         if (_databaseCacheRebuilder.IsRebuilding())
         {
@@ -27,10 +27,10 @@ public async Task<IActionResult> Rebuild(CancellationToken cancellationToken)
                 Type = "Error",
             };
 
-            return await Task.FromResult(Conflict(problemDetails));
+            return Task.FromResult<IActionResult>(Conflict(problemDetails));
         }
 
         _databaseCacheRebuilder.Rebuild(true);
-        return await Task.FromResult(Ok());
+        return Task.FromResult<IActionResult>(Ok());
     }
 }
diff --git a/src/Umbraco.Core/Services/ContentTypeEditing/ContentTypeEditingServiceBase.cs b/src/Umbraco.Core/Services/ContentTypeEditing/ContentTypeEditingServiceBase.cs
@@ -50,7 +50,7 @@ protected async Task<IEnumerable<ContentTypeAvailableCompositionsResult>> FindAv
 
         var currentCompositionAliases = currentCompositeKeys.Any()
             ? allContentTypes.Where(ct => currentCompositeKeys.Contains(ct.Key)).Select(ct => ct.Alias).ToArray()
-            : Array.Empty<string>();
+            : [];
 
         ContentTypeAvailableCompositionsResults availableCompositions = _contentTypeService.GetAvailableCompositeContentTypes(
             contentType,
@@ -142,9 +142,9 @@ protected async Task<IEnumerable<ContentTypeAvailableCompositionsResult>> FindAv
         return Attempt.SucceedWithStatus<TContentType?, ContentTypeOperationStatus>(ContentTypeOperationStatus.Success, contentType);
     }
 
-    protected virtual async Task<ContentTypeOperationStatus> AdditionalCreateValidationAsync(
+    protected virtual Task<ContentTypeOperationStatus> AdditionalCreateValidationAsync(
         ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)
-        => await Task.FromResult(ContentTypeOperationStatus.Success);
+        => Task.FromResult(ContentTypeOperationStatus.Success);
 
     #region Sanitization
 
@@ -346,7 +346,7 @@ private ContentTypeOperationStatus ValidateCompositions(TContentType? contentTyp
         return ContentTypeOperationStatus.Success;
     }
 
-    private ContentTypeOperationStatus ValidateProperties(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)
+    private static ContentTypeOperationStatus ValidateProperties(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)
     {
         // grab all content types used for composition and/or inheritance
         Guid[] allCompositionKeys = KeysForCompositionTypes(model, CompositionType.Composition, CompositionType.Inheritance);
@@ -365,7 +365,7 @@ private ContentTypeOperationStatus ValidateProperties(ContentTypeEditingModelBas
         return ContentTypeOperationStatus.Success;
     }
 
-    private ContentTypeOperationStatus ValidateContainers(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)
+    private static ContentTypeOperationStatus ValidateContainers(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)
     {
         if (model.Containers.Any(container => Enum.TryParse<PropertyGroupType>(container.Type, out _) is false))
         {
@@ -420,7 +420,7 @@ private bool ContentTypeAliasCanBeUsedFor(string alias, Guid key)
         return ContentTypeAliasIsInUse(alias) is false;
     }
 
-    private bool IsReservedContentTypeAlias(string alias)
+    private static bool IsReservedContentTypeAlias(string alias)
     {
         var reservedAliases = new[] { "system" };
         return reservedAliases.InvariantContains(alias);
@@ -474,7 +474,7 @@ private async Task<TContentType> UpdateAsync(
         return contentType;
     }
 
-    private void UpdateAllowedContentTypes(
+    private static void UpdateAllowedContentTypes(
         TContentType contentType,
         ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model,
         IContentTypeComposition[] allContentTypeCompositions)
@@ -573,7 +573,7 @@ private async Task UpdatePropertiesAsync(
         }
     }
 
-    private string PropertyGroupAlias(string? containerName)
+    private static string PropertyGroupAlias(string? containerName)
     {
         if (containerName.IsNullOrWhiteSpace())
         {
@@ -625,7 +625,7 @@ private IPropertyType MapProperty(
         return propertyType;
     }
 
-    private void UpdateCompositions(
+    private static void UpdateCompositions(
         TContentType contentType,
         ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model,
         IContentTypeComposition[] allContentTypeCompositions)
@@ -658,7 +658,7 @@ private void UpdateCompositions(
         }
     }
 
-    private void UpdateParentContentType(
+    private static void UpdateParentContentType(
         TContentType contentType,
         ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model,
         IContentTypeComposition[] allContentTypeCompositions)
@@ -677,15 +677,15 @@ private void UpdateParentContentType(
 
     #region Shared between model validation and model update
 
-    private Guid[] GetDataTypeKeys(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)
+    private static Guid[] GetDataTypeKeys(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)
         => model.Properties.Select(property => property.DataTypeKey).Distinct().ToArray();
 
     private async Task<IDataType[]> GetDataTypesAsync(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)
     {
         Guid[] dataTypeKeys = GetDataTypeKeys(model);
         return dataTypeKeys.Any()
             ? (await _dataTypeService.GetAllAsync(GetDataTypeKeys(model))).ToArray()
-            : Array.Empty<IDataType>();
+            : [];
     }
 
     private int? GetParentId(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, Guid? containerKey)
@@ -711,7 +711,7 @@ private async Task<IDataType[]> GetDataTypesAsync(ContentTypeEditingModelBase<TP
         return Constants.System.Root;
     }
 
-    private Guid[] KeysForCompositionTypes(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, params CompositionType[] compositionTypes)
+    private static Guid[] KeysForCompositionTypes(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, params CompositionType[] compositionTypes)
         => model.Compositions
             .Where(c => compositionTypes.Contains(c.CompositionType))
             .Select(c => c.Key)
diff --git a/src/Umbraco.Core/Services/ContentTypeEditing/ElementSwitchValidator.cs b/src/Umbraco.Core/Services/ContentTypeEditing/ElementSwitchValidator.cs
@@ -20,27 +20,27 @@ public ElementSwitchValidator(
         _dataTypeService = dataTypeService;
     }
 
-    public async Task<bool> AncestorsAreAlignedAsync(IContentType contentType)
+    public Task<bool> AncestorsAreAlignedAsync(IContentType contentType)
     {
         // this call does not return the system roots
         var ancestorIds = contentType.AncestorIds();
         if (ancestorIds.Length == 0)
         {
             // if there are no ancestors, validation passes
-            return true;
+            return Task.FromResult(true);
         }
 
         // if there are any ancestors where IsElement is different from the contentType, the validation fails
-        return await Task.FromResult(_contentTypeService.GetMany(ancestorIds)
+        return Task.FromResult(_contentTypeService.GetMany(ancestorIds)
             .Any(ancestor => ancestor.IsElement != contentType.IsElement) is false);
     }
 
-    public async Task<bool> DescendantsAreAlignedAsync(IContentType contentType)
+    public Task<bool> DescendantsAreAlignedAsync(IContentType contentType)
     {
         IEnumerable<IContentType> descendants = _contentTypeService.GetDescendants(contentType.Id, false);
 
         // if there are any descendants where IsElement is different from the contentType, the validation fails
-        return await Task.FromResult(descendants.Any(descendant => descendant.IsElement != contentType.IsElement) is false);
+        return Task.FromResult(descendants.Any(descendant => descendant.IsElement != contentType.IsElement) is false);
     }
 
     public async Task<bool> ElementToDocumentNotUsedInBlockStructuresAsync(IContentTypeBase contentType)
@@ -59,8 +59,8 @@ public async Task<bool> ElementToDocumentNotUsedInBlockStructuresAsync(IContentT
                 .ConfiguredElementTypeKeys().Contains(contentType.Key)) is false;
     }
 
-    public async Task<bool> DocumentToElementHasNoContentAsync(IContentTypeBase contentType) =>
+    public Task<bool> DocumentToElementHasNoContentAsync(IContentTypeBase contentType) =>
 
         // if any content for the content type exists, the validation fails.
-        await Task.FromResult(_contentTypeService.HasContentNodes(contentType.Id) is false);
+        Task.FromResult(_contentTypeService.HasContentNodes(contentType.Id) is false);
 }
diff --git a/src/Umbraco.Core/Services/DataTypeService.cs b/src/Umbraco.Core/Services/DataTypeService.cs
@@ -355,13 +355,13 @@ public Task<IEnumerable<IDataType>> GetByEditorAliasAsync(string propertyEditorA
         }
 
         /// <inheritdoc />
-        public async Task<IEnumerable<IDataType>> GetByEditorAliasAsync(string[] propertyEditorAlias)
+        public Task<IEnumerable<IDataType>> GetByEditorAliasAsync(string[] propertyEditorAlias)
         {
             using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
             IQuery<IDataType> query = Query<IDataType>().Where(x => propertyEditorAlias.Contains(x.EditorAlias));
             IEnumerable<IDataType> dataTypes = _dataTypeRepository.Get(query).ToArray();
             ConvertMissingEditorsOfDataTypesToLabels(dataTypes);
-            return await Task.FromResult(dataTypes);
+            return Task.FromResult(dataTypes);
         }
 
         /// <inheritdoc />
@@ -396,7 +396,7 @@ private void ConvertMissingEditorOfDataTypeToLabel(IDataType? dataType)
                 return;
             }
 
-            ConvertMissingEditorsOfDataTypesToLabels(new[] { dataType });
+            ConvertMissingEditorsOfDataTypesToLabels([dataType]);
         }
 
         private void ConvertMissingEditorsOfDataTypesToLabels(IEnumerable<IDataType> dataTypes)
@@ -763,7 +763,7 @@ public Task<PagedModel<RelationItemModel>> GetPagedRelationsAsync(Guid key, int
             var totalItems = combinedUsages.Count;
 
             // Create the page of items.
-            IList<(string PropertyAlias, Udi Udi)> pagedUsages = combinedUsages
+            List<(string PropertyAlias, Udi Udi)> pagedUsages = combinedUsages
                 .OrderBy(x => x.Udi.EntityType) // Document types first, then media types, then member types.
                 .ThenBy(x => x.PropertyAlias)
                 .Skip(skip)
@@ -772,7 +772,7 @@ public Task<PagedModel<RelationItemModel>> GetPagedRelationsAsync(Guid key, int
 
             // Get the content types for the UDIs referenced in the page of items to construct the response from.
             // They could be document, media or member types.
-            IList<IContentTypeComposition> contentTypes = GetReferencedContentTypes(pagedUsages);
+            List<IContentTypeComposition> contentTypes = GetReferencedContentTypes(pagedUsages);
 
             IEnumerable<RelationItemModel> relations = pagedUsages
                 .Select(x =>
@@ -807,7 +807,7 @@ public Task<PagedModel<RelationItemModel>> GetPagedRelationsAsync(Guid key, int
             return Task.FromResult(pagedModel);
         }
 
-        private IList<IContentTypeComposition> GetReferencedContentTypes(IList<(string PropertyAlias, Udi Udi)> pagedUsages)
+        private List<IContentTypeComposition> GetReferencedContentTypes(List<(string PropertyAlias, Udi Udi)> pagedUsages)
         {
             IEnumerable<IContentTypeComposition> documentTypes = GetContentTypes(
                 pagedUsages,
@@ -845,10 +845,10 @@ public IEnumerable<ValidationResult> ValidateConfigurationData(IDataType dataTyp
         {
             IConfigurationEditor? configurationEditor = dataType.Editor?.GetConfigurationEditor();
             return configurationEditor == null
-                ? new[]
-                {
+                ?
+                [
                     new ValidationResult($"Data type with editor alias {dataType.EditorAlias} does not have a configuration editor")
-                }
+                ]
                 : configurationEditor.Validate(dataType.ConfigurationData);
         }
 
diff --git a/src/Umbraco.Core/Services/EntityTypeContainerService.cs b/src/Umbraco.Core/Services/EntityTypeContainerService.cs
@@ -52,18 +52,18 @@ protected EntityTypeContainerService(
 
 
     /// <inheritdoc />
-    public async Task<IEnumerable<EntityContainer>> GetAsync(string name, int level)
+    public Task<IEnumerable<EntityContainer>> GetAsync(string name, int level)
     {
         using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
         ReadLock(scope);
-        return await Task.FromResult(_entityContainerRepository.Get(name, level));
+        return Task.FromResult(_entityContainerRepository.Get(name, level));
     }
     /// <inheritdoc />
-    public async Task<IEnumerable<EntityContainer>> GetAllAsync()
+    public Task<IEnumerable<EntityContainer>> GetAllAsync()
     {
         using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
         ReadLock(scope);
-        return await Task.FromResult(_entityContainerRepository.GetMany());
+        return Task.FromResult(_entityContainerRepository.GetMany());
     }
 
     /// <inheritdoc />
diff --git a/src/Umbraco.Core/Services/Querying/ContentQueryService.cs b/src/Umbraco.Core/Services/Querying/ContentQueryService.cs
@@ -23,23 +23,23 @@ public ContentQueryService(
         _coreScopeProvider = coreScopeProvider;
     }
 
-    public async Task<Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>> GetWithSchedulesAsync(Guid id)
+    public Task<Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>> GetWithSchedulesAsync(Guid id)
     {
         using ICoreScope scope = _coreScopeProvider.CreateCoreScope(autoComplete: true);
 
-        IContent? content = await Task.FromResult(_contentService.GetById(id));
+        IContent? content = _contentService.GetById(id);
 
         if (content == null)
         {
-            return Attempt<ContentScheduleQueryResult, ContentQueryOperationStatus>.Fail(ContentQueryOperationStatus
-                .ContentNotFound);
+            return Task.FromResult(Attempt<ContentScheduleQueryResult, ContentQueryOperationStatus>.Fail(ContentQueryOperationStatus
+                .ContentNotFound));
         }
 
         ContentScheduleCollection schedules = _contentService.GetContentScheduleByContentId(id);
 
-        return Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>
+        return Task.FromResult(Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>
             .Succeed(
                 ContentQueryOperationStatus.Success,
-                new ContentScheduleQueryResult(content, schedules));
+                new ContentScheduleQueryResult(content, schedules)));
     }
 }
diff --git a/src/Umbraco.Core/Services/RelationService.cs b/src/Umbraco.Core/Services/RelationService.cs
@@ -220,7 +220,7 @@ public IEnumerable<IRelation> GetByRelationTypeName(string relationTypeName)
         }
 
         return relationTypeIds.Count == 0
-            ? Enumerable.Empty<IRelation>()
+            ? []
             : GetRelationsByListOfTypeIds(relationTypeIds);
     }
 
@@ -230,8 +230,8 @@ public IEnumerable<IRelation> GetByRelationTypeAlias(string relationTypeAlias)
         IRelationType? relationType = GetRelationType(relationTypeAlias);
 
         return relationType == null
-            ? Enumerable.Empty<IRelation>()
-            : GetRelationsByListOfTypeIds(new[] { relationType.Id });
+            ? []
+            : GetRelationsByListOfTypeIds([relationType.Id]);
     }
 
     /// <inheritdoc />
@@ -594,7 +594,7 @@ private async Task<Attempt<IRelationType, RelationTypeOperationStatus>> SaveAsyn
 
             EventMessages eventMessages = EventMessagesFactory.Get();
             var savingNotification = new RelationTypeSavingNotification(relationType, eventMessages);
-            if (scope.Notifications.PublishCancelable(savingNotification))
+            if (await scope.Notifications.PublishCancelableAsync(savingNotification))
             {
                 scope.Complete();
                 return Attempt.FailWithStatus(RelationTypeOperationStatus.CancelledByNotification, relationType);
@@ -659,7 +659,7 @@ public void Delete(IRelationType relationType)
 
         EventMessages eventMessages = EventMessagesFactory.Get();
         var deletingNotification = new RelationTypeDeletingNotification(relationType, eventMessages);
-        if (scope.Notifications.PublishCancelable(deletingNotification))
+        if (await scope.Notifications.PublishCancelableAsync(deletingNotification))
         {
             scope.Complete();
             return Attempt.FailWithStatus<IRelationType?, RelationTypeOperationStatus>(RelationTypeOperationStatus.CancelledByNotification, null);
@@ -670,7 +670,7 @@ public void Delete(IRelationType relationType)
         Audit(AuditType.Delete, currentUser, relationType.Id, "Deleted relation type");
         scope.Notifications.Publish(new RelationTypeDeletedNotification(relationType, eventMessages).WithStateFrom(deletingNotification));
         scope.Complete();
-        return await Task.FromResult(Attempt.SucceedWithStatus<IRelationType?, RelationTypeOperationStatus>(RelationTypeOperationStatus.Success, relationType));
+        return Attempt.SucceedWithStatus<IRelationType?, RelationTypeOperationStatus>(RelationTypeOperationStatus.Success, relationType);
     }
 
     /// <inheritdoc />
@@ -726,7 +726,7 @@ public IEnumerable<UmbracoObjectTypes> GetAllowedObjectTypes() =>
         return _relationTypeRepository.Get(query).FirstOrDefault();
     }
 
-    private IEnumerable<IRelation> GetRelationsByListOfTypeIds(IEnumerable<int> relationTypeIds)
+    private List<IRelation> GetRelationsByListOfTypeIds(IEnumerable<int> relationTypeIds)
     {
         var relations = new List<IRelation>();
         using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))
diff --git a/src/Umbraco.Core/Strings/Diff.cs b/src/Umbraco.Core/Strings/Diff.cs
@@ -13,7 +13,7 @@ namespace Umbraco.Cms.Core.Strings;
 ///     Copyright (c) by Matthias Hertel, http://www.mathertel.de
 ///     This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx
 /// </summary>
-internal class Diff
+internal sealed class Diff
 {
     /// <summary>
     ///     Find the difference in 2 texts, comparing by text lines.

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class RebuildPublishedCacheController : PublishedCacheControllerBase`
`15`	`15`	`[HttpPost("rebuild")]`
`16`	`16`	`[MapToApiVersion("1.0")]`
`17`	`17`	`[ProducesResponseType(StatusCodes.Status200OK)]`
`18`		`- public async Task<IActionResult> Rebuild(CancellationToken cancellationToken)`
	`18`	`+ public Task<IActionResult> Rebuild(CancellationToken cancellationToken)`
`19`	`19`	`{`
`20`	`20`	`if (_databaseCacheRebuilder.IsRebuilding())`
`21`	`21`	`{`
`@@ -27,10 +27,10 @@ public async Task<IActionResult> Rebuild(CancellationToken cancellationToken)`
`27`	`27`	`Type = "Error",`
`28`	`28`	`};`
`29`	`29`
`30`		`- return await Task.FromResult(Conflict(problemDetails));`
	`30`	`+ return Task.FromResult<IActionResult>(Conflict(problemDetails));`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`_databaseCacheRebuilder.Rebuild(true);`
`34`		`- return await Task.FromResult(Ok());`
	`34`	`+ return Task.FromResult<IActionResult>(Ok());`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ protected async Task<IEnumerable<ContentTypeAvailableCompositionsResult>> FindAv`
`50`	`50`
`51`	`51`	`var currentCompositionAliases = currentCompositeKeys.Any()`
`52`	`52`	`? allContentTypes.Where(ct => currentCompositeKeys.Contains(ct.Key)).Select(ct => ct.Alias).ToArray()`
`53`		`- : Array.Empty<string>();`
	`53`	`+ : [];`
`54`	`54`
`55`	`55`	`ContentTypeAvailableCompositionsResults availableCompositions = _contentTypeService.GetAvailableCompositeContentTypes(`
`56`	`56`	`contentType,`
`@@ -142,9 +142,9 @@ protected async Task<IEnumerable<ContentTypeAvailableCompositionsResult>> FindAv`
`142`	`142`	`return Attempt.SucceedWithStatus<TContentType?, ContentTypeOperationStatus>(ContentTypeOperationStatus.Success, contentType);`
`143`	`143`	`}`
`144`	`144`
`145`		`- protected virtual async Task<ContentTypeOperationStatus> AdditionalCreateValidationAsync(`
	`145`	`+ protected virtual Task<ContentTypeOperationStatus> AdditionalCreateValidationAsync(`
`146`	`146`	`ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)`
`147`		`- => await Task.FromResult(ContentTypeOperationStatus.Success);`
	`147`	`+ => Task.FromResult(ContentTypeOperationStatus.Success);`
`148`	`148`
`149`	`149`	`#region Sanitization`
`150`	`150`
`@@ -346,7 +346,7 @@ private ContentTypeOperationStatus ValidateCompositions(TContentType? contentTyp`
`346`	`346`	`return ContentTypeOperationStatus.Success;`
`347`	`347`	`}`
`348`	`348`
`349`		`- private ContentTypeOperationStatus ValidateProperties(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)`
	`349`	`+ private static ContentTypeOperationStatus ValidateProperties(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)`
`350`	`350`	`{`
`351`	`351`	`// grab all content types used for composition and/or inheritance`
`352`	`352`	`Guid[] allCompositionKeys = KeysForCompositionTypes(model, CompositionType.Composition, CompositionType.Inheritance);`
`@@ -365,7 +365,7 @@ private ContentTypeOperationStatus ValidateProperties(ContentTypeEditingModelBas`
`365`	`365`	`return ContentTypeOperationStatus.Success;`
`366`	`366`	`}`
`367`	`367`
`368`		`- private ContentTypeOperationStatus ValidateContainers(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)`
	`368`	`+ private static ContentTypeOperationStatus ValidateContainers(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, IContentTypeComposition[] allContentTypeCompositions)`
`369`	`369`	`{`
`370`	`370`	`if (model.Containers.Any(container => Enum.TryParse<PropertyGroupType>(container.Type, out _) is false))`
`371`	`371`	`{`
`@@ -420,7 +420,7 @@ private bool ContentTypeAliasCanBeUsedFor(string alias, Guid key)`
`420`	`420`	`return ContentTypeAliasIsInUse(alias) is false;`
`421`	`421`	`}`
`422`	`422`
`423`		`- private bool IsReservedContentTypeAlias(string alias)`
	`423`	`+ private static bool IsReservedContentTypeAlias(string alias)`
`424`	`424`	`{`
`425`	`425`	`var reservedAliases = new[] { "system" };`
`426`	`426`	`return reservedAliases.InvariantContains(alias);`
`@@ -474,7 +474,7 @@ private async Task<TContentType> UpdateAsync(`
`474`	`474`	`return contentType;`
`475`	`475`	`}`
`476`	`476`
`477`		`- private void UpdateAllowedContentTypes(`
	`477`	`+ private static void UpdateAllowedContentTypes(`
`478`	`478`	`TContentType contentType,`
`479`	`479`	`ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model,`
`480`	`480`	`IContentTypeComposition[] allContentTypeCompositions)`
`@@ -573,7 +573,7 @@ private async Task UpdatePropertiesAsync(`
`573`	`573`	`}`
`574`	`574`	`}`
`575`	`575`
`576`		`- private string PropertyGroupAlias(string? containerName)`
	`576`	`+ private static string PropertyGroupAlias(string? containerName)`
`577`	`577`	`{`
`578`	`578`	`if (containerName.IsNullOrWhiteSpace())`
`579`	`579`	`{`
`@@ -625,7 +625,7 @@ private IPropertyType MapProperty(`
`625`	`625`	`return propertyType;`
`626`	`626`	`}`
`627`	`627`
`628`		`- private void UpdateCompositions(`
	`628`	`+ private static void UpdateCompositions(`
`629`	`629`	`TContentType contentType,`
`630`	`630`	`ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model,`
`631`	`631`	`IContentTypeComposition[] allContentTypeCompositions)`
`@@ -658,7 +658,7 @@ private void UpdateCompositions(`
`658`	`658`	`}`
`659`	`659`	`}`
`660`	`660`
`661`		`- private void UpdateParentContentType(`
	`661`	`+ private static void UpdateParentContentType(`
`662`	`662`	`TContentType contentType,`
`663`	`663`	`ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model,`
`664`	`664`	`IContentTypeComposition[] allContentTypeCompositions)`
`@@ -677,15 +677,15 @@ private void UpdateParentContentType(`
`677`	`677`
`678`	`678`	`#region Shared between model validation and model update`
`679`	`679`
`680`		`- private Guid[] GetDataTypeKeys(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)`
	`680`	`+ private static Guid[] GetDataTypeKeys(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)`
`681`	`681`	`=> model.Properties.Select(property => property.DataTypeKey).Distinct().ToArray();`
`682`	`682`
`683`	`683`	`private async Task<IDataType[]> GetDataTypesAsync(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model)`
`684`	`684`	`{`
`685`	`685`	`Guid[] dataTypeKeys = GetDataTypeKeys(model);`
`686`	`686`	`return dataTypeKeys.Any()`
`687`	`687`	`? (await _dataTypeService.GetAllAsync(GetDataTypeKeys(model))).ToArray()`
`688`		`- : Array.Empty<IDataType>();`
	`688`	`+ : [];`
`689`	`689`	`}`
`690`	`690`
`691`	`691`	`private int? GetParentId(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, Guid? containerKey)`
`@@ -711,7 +711,7 @@ private async Task<IDataType[]> GetDataTypesAsync(ContentTypeEditingModelBase<TP`
`711`	`711`	`return Constants.System.Root;`
`712`	`712`	`}`
`713`	`713`
`714`		`- private Guid[] KeysForCompositionTypes(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, params CompositionType[] compositionTypes)`
	`714`	`+ private static Guid[] KeysForCompositionTypes(ContentTypeEditingModelBase<TPropertyTypeModel, TPropertyTypeContainer> model, params CompositionType[] compositionTypes)`
`715`	`715`	`=> model.Compositions`
`716`	`716`	`.Where(c => compositionTypes.Contains(c.CompositionType))`
`717`	`717`	`.Select(c => c.Key)`
Original file line number	Diff line number	Diff line change
`@@ -20,27 +20,27 @@ public ElementSwitchValidator(`
`20`	`20`	`_dataTypeService = dataTypeService;`
`21`	`21`	`}`
`22`	`22`
`23`		`- public async Task<bool> AncestorsAreAlignedAsync(IContentType contentType)`
	`23`	`+ public Task<bool> AncestorsAreAlignedAsync(IContentType contentType)`
`24`	`24`	`{`
`25`	`25`	`// this call does not return the system roots`
`26`	`26`	`var ancestorIds = contentType.AncestorIds();`
`27`	`27`	`if (ancestorIds.Length == 0)`
`28`	`28`	`{`
`29`	`29`	`// if there are no ancestors, validation passes`
`30`		`- return true;`
	`30`	`+ return Task.FromResult(true);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`// if there are any ancestors where IsElement is different from the contentType, the validation fails`
`34`		`- return await Task.FromResult(_contentTypeService.GetMany(ancestorIds)`
	`34`	`+ return Task.FromResult(_contentTypeService.GetMany(ancestorIds)`
`35`	`35`	`.Any(ancestor => ancestor.IsElement != contentType.IsElement) is false);`
`36`	`36`	`}`
`37`	`37`
`38`		`- public async Task<bool> DescendantsAreAlignedAsync(IContentType contentType)`
	`38`	`+ public Task<bool> DescendantsAreAlignedAsync(IContentType contentType)`
`39`	`39`	`{`
`40`	`40`	`IEnumerable<IContentType> descendants = _contentTypeService.GetDescendants(contentType.Id, false);`
`41`	`41`
`42`	`42`	`// if there are any descendants where IsElement is different from the contentType, the validation fails`
`43`		`- return await Task.FromResult(descendants.Any(descendant => descendant.IsElement != contentType.IsElement) is false);`
	`43`	`+ return Task.FromResult(descendants.Any(descendant => descendant.IsElement != contentType.IsElement) is false);`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`public async Task<bool> ElementToDocumentNotUsedInBlockStructuresAsync(IContentTypeBase contentType)`
`@@ -59,8 +59,8 @@ public async Task<bool> ElementToDocumentNotUsedInBlockStructuresAsync(IContentT`
`59`	`59`	`.ConfiguredElementTypeKeys().Contains(contentType.Key)) is false;`
`60`	`60`	`}`
`61`	`61`
`62`		`- public async Task<bool> DocumentToElementHasNoContentAsync(IContentTypeBase contentType) =>`
	`62`	`+ public Task<bool> DocumentToElementHasNoContentAsync(IContentTypeBase contentType) =>`
`63`	`63`
`64`	`64`	`// if any content for the content type exists, the validation fails.`
`65`		`- await Task.FromResult(_contentTypeService.HasContentNodes(contentType.Id) is false);`
	`65`	`+ Task.FromResult(_contentTypeService.HasContentNodes(contentType.Id) is false);`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,18 +52,18 @@ protected EntityTypeContainerService(`
`52`	`52`
`53`	`53`
`54`	`54`	`/// <inheritdoc />`
`55`		`- public async Task<IEnumerable<EntityContainer>> GetAsync(string name, int level)`
	`55`	`+ public Task<IEnumerable<EntityContainer>> GetAsync(string name, int level)`
`56`	`56`	`{`
`57`	`57`	`using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);`
`58`	`58`	`ReadLock(scope);`
`59`		`- return await Task.FromResult(_entityContainerRepository.Get(name, level));`
	`59`	`+ return Task.FromResult(_entityContainerRepository.Get(name, level));`
`60`	`60`	`}`
`61`	`61`	`/// <inheritdoc />`
`62`		`- public async Task<IEnumerable<EntityContainer>> GetAllAsync()`
	`62`	`+ public Task<IEnumerable<EntityContainer>> GetAllAsync()`
`63`	`63`	`{`
`64`	`64`	`using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);`
`65`	`65`	`ReadLock(scope);`
`66`		`- return await Task.FromResult(_entityContainerRepository.GetMany());`
	`66`	`+ return Task.FromResult(_entityContainerRepository.GetMany());`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/// <inheritdoc />`
Original file line number	Diff line number	Diff line change
`@@ -23,23 +23,23 @@ public ContentQueryService(`
`23`	`23`	`_coreScopeProvider = coreScopeProvider;`
`24`	`24`	`}`
`25`	`25`
`26`		`- public async Task<Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>> GetWithSchedulesAsync(Guid id)`
	`26`	`+ public Task<Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>> GetWithSchedulesAsync(Guid id)`
`27`	`27`	`{`
`28`	`28`	`using ICoreScope scope = _coreScopeProvider.CreateCoreScope(autoComplete: true);`
`29`	`29`
`30`		`- IContent? content = await Task.FromResult(_contentService.GetById(id));`
	`30`	`+ IContent? content = _contentService.GetById(id);`
`31`	`31`
`32`	`32`	`if (content == null)`
`33`	`33`	`{`
`34`		`- return Attempt<ContentScheduleQueryResult, ContentQueryOperationStatus>.Fail(ContentQueryOperationStatus`
`35`		`- .ContentNotFound);`
	`34`	`+ return Task.FromResult(Attempt<ContentScheduleQueryResult, ContentQueryOperationStatus>.Fail(ContentQueryOperationStatus`
	`35`	`+ .ContentNotFound));`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`ContentScheduleCollection schedules = _contentService.GetContentScheduleByContentId(id);`
`39`	`39`
`40`		`- return Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>`
	`40`	`+ return Task.FromResult(Attempt<ContentScheduleQueryResult?, ContentQueryOperationStatus>`
`41`	`41`	`.Succeed(`
`42`	`42`	`ContentQueryOperationStatus.Success,`
`43`		`- new ContentScheduleQueryResult(content, schedules));`
	`43`	`+ new ContentScheduleQueryResult(content, schedules)));`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ public IEnumerable<IRelation> GetByRelationTypeName(string relationTypeName)`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`return relationTypeIds.Count == 0`
`223`		`- ? Enumerable.Empty<IRelation>()`
	`223`	`+ ? []`
`224`	`224`	`: GetRelationsByListOfTypeIds(relationTypeIds);`
`225`	`225`	`}`
`226`	`226`
`@@ -230,8 +230,8 @@ public IEnumerable<IRelation> GetByRelationTypeAlias(string relationTypeAlias)`
`230`	`230`	`IRelationType? relationType = GetRelationType(relationTypeAlias);`
`231`	`231`
`232`	`232`	`return relationType == null`
`233`		`- ? Enumerable.Empty<IRelation>()`
`234`		`- : GetRelationsByListOfTypeIds(new[] { relationType.Id });`
	`233`	`+ ? []`
	`234`	`+ : GetRelationsByListOfTypeIds([relationType.Id]);`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`/// <inheritdoc />`
`@@ -594,7 +594,7 @@ private async Task<Attempt<IRelationType, RelationTypeOperationStatus>> SaveAsyn`
`594`	`594`
`595`	`595`	`EventMessages eventMessages = EventMessagesFactory.Get();`
`596`	`596`	`var savingNotification = new RelationTypeSavingNotification(relationType, eventMessages);`
`597`		`- if (scope.Notifications.PublishCancelable(savingNotification))`
	`597`	`+ if (await scope.Notifications.PublishCancelableAsync(savingNotification))`
`598`	`598`	`{`
`599`	`599`	`scope.Complete();`
`600`	`600`	`return Attempt.FailWithStatus(RelationTypeOperationStatus.CancelledByNotification, relationType);`
`@@ -659,7 +659,7 @@ public void Delete(IRelationType relationType)`
`659`	`659`
`660`	`660`	`EventMessages eventMessages = EventMessagesFactory.Get();`
`661`	`661`	`var deletingNotification = new RelationTypeDeletingNotification(relationType, eventMessages);`
`662`		`- if (scope.Notifications.PublishCancelable(deletingNotification))`
	`662`	`+ if (await scope.Notifications.PublishCancelableAsync(deletingNotification))`
`663`	`663`	`{`
`664`	`664`	`scope.Complete();`
`665`	`665`	`return Attempt.FailWithStatus<IRelationType?, RelationTypeOperationStatus>(RelationTypeOperationStatus.CancelledByNotification, null);`
`@@ -670,7 +670,7 @@ public void Delete(IRelationType relationType)`
`670`	`670`	`Audit(AuditType.Delete, currentUser, relationType.Id, "Deleted relation type");`
`671`	`671`	`scope.Notifications.Publish(new RelationTypeDeletedNotification(relationType, eventMessages).WithStateFrom(deletingNotification));`
`672`	`672`	`scope.Complete();`
`673`		`- return await Task.FromResult(Attempt.SucceedWithStatus<IRelationType?, RelationTypeOperationStatus>(RelationTypeOperationStatus.Success, relationType));`
	`673`	`+ return Attempt.SucceedWithStatus<IRelationType?, RelationTypeOperationStatus>(RelationTypeOperationStatus.Success, relationType);`
`674`	`674`	`}`
`675`	`675`
`676`	`676`	`/// <inheritdoc />`
`@@ -726,7 +726,7 @@ public IEnumerable<UmbracoObjectTypes> GetAllowedObjectTypes() =>`
`726`	`726`	`return _relationTypeRepository.Get(query).FirstOrDefault();`
`727`	`727`	`}`
`728`	`728`
`729`		`- private IEnumerable<IRelation> GetRelationsByListOfTypeIds(IEnumerable<int> relationTypeIds)`
	`729`	`+ private List<IRelation> GetRelationsByListOfTypeIds(IEnumerable<int> relationTypeIds)`
`730`	`730`	`{`
`731`	`731`	`var relations = new List<IRelation>();`
`732`	`732`	`using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Umbraco.Cms.Core.Strings;`
`13`	`13`	`/// Copyright (c) by Matthias Hertel, http://www.mathertel.de`
`14`	`14`	`/// This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx`
`15`	`15`	`/// </summary>`
`16`		`-internal class Diff`
	`16`	`+internal sealed class Diff`
`17`	`17`	`{`
`18`	`18`	`/// <summary>`
`19`	`19`	`/// Find the difference in 2 texts, comparing by text lines.`