Merge pull request #4 from CrackAndDie/dev

New container implementation and more

Hypocrite.Avalonia/Container/LightContainerExtension.cs

@@ -56,13 +56,13 @@ public void FinalizeExtension()
 
  public Type GetRegistrationType(string key)
  {
- return Instance.Registrations.FirstOrDefault(x => x.Name == key)?.GetType();
+ return Instance.Registrations.Get(0, key)?.Value?.MappedToType;
  }
 
  public Type GetRegistrationType(Type serviceType)
  {
- var matchingRegistration = Instance.Registrations.Where(x => x.RegisteredType == serviceType).FirstOrDefault();
- return matchingRegistration?.MappedToType;
+ var matchingRegistration = Instance.Registrations.Get(serviceType.GetHashCode(), string.Empty);
+ return matchingRegistration?.Value?.MappedToType;
  }
 
  public bool IsRegistered(Type type)

Hypocrite.Avalonia/Localization/LocalizationChangedObservable.cs

@@ -1,10 +1,10 @@
 using Hypocrite.Core.Mvvm;
-using Hypocrite.Core.Mvvm.ObserverLogics;
 using Avalonia;
 using Avalonia.Data;
 using System;
 using System.ComponentModel;
 using System.Reflection;
+using Hypocrite.Core.Reactive;
 
 namespace Hypocrite.Localization
 {

Hypocrite.Avalonia/MVVM/ApplicationBase.cs

@@ -3,7 +3,6 @@
 using Hypocrite.Core.Container;
 using Hypocrite.Core.Interfaces;
 using Hypocrite.Core.Interfaces.Presentation;
-using Hypocrite.Core.Mvvm.Events;
 using Hypocrite.Core.Services;
 using Hypocrite.Core.Logging.Interfaces;
 using Hypocrite.Core.Logging.Services;
@@ -22,6 +21,7 @@
 using Prism.Services.Dialogs;
 using Prism;
 using Hypocrite.Container;
+using Hypocrite.Core.Events;
 
 namespace Hypocrite.Mvvm
 {

Hypocrite.Avalonia/MVVM/DialogViewModelBase.cs

@@ -1,11 +1,7 @@
 using Avalonia.Input;
-using Hypocrite.Core.Mvvm.Events;
-using Prism.Commands;
+using Hypocrite.Core.Events;
 using Prism.Services.Dialogs;
 using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows.Input;
 
 namespace Hypocrite.Mvvm
 {

Hypocrite.Avalonia/MVVM/ViewModelBase.cs

@@ -7,7 +7,7 @@
 
 namespace Hypocrite.Mvvm
 {
- public class ViewModelBase : EngineViewModelBase, INavigationAware
+ public class ViewModelBase : CoreViewModelBase, INavigationAware
  {
  public ViewModelBase()
  {

Hypocrite.Benchmarks/Container/ContainerTestClass.cs

@@ -0,0 +1,14 @@
+namespace Hypocrite.Benchmarks.Container
+{
+ public class ContainerTestClass
+ {
+ public int Id { get; set; }
+ public string Name { get; set; }
+
+ public ContainerTestClass(int id, string name)
+ {
+ Id = id;
+ Name = name;
+ }
+ }
+}

Hypocrite.Benchmarks/Container/ContainerTestClass2.cs

@@ -0,0 +1,8 @@
+namespace Hypocrite.Benchmarks.Container
+{
+ public class ContainerTestClass2
+ {
+ public int Id { get; set; }
+ public string Name { get; set; }
+ }
+}

Hypocrite.Benchmarks/Container/ContainerTestClass3.cs

@@ -0,0 +1,21 @@
+using Hypocrite.Core.Container;
+using Unity;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ public class ContainerTestClass3Light
+ {
+ public int Id { get; set; }
+ public string Name { get; set; }
+ [Injection]
+ public ContainerTestClass2 TestClass { get; set; }
+ }
+
+ public class ContainerTestClass3Unity
+ {
+ public int Id { get; set; }
+ public string Name { get; set; }
+ [Dependency]
+ public ContainerTestClass2 TestClass { get; set; }
+ }
+}

Hypocrite.Benchmarks/Container/ContainerTestClass4.cs

@@ -0,0 +1,29 @@
+using Hypocrite.Core.Container;
+using Unity;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ public class ContainerTestClass4Light
+ {
+ public int Id { get; set; }
+ public string Name { get; set; }
+ public ContainerTestClass2 TestClass { get; set; }
+
+ public ContainerTestClass4Light([Injection] ContainerTestClass2 testClass)
+ {
+ TestClass = testClass;
+ }
+ }
+
+ public class ContainerTestClass4Unity
+ {
+ public int Id { get; set; }
+ public string Name { get; set; }
+ public ContainerTestClass2 TestClass { get; set; }
+
+ public ContainerTestClass4Unity([Dependency] ContainerTestClass2 testClass)
+ {
+ TestClass = testClass;
+ }
+ }
+}

Hypocrite.Benchmarks/Container/IsRegistered.cs

@@ -0,0 +1,34 @@
+using BenchmarkDotNet.Attributes;
+using Hypocrite.Core.Container;
+using Hypocrite.Core.Container.Interfaces;
+using Unity;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ [MemoryDiagnoser]
+ public class IsRegistered
+ {
+ ILightContainer _lightContainer;
+ IUnityContainer _unityContainer;
+
+ public IsRegistered()
+ {
+ _lightContainer = new LightContainer();
+ _lightContainer.RegisterType(typeof(ContainerTestClass2), typeof(ContainerTestClass2));
+ _unityContainer = new UnityContainer();
+ _unityContainer.RegisterType<ContainerTestClass2>();
+ }
+
+ [Benchmark]
+ public bool WithUnityContainer()
+ {
+ return _unityContainer.IsRegistered<ContainerTestClass2>();
+ }
+
+ [Benchmark]
+ public bool WithLightContainer()
+ {
+ return _lightContainer.IsRegistered(typeof(ContainerTestClass2));
+ }
+ }
+}

Hypocrite.Benchmarks/Container/LightContainerSteps.cs

@@ -0,0 +1,48 @@
+using BenchmarkDotNet.Attributes;
+using Hypocrite.Core.Container;
+using Hypocrite.Core.Container.Extensions;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ [MemoryDiagnoser]
+ public class LightContainerSteps
+ {
+ LightContainer _lightContainer;
+
+ public LightContainerSteps()
+ {
+ _lightContainer = new LightContainer();
+ _lightContainer.RegisterType(typeof(ContainerTestClass2), typeof(ContainerTestClass2), false);
+ }
+
+ [Benchmark]
+ public void IsRegistered()
+ {
+ _lightContainer.IsRegistered(typeof(ContainerTestClass2));
+ }
+
+ [Benchmark]
+ public void GetRegistration()
+ {
+ _lightContainer.GetRegistration(typeof(ContainerTestClass2), string.Empty);
+ }
+
+ // it takes about 60ns
+ // var _ = reg.RegistrationPolicy.CreateInstance(true);
+
+ [Benchmark]
+ public void CreatePureInstance()
+ {
+ var reg = _lightContainer.GetRegistration(typeof(ContainerTestClass2), string.Empty);
+ var _ = _lightContainer.InstanceCreator.CreatePureInstance(reg);
+ }
+
+ [Benchmark]
+ public void CreateInstance()
+ {
+ var reg = _lightContainer.GetRegistration(typeof(ContainerTestClass2), string.Empty);
+ var inst = _lightContainer.InstanceCreator.CreatePureInstance(reg);
+ _lightContainer.InstanceCreator.ResolveInjections(inst, reg.MemberInjectionInfo);
+ }
+ }
+}

Hypocrite.Benchmarks/Container/ResolveOverloadType.cs

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using Hypocrite.Core.Container;
+using Hypocrite.Core.Container.Interfaces;
+using Hypocrite.Core.Container.Extensions;
+using Unity;
+using System.Collections.Generic;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ [MemoryDiagnoser]
+ public class ResolveOverloadType
+ {
+ ILightContainer _lightContainer;
+ IUnityContainer _unityContainer;
+
+ public ResolveOverloadType()
+ {
+ _lightContainer = new LightContainer();
+ _unityContainer = new UnityContainer();
+
+ for (char c = 'A'; c <= 'Z'; ++c)
+ {
+ _lightContainer.RegisterType<ContainerTestClass2>(c.ToString());
+ _unityContainer.RegisterType<ContainerTestClass2>(c.ToString());
+ }
+ }
+
+ [Benchmark]
+ public ContainerTestClass2 WithUnityContainer()
+ {
+ return _unityContainer.Resolve<ContainerTestClass2>("K");
+ }
+
+ [Benchmark]
+ public ContainerTestClass2 WithLightContainer()
+ {
+ return _lightContainer.Resolve<ContainerTestClass2>("K");
+ }
+ }
+}

Hypocrite.Benchmarks/Container/ResolveSingleton.cs

@@ -0,0 +1,35 @@
+using BenchmarkDotNet.Attributes;
+using Hypocrite.Core.Container;
+using Hypocrite.Core.Container.Interfaces;
+using System.Linq.Expressions;
+using Unity;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ [MemoryDiagnoser]
+ public class ResolveSingleton
+ {
+ ILightContainer _lightContainer;
+ IUnityContainer _unityContainer;
+
+ public ResolveSingleton() 
+ {
+ _lightContainer = new LightContainer();
+ _lightContainer.RegisterType(typeof(ContainerTestClass2), typeof(ContainerTestClass2), true);
+ _unityContainer = new UnityContainer();
+ _unityContainer.RegisterSingleton<ContainerTestClass2>();
+ }
+
+ [Benchmark]
+ public ContainerTestClass2 WithUnityContainer()
+ {
+ return _unityContainer.Resolve<ContainerTestClass2>();
+ }
+
+ [Benchmark]
+ public ContainerTestClass2 WithLightContainer()
+ {
+ return _lightContainer.Resolve(typeof(ContainerTestClass2)) as ContainerTestClass2;
+ }
+ }
+}

