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

Merge branch 'vx/feature/unicore' of https://github.com/umbraco/Umbraco-CMS into vx/feature/unicore

Browse Source
This commit is contained in:
Carole Rennie Logan
2019-05-20 16:26:25 +01:00
parent 20282edba4 f8462a739c
commit 98afb9a030
8 changed files with 4 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
src/Umbraco.Core/Composing/IFactory.cs
View File

@@ -1,84 +0,0 @@
using System;
using System.Collections.Generic;
namespace Umbraco.Core.Composing
{
/// <summary>
/// Defines a service factory for Umbraco.
/// </summary>
public interface IFactory
{
/// <summary>
/// Gets the concrete factory.
/// </summary>
object Concrete { get; }
/// <summary>
/// Gets an instance of a service.
/// </summary>
/// <param name="type">The type of the service.</param>
/// <returns>An instance of the specified type.</returns>
/// <remarks>Throws an exception if the container failed to get an instance of the specified type.</remarks>
object GetInstance(Type type);
/// <summary>
/// Gets a targeted instance of a service.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
/// <typeparam name="TTarget">The type of the target.</typeparam>
/// <returns>The instance of the specified type for the specified target.</returns>
/// <remarks>Throws an exception if the container failed to get an instance of the specified type.</remarks>
TService GetInstanceFor<TService, TTarget>();
/// <summary>
/// Tries to get an instance of a service.
/// </summary>
/// <param name="type">The type of the service.</param>
/// <returns>An instance of the specified type, or null.</returns>
/// <remarks>Returns null if the container does not know how to get an instance
/// of the specified type. Throws an exception if the container does know how
/// to get an instance of the specified type, but failed to do so.</remarks>
object TryGetInstance(Type type);
/// <summary>
/// Gets all instances of a service.
/// </summary>
/// <param name="serviceType">The type of the service.</param>
IEnumerable<object> GetAllInstances(Type serviceType);
/// <summary>
/// Gets all instances of a service.
/// </summary>
/// <typeparam name="TService">The type of the service.</typeparam>
IEnumerable<TService> GetAllInstances<TService>()
where TService : class;
/// <summary>
/// Releases an instance.
/// </summary>
/// <param name="instance">The instance.</param>
/// <remarks>
/// See https://stackoverflow.com/questions/14072208 and http://kozmic.net/2010/08/27/must-i-release-everything-when-using-windsor/,
/// you only need to release instances you specifically resolved, and even then, if done right, that might never be needed. For
/// instance, LightInject does not require this and does not support it - should work with scopes.
/// </remarks>
void Release(object instance);
/// <summary>
/// Begins a scope.
/// </summary>
/// <remarks>
/// <para>When the scope is disposed, scoped instances that have been created during the scope are disposed.</para>
/// <para>Scopes can be nested. Each instance is disposed individually.</para>
/// </remarks>
IDisposable BeginScope();
/// <summary>
/// Enables per-request scope.
/// </summary>
/// <remarks>
/// <para>Ties scopes to web requests.</para>
/// </remarks>
void EnablePerWebRequestScope();
}
}

106
src/Umbraco.Core/Composing/IRegister.cs
View File

