Refactor

src/stashbox.tests/DecoratorTests.cs

@@ -481,6 +481,19 @@ public void DecoratorTests_RemapDecorator_V2()
             }
         }
 
+        [TestMethod]
+        public void DecoratorTests_Service_ImplementationType()
+        {
+            using (var container = new StashboxContainer())
+            {
+                container.RegisterDecorator<ITest1, TestDecorator1>(context =>
+                {
+                    Assert.AreEqual(typeof(ITest1), context.ServiceType);
+                    Assert.AreEqual(typeof(TestDecorator1), context.ImplementationType);
+                });
+            }
+        }
+
         public interface ITest1 { ITest1 Test { get; } }
 
         public interface IDecoratorDep { }

src/stashbox.tests/WireUpTests.cs

@@ -79,7 +79,7 @@ public void InjectionMemberTests_WireUp_WithoutService()
             {
                 container.RegisterType<ITest, Test>();
                 var test1 = new Test1();
-                container.WireUpAs(test1);
+                container.WireUp(test1);
                 var inst = container.Resolve<Test1>();
 
                 Assert.IsNotNull(inst);

src/stashbox/Infrastructure/IDependencyRegistrator.cs

@@ -104,6 +104,15 @@ IDependencyRegistrator RegisterType<TTo>(Action<IFluentServiceRegistrator> confi
         /// <returns>The <see cref="IDependencyRegistrator"/> which on this method was called.</returns>
         IDependencyRegistrator WireUp(Type serviceType, object instance, object name = null, bool withoutDisposalTracking = false);
 
+        /// <summary>
+        /// Registers an already constructed instance, but the container will perform injections and extensions on it.
+        /// </summary>
+        /// <param name="instance">The constructed object.</param>
+        /// <param name="name">The name of the registration.</param>
+        /// <param name="withoutDisposalTracking">If it's set to true the container will exclude the instance from the disposal tracking.</param>
+        /// <returns>The <see cref="IDependencyRegistrator"/> which on this method was called.</returns>
+        IDependencyRegistrator WireUp(object instance, object name = null, bool withoutDisposalTracking = false);
+
         /// <summary>
         /// Registers a type with singleton lifetime.
         /// </summary>

src/stashbox/Infrastructure/Registration/IBaseFluentRegistrator.cs

@@ -11,6 +11,16 @@ namespace Stashbox.Infrastructure.Registration
     /// </summary>
     public interface IBaseFluentRegistrator<out TFluentRegistrator>
     {
+        /// <summary>
+        /// The service type.
+        /// </summary>
+        Type ServiceType { get; }
+
+        /// <summary>
+        /// The implementation type.
+        /// </summary>
+        Type ImplementationType { get; }
+
         /// <summary>
         /// Sets injection parameters for the registration.
         /// </summary>

src/stashbox/Infrastructure/Registration/IFluentServiceRegistrator.cs

@@ -8,16 +8,6 @@ namespace Stashbox.Infrastructure.Registration
     /// </summary>
     public interface IFluentServiceRegistrator : IBaseFluentRegistrator<IFluentServiceRegistrator>
     {
-        /// <summary>
-        /// The service type.
-        /// </summary>
-        Type ServiceType { get; }
-
-        /// <summary>
-        /// The implementation type.
-        /// </summary>
-        Type ImplementationType { get; }
-
         /// <summary>
         /// Sets the lifetime of the registration.
         /// </summary>

src/stashbox/Registration/DecoratorRegistrationContext.cs

@@ -13,12 +13,20 @@ internal class DecoratorRegistrationContext : IDecoratorRegistrationContext
         private readonly IServiceRegistrator serviceRegistrator;
         private bool replaceExistingRegistration;
 
+        public Type ServiceType => this.registrationContext.ServiceType;
+
+        public Type ImplementationType => this.registrationContext.ImplementationType;
+
         public DecoratorRegistrationContext(RegistrationContext registrationContext, IServiceRegistrator serviceRegistrator)
         {
             this.registrationContext = registrationContext;
             this.serviceRegistrator = serviceRegistrator;
         }
 
+        public IStashboxContainer Register() => this.serviceRegistrator.Register(this.registrationContext, true, this.replaceExistingRegistration);
+
+        public IStashboxContainer ReMap() => this.serviceRegistrator.ReMap(this.registrationContext, true);
+
         public IFluentDecoratorRegistrator WithInjectionParameters(params InjectionParameter[] injectionParameters)
         {
             this.registrationContext.WithInjectionParameters(injectionParameters);
@@ -44,10 +52,6 @@ public IFluentDecoratorRegistrator WithoutDisposalTracking()
             return this;
         }
 
-        public IStashboxContainer Register() => this.serviceRegistrator.Register(this.registrationContext, true, this.replaceExistingRegistration);
-
-        public IStashboxContainer ReMap() => this.serviceRegistrator.ReMap(this.registrationContext, true);
-
         public IFluentDecoratorRegistrator ReplaceExisting()
         {
             this.replaceExistingRegistration = true;

src/stashbox/StashboxContainer.Registrator.cs

@@ -67,6 +67,10 @@ public IDependencyRegistrator RegisterInstance(Type serviceType, object instance
         public IDependencyRegistrator WireUpAs<TFrom>(TFrom instance, object name = null, bool withoutDisposalTracking = false) =>
             this.WireUp(typeof(TFrom), instance, name, withoutDisposalTracking);
 
+        /// <inheritdoc />
+        public IDependencyRegistrator WireUp(object instance, object name = null, bool withoutDisposalTracking = false) =>
+            this.WireUp(instance.GetType(), instance, name, withoutDisposalTracking);
+
         /// <inheritdoc />
         public IDependencyRegistrator WireUp(Type serviceType, object instance, object name = null, bool withoutDisposalTracking = false)
         {