Hypocrite.Benchmarks/Container/ResolveType.cs

@@ -0,0 +1,34 @@
+using BenchmarkDotNet.Attributes;
+using Hypocrite.Core.Container;
+using Hypocrite.Core.Container.Interfaces;
+using Unity;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ [MemoryDiagnoser]
+ public class ResolveType
+ {
+ ILightContainer _lightContainer;
+ IUnityContainer _unityContainer;
+
+ public ResolveType()
+ {
+ _lightContainer = new LightContainer();
+ _lightContainer.RegisterType(typeof(ContainerTestClass2), typeof(ContainerTestClass2));
+ _unityContainer = new UnityContainer();
+ _unityContainer.RegisterType<ContainerTestClass2>();
+ }
+
+ [Benchmark]
+ public ContainerTestClass2 WithUnityContainer()
+ {
+ return _unityContainer.Resolve<ContainerTestClass2>();
+ }
+
+ [Benchmark]
+ public ContainerTestClass2 WithLightContainer()
+ {
+ return _lightContainer.Resolve(typeof(ContainerTestClass2)) as ContainerTestClass2;
+ }
+ }
+}

Hypocrite.Benchmarks/Container/ResolveTypeWithCtorInjection.cs

@@ -0,0 +1,36 @@
+using BenchmarkDotNet.Attributes;
+using Hypocrite.Core.Container;
+using Hypocrite.Core.Container.Interfaces;
+using Unity;
+
+namespace Hypocrite.Benchmarks.Container
+{
+ [MemoryDiagnoser]
+ public class ResolveTypeWithCtorInjection
+ {
+ ILightContainer _lightContainer;
+ IUnityContainer _unityContainer;
+
+ public ResolveTypeWithCtorInjection()
+ {
+ _lightContainer = new LightContainer();
+ _lightContainer.RegisterType(typeof(ContainerTestClass2), typeof(ContainerTestClass2));
+ _lightContainer.RegisterType(typeof(ContainerTestClass4Light), typeof(ContainerTestClass4Light));
+ _unityContainer = new UnityContainer();
+ _unityContainer.RegisterType<ContainerTestClass2>();
+ _unityContainer.RegisterType<ContainerTestClass4Unity>();
+ }
+
+ [Benchmark]
+ public int WithUnityContainer()
+ {
+ return _unityContainer.Resolve<ContainerTestClass4Unity>().TestClass.Id;
+ }
+
+ [Benchmark]
+ public int WithLightContainer()
+ {
+ return (_lightContainer.Resolve(typeof(ContainerTestClass4Light)) as ContainerTestClass4Light).TestClass.Id;
+ }
+ }
+}