@@ -1,106 +0,0 @@
using System;
namespace Umbraco.Core.Composing
{
/// <summary>
/// Defines a service register for Umbraco.
/// </summary>
public interface IRegister
{
/// <summary>
/// Gets the concrete container.
/// </summary>
object Concrete { get; }
/// <summary>
/// Registers a service as its own implementation.
/// </summary>
void Register(Type serviceType, Lifetime lifetime = Lifetime.Transient);
/// <summary>
/// Registers a service with an implementation type.
/// </summary>
void Register(Type serviceType, Type implementingType, Lifetime lifetime = Lifetime.Transient);
/// <summary>
/// Registers a service with an implementation factory.
/// </summary>
void Register<TService>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
where TService : class;
/// <summary>
/// Registers a service with an implementing instance.
/// </summary>
void Register(Type serviceType, object instance);
/// <summary>
/// Registers a service for a target, as its own implementation.
/// </summary>
/// <remarks>
/// There can only be one implementation or instanced registered for a service and target;
/// what happens if many are registered is not specified.
/// </remarks>
void RegisterFor<TService, TTarget>(Lifetime lifetime = Lifetime.Transient)
where TService : class;
/// <summary>
/// Registers a service for a target, with an implementation type.
/// </summary>
/// <remarks>
/// There can only be one implementation or instanced registered for a service and target;
/// what happens if many are registered is not specified.
/// </remarks>
void RegisterFor<TService, TTarget>(Type implementingType, Lifetime lifetime = Lifetime.Transient)
where TService : class;
/// <summary>
/// Registers a service for a target, with an implementation factory.
/// </summary>
/// <remarks>
/// There can only be one implementation or instanced registered for a service and target;
/// what happens if many are registered is not specified.
/// </remarks>
void RegisterFor<TService, TTarget>(Func<IFactory, TService> factory, Lifetime lifetime = Lifetime.Transient)
where TService : class;
/// <summary>
/// Registers a service for a target, with an implementing instance.
/// </summary>
/// <remarks>
/// There can only be one implementation or instanced registered for a service and target;
/// what happens if many are registered is not specified.
/// </remarks>
void RegisterFor<TService, TTarget>(TService instance)
where TService : class;
/// <summary>
/// Registers a base type for auto-registration.
/// </summary>
/// <remarks>
/// <para>Auto-registration means that anytime the container is asked to create an instance
/// of a type deriving from <paramref name="serviceBaseType"/>, it will first register that
/// type automatically.</para>
/// <para>This can be used for instance for views or controllers. Then, one just needs to
/// register a common base class or interface, and the container knows how to create instances.</para>
/// </remarks>
void RegisterAuto(Type serviceBaseType);
#region Control
/// <summary>
/// Configures the container for web support.
/// </summary>
/// <remarks>
/// <para>Enables support for MVC, WebAPI, but *not* per-request scope. This is used early in the boot
/// process, where anything "scoped" should not be linked to a web request.</para>
/// </remarks>
void ConfigureForWeb();
/// <summary>
/// Creates the factory.
/// </summary>
IFactory CreateFactory();
#endregion
}
}

49
src/Umbraco.Core/Composing/Lifetime.cs
View File

@@ -1,49 +0,0 @@
namespace Umbraco.Core.Composing
{
/// <summary>
/// Specifies the lifetime of a registered instance.
/// </summary>
public enum Lifetime
{
/// <summary>
/// Always get a new instance.
/// </summary>
/// <remarks>Corresponds to Transient in LightInject, Castle Windsor
/// or MS.DI, PerDependency in Autofac.</remarks>
Transient,
/// <summary>
/// One unique instance per request.
/// </summary>
// TODO: review lifetimes for LightInject vs other containers
// currently, corresponds to 'Request' in LightInject which is 'Transient + disposed by Scope'
// but NOT (in LightInject) a per-web-request lifetime, more a TransientScoped
//
// we use it for controllers, httpContextBase and umbracoContext
// - so that they are automatically disposed at the end of the scope (ie request)
// - not sure they should not be simply 'scoped'?
//
// Castle has an extra PerWebRequest something, and others use scope
// what about Request before first request ie during application startup?
// see http://blog.ploeh.dk/2009/11/17/UsingCastleWindsor'sPerWebRequestlifestylewithASP.NETMVConIIS7/
// Castle ends up requiring a special scope manager too
// see https://groups.google.com/forum/#!topic/castle-project-users/1E2W9LVIYR4
//
// but maybe also - why are we requiring scoped services at startup?
Request,
/// <summary>
/// One unique instance per container scope.
/// </summary>
/// <remarks>Corresponds to Scope in LightInject, Scoped in MS.DI
/// or Castle Windsor, PerLifetimeScope in Autofac.</remarks>
Scope,
/// <summary>
/// One unique instance per container.
/// </summary>
/// <remarks>Corresponds to Singleton in LightInject, Castle Windsor
/// or MS.DI and to SingleInstance in Autofac.</remarks>
Singleton
}
}

13
src/Umbraco.Core/IEmailSender.cs
View File

@@ -1,13 +0,0 @@
using System.Net.Mail;
using System.Threading.Tasks;
namespace Umbraco.Core
{
/// <summary>
/// Simple abstraction to send an email message
/// </summary>
public interface IEmailSender
{
Task SendAsync(MailMessage message);
}
}

83
src/Umbraco.Core/LambdaExpressionCacheKey.cs
View File

