Skip to content

Commit

Permalink
- Cleanup namespaces to file scoped namespaces
Browse files Browse the repository at this point in the history
  • Loading branch information
@RonSijm
RonSijm committed Jan 12, 2024
1 parent d082853 commit e1ee06e
Show file tree
Hide file tree
Showing 29 changed files with 1,465 additions and 1,487 deletions.
5 changes: 0 additions & 5 deletions src/RonSijm.Blazyload/Features/DIComponents/BlazyServiceProvider.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,11 +2,6 @@

namespace RonSijm.Blazyload.Features.DIComponents;

public interface IBlazyInternalServiceProvider
{
bool TryGetServiceFromOverride(Type serviceType, out object value);
}

public class BlazyServiceProvider : IServiceProvider, IBlazyInternalServiceProvider
{
private readonly ServiceCollection _services = new();
Expand Down
6 changes: 6 additions & 0 deletions src/RonSijm.Blazyload/Features/DIComponents/IBlazyInternalServiceProvider.cs
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
namespace RonSijm.Blazyload.Features.DIComponents;

public interface IBlazyInternalServiceProvider
{
bool TryGetServiceFromOverride(Type serviceType, out object value);
}
253 changes: 126 additions & 127 deletions src/RonSijm.Blazyload/MicrosoftServiceProvider/MicrosoftServiceProvider.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,179 +4,178 @@
using System.Collections.Concurrent;
using RonSijm.Blazyload.MicrosoftServiceProvider.ServiceLookup;

namespace RonSijm.Blazyload.MicrosoftServiceProvider
namespace RonSijm.Blazyload.MicrosoftServiceProvider;

public sealed class MicrosoftServiceProvider : IServiceProvider, IDisposable, IAsyncDisposable
{
public sealed class MicrosoftServiceProvider : IServiceProvider, IDisposable, IAsyncDisposable
{
private readonly CallSiteValidator _callSiteValidator;
private readonly CallSiteValidator _callSiteValidator;

private readonly Func<Type, Func<ServiceProviderEngineScope, object>> _createServiceAccessor;
private readonly Func<Type, Func<ServiceProviderEngineScope, object>> _createServiceAccessor;

// Internal for testing
private readonly ServiceProviderEngine _engine;
// Internal for testing
private readonly ServiceProviderEngine _engine;

private bool _disposed;
private bool _disposed;

private readonly ConcurrentDictionary<Type, Func<ServiceProviderEngineScope, object>> _realizedServices;
private readonly ConcurrentDictionary<Type, Func<ServiceProviderEngineScope, object>> _realizedServices;

private CallSiteFactory CallSiteFactory { get; }
private CallSiteFactory CallSiteFactory { get; }

internal ServiceProviderEngineScope Root { get; }
internal ServiceProviderEngineScope Root { get; }

internal static bool VerifyOpenGenericServiceTrimmability { get; } = AppContext.TryGetSwitch("Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability", out var verifyOpenGenerics) && verifyOpenGenerics;
internal static bool VerifyOpenGenericServiceTrimmability { get; } = AppContext.TryGetSwitch("Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability", out var verifyOpenGenerics) && verifyOpenGenerics;

public MicrosoftServiceProvider(ICollection<ServiceDescriptor> serviceDescriptors, ServiceProviderOptions options, IBlazyInternalServiceProvider internalServiceProvider)
public MicrosoftServiceProvider(ICollection<ServiceDescriptor> serviceDescriptors, ServiceProviderOptions options, IBlazyInternalServiceProvider internalServiceProvider)
{
// note that Root needs to be set before calling GetEngine(), because the engine may need to access Root
Root = new ServiceProviderEngineScope(this, isRootScope: true);
_engine = GetEngine();
_createServiceAccessor = CreateServiceAccessor;
_realizedServices = new ConcurrentDictionary<Type, Func<ServiceProviderEngineScope, object>>();

CallSiteFactory = new CallSiteFactory(serviceDescriptors, internalServiceProvider);
// The list of built in services that aren't part of the list of service descriptors
// keep this in sync with CallSiteFactory.IsService
CallSiteFactory.Add(typeof(IServiceProvider), new ServiceProviderCallSite());
CallSiteFactory.Add(typeof(IServiceScopeFactory), new ConstantCallSite(typeof(IServiceScopeFactory), Root));
CallSiteFactory.Add(typeof(IServiceProviderIsService), new ConstantCallSite(typeof(IServiceProviderIsService), CallSiteFactory));

if (options.ValidateScopes)
{
// note that Root needs to be set before calling GetEngine(), because the engine may need to access Root
Root = new ServiceProviderEngineScope(this, isRootScope: true);
_engine = GetEngine();
_createServiceAccessor = CreateServiceAccessor;
_realizedServices = new ConcurrentDictionary<Type, Func<ServiceProviderEngineScope, object>>();

CallSiteFactory = new CallSiteFactory(serviceDescriptors, internalServiceProvider);
// The list of built in services that aren't part of the list of service descriptors
// keep this in sync with CallSiteFactory.IsService
CallSiteFactory.Add(typeof(IServiceProvider), new ServiceProviderCallSite());
CallSiteFactory.Add(typeof(IServiceScopeFactory), new ConstantCallSite(typeof(IServiceScopeFactory), Root));
CallSiteFactory.Add(typeof(IServiceProviderIsService), new ConstantCallSite(typeof(IServiceProviderIsService), CallSiteFactory));

if (options.ValidateScopes)
{
_callSiteValidator = new CallSiteValidator();
}
_callSiteValidator = new CallSiteValidator();
}

if (options.ValidateOnBuild)
if (options.ValidateOnBuild)
{
List<Exception> exceptions = null;
foreach (var serviceDescriptor in serviceDescriptors)
{
List<Exception> exceptions = null;
foreach (var serviceDescriptor in serviceDescriptors)
try
{
try
{
ValidateService(serviceDescriptor);
}
catch (Exception e)
{
exceptions ??= new List<Exception>();
exceptions.Add(e);
}
ValidateService(serviceDescriptor);
}

if (exceptions != null)
catch (Exception e)
{
throw new AggregateException("Some services are not able to be constructed", exceptions.ToArray());
exceptions ??= new List<Exception>();
exceptions.Add(e);
}
}

if (exceptions != null)
{
throw new AggregateException("Some services are not able to be constructed", exceptions.ToArray());
}
}
}

/// <inheritdoc />
/// <summary>
/// Gets the service object of the specified type.
/// </summary>
/// <param name="serviceType">The type of the service to get.</param>
/// <returns>The service that was produced.</returns>
public object GetService(Type serviceType) => GetService(serviceType, Root);
/// <inheritdoc />
/// <summary>
/// Gets the service object of the specified type.
/// </summary>
/// <param name="serviceType">The type of the service to get.</param>
/// <returns>The service that was produced.</returns>
public object GetService(Type serviceType) => GetService(serviceType, Root);

internal bool IsDisposed() => _disposed;
internal bool IsDisposed() => _disposed;

/// <inheritdoc />
public void Dispose()
{
DisposeCore();
Root.Dispose();
}
/// <inheritdoc />
public void Dispose()
{
DisposeCore();
Root.Dispose();
}

/// <inheritdoc/>
public ValueTask DisposeAsync()
{
DisposeCore();
return Root.DisposeAsync();
}
/// <inheritdoc/>
public ValueTask DisposeAsync()
{
DisposeCore();
return Root.DisposeAsync();
}

private void DisposeCore()
{
_disposed = true;
}
private void DisposeCore()
{
_disposed = true;
}

private void OnCreate(ServiceCallSite callSite)
{
_callSiteValidator?.ValidateCallSite(callSite);
}
private void OnCreate(ServiceCallSite callSite)
{
_callSiteValidator?.ValidateCallSite(callSite);
}

private void OnResolve(Type serviceType, IServiceScope scope)
{
_callSiteValidator?.ValidateResolution(serviceType, scope, Root);
}
private void OnResolve(Type serviceType, IServiceScope scope)
{
_callSiteValidator?.ValidateResolution(serviceType, scope, Root);
}

internal object GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
internal object GetService(Type serviceType, ServiceProviderEngineScope serviceProviderEngineScope)
{
if (_disposed)
{
if (_disposed)
{
ThrowHelper.ThrowObjectDisposedException();
}
ThrowHelper.ThrowObjectDisposedException();
}

var realizedService = _realizedServices.GetOrAdd(serviceType, _createServiceAccessor);
OnResolve(serviceType, serviceProviderEngineScope);
var realizedService = _realizedServices.GetOrAdd(serviceType, _createServiceAccessor);
OnResolve(serviceType, serviceProviderEngineScope);

var result = realizedService.Invoke(serviceProviderEngineScope);
//System.Diagnostics.Debug.Assert(result is null || CallSiteFactory.IsService(serviceType));
return result;
}
var result = realizedService.Invoke(serviceProviderEngineScope);
//System.Diagnostics.Debug.Assert(result is null || CallSiteFactory.IsService(serviceType));
return result;
}

private void ValidateService(ServiceDescriptor descriptor)
private void ValidateService(ServiceDescriptor descriptor)
{
if (descriptor.ServiceType.IsGenericType && !descriptor.ServiceType.IsConstructedGenericType)
{
if (descriptor.ServiceType.IsGenericType && !descriptor.ServiceType.IsConstructedGenericType)
{
return;
}

try
{
var callSite = CallSiteFactory.GetCallSite(descriptor, new CallSiteChain());
if (callSite != null)
{
OnCreate(callSite);
}
}
catch (Exception e)
{
throw new InvalidOperationException($"Error while validating the service descriptor '{descriptor}': {e.Message}", e);
}
return;
}

private Func<ServiceProviderEngineScope, object> CreateServiceAccessor(Type serviceType)
try
{
var callSite = CallSiteFactory.GetCallSite(serviceType, new CallSiteChain());
var callSite = CallSiteFactory.GetCallSite(descriptor, new CallSiteChain());
if (callSite != null)
{
OnCreate(callSite);

// Optimize singleton case
if (callSite.Cache.Location == CallSiteResultCacheLocation.Root)
{
var value = CallSiteRuntimeResolver.Instance.Resolve(callSite, Root);
return _ => value;
}

return _engine.RealizeService(callSite);
}

return _ => null;
}
catch (Exception e)
{
throw new InvalidOperationException($"Error while validating the service descriptor '{descriptor}': {e.Message}", e);
}
}

internal IServiceScope CreateScope()
private Func<ServiceProviderEngineScope, object> CreateServiceAccessor(Type serviceType)
{
var callSite = CallSiteFactory.GetCallSite(serviceType, new CallSiteChain());
if (callSite != null)
{
if (_disposed)
OnCreate(callSite);

// Optimize singleton case
if (callSite.Cache.Location == CallSiteResultCacheLocation.Root)
{
ThrowHelper.ThrowObjectDisposedException();
var value = CallSiteRuntimeResolver.Instance.Resolve(callSite, Root);
return _ => value;
}

return new ServiceProviderEngineScope(this, isRootScope: false);
return _engine.RealizeService(callSite);
}

private ServiceProviderEngine GetEngine()
{
return _ => null;
}

return RuntimeServiceProviderEngine.Instance;
internal IServiceScope CreateScope()
{
if (_disposed)
{
ThrowHelper.ThrowObjectDisposedException();
}

return new ServiceProviderEngineScope(this, isRootScope: false);
}

private ServiceProviderEngine GetEngine()
{

return RuntimeServiceProviderEngine.Instance;
}
}
}
Loading

0 comments on commit e1ee06e

Please sign in to comment.