@@ -1,83 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
namespace Umbraco.Core
{
/// <summary>
/// Represents a simple <see cref="LambdaExpression"/> in a form which is suitable for using as a dictionary key
/// by exposing the return type, argument types and expression string form in a single concatenated string.
/// </summary>
internal struct LambdaExpressionCacheKey
{
public LambdaExpressionCacheKey(string returnType, string expression, params string[] argTypes)
{
ReturnType = returnType;
ExpressionAsString = expression;
ArgTypes = new HashSet<string>(argTypes);
_toString = null;
}
public LambdaExpressionCacheKey(LambdaExpression obj)
{
ReturnType = obj.ReturnType.FullName;
ExpressionAsString = obj.ToString();
ArgTypes = new HashSet<string>(obj.Parameters.Select(x => x.Type.FullName));
_toString = null;
}
/// <summary>
/// The argument type names of the <see cref="LambdaExpression"/>
/// </summary>
public readonly HashSet<string> ArgTypes;
/// <summary>
/// The return type of the <see cref="LambdaExpression"/>
/// </summary>
public readonly string ReturnType;
/// <summary>
/// The original string representation of the <see cref="LambdaExpression"/>
/// </summary>
public readonly string ExpressionAsString;
private string _toString;
/// <summary>
/// Returns a <see cref="System.String"/> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String"/> that represents this instance.
/// </returns>
public override string ToString()
{
return _toString ?? (_toString = String.Concat(String.Join("|", ArgTypes), ",", ReturnType, ",", ExpressionAsString));
}
/// <summary>
/// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
/// </summary>
/// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
/// <returns>
/// <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
/// </returns>
public override bool Equals(object obj)
{
if (ReferenceEquals(obj, null)) return false;
var casted = (LambdaExpressionCacheKey)obj;
return casted.ToString() == ToString();
}
/// <summary>
/// Returns a hash code for this instance.
/// </summary>
/// <returns>
/// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
/// </returns>
public override int GetHashCode()
{
return ToString().GetHashCode();
}
}
}

32
src/Umbraco.Core/MonitorLock.cs
View File

@@ -1,32 +0,0 @@
using System;
namespace Umbraco.Core
{
/// <summary>
/// Provides an equivalent to the c# lock statement, to be used in a using block.
/// </summary>
/// <remarks>Ie replace <c>lock (o) {...}</c> by <c>using (new MonitorLock(o)) { ... }</c></remarks>
public class MonitorLock : IDisposable
{
private readonly object _locker;
private readonly bool _entered;
/// <summary>
/// Initializes a new instance of the <see cref="MonitorLock"/> class with an object to lock.
/// </summary>
/// <param name="locker">The object to lock.</param>
/// <remarks>Should always be used within a using block.</remarks>
public MonitorLock(object locker)
{
_locker = locker;
_entered = false;
System.Threading.Monitor.Enter(_locker, ref _entered);
}
void IDisposable.Dispose()
{
if (_entered)
System.Threading.Monitor.Exit(_locker);
}
}
}

6
src/Umbraco.Core/Umbraco.Core.csproj
View File

@@ -196,10 +196,7 @@
<Compile Include="Composing\HideFromTypeFinderAttribute.cs" />
<Compile Include="Composing\IBuilderCollection.cs" />
<Compile Include="Composing\ICollectionBuilder.cs" />
<Compile Include="Composing\IFactory.cs" />
<Compile Include="Composing\IRegister.cs" />
<Compile Include="Composing\LazyCollectionBuilderBase.cs" />
<Compile Include="Composing\Lifetime.cs" />
<Compile Include="Composing\LightInject\LightInjectContainer.cs" />
<Compile Include="Composing\LightInject\MixedLightInjectScopeManagerProvider.cs" />
<Compile Include="Composing\OrderedCollectionBuilderBase.cs" />
@@ -619,7 +616,6 @@
<Compile Include="HashGenerator.cs" />
<Compile Include="HttpContextExtensions.cs" />
<Compile Include="IDisposeOnRequestEnd.cs" />
<Compile Include="IEmailSender.cs" />
<Compile Include="IntExtensions.cs" />
<Compile Include="IO\FileSecurityException.cs" />
<Compile Include="IO\FileSystemExtensions.cs" />
@@ -637,7 +633,6 @@
<Compile Include="IO\ViewHelper.cs" />
<Compile Include="IRuntime.cs" />
<Compile Include="IRuntimeState.cs" />
<Compile Include="LambdaExpressionCacheKey.cs" />
<Compile Include="Logging\DebugDiagnosticsLogger.cs" />
<Compile Include="Logging\Serilog\SerilogLogger.cs" />
<Compile Include="Logging\LoggingTaskExtension.cs" />
@@ -867,7 +862,6 @@
<Compile Include="Models\ObjectTypes.cs" />
<Compile Include="Models\UserExtensions.cs" />
<Compile Include="Models\Validation\RequiredForPersistenceAttribute.cs" />
<Compile Include="MonitorLock.cs" />
<Compile Include="NamedUdiRange.cs" />
<Compile Include="NameValueCollectionExtensions.cs" />
<Compile Include="NetworkHelper.cs" />