C# ninject-在请求期间向现有对象注入依赖项

Ninject为我创建了依赖于类B的类A的实例（所以Ninject也创建了对象B）。Ninject配置为返回类A的单个实例（InSingletonScope）和类B的多个实例（InTrancientScope）。 类A具有允许获取/设置对象B的依赖关系的属性

每次我请求类A的相同实例时，是否可以使用新创建的实例B检索类A的实例

如果对每个请求都执行OnActivation方法，而不仅仅是第一次执行，那么它就可以做到这一点

或者这是我要做的反模式

编辑： 为了避免XY问题，我将尝试解释更多细节。这个解决方案太大了，无法解释长话短说的一切：

有一个操作要做，例如盘点。该操作由三名演示者（P1、P2、P3）完成。演示者管理相应的视图（V1、V2、V3）。用户在视图中输入数据，演示者从视图中获取数据并保存到操作。 所有演示者和视图都是单例（InSingletonScope），以避免在每次需要时创建对象。视图被注入到适当的演示者中。

---

每次操作开始时，都应创建新的操作实例，并将其注入所有已存在的演示者。

每当您向IOC请求演示者时，它都会返回具有相同操作工厂的相同演示者。如果将IsValid设置为false，则操作工厂可以返回相同对象或新对象。 为解决此问题而创建的示例代码：

操作：

public abstract class Operation
    {
        protected Logger logger;

        public Operation(Logger logger)
        {
            this.logger = logger;
        }
    }


public class StocktakingOperation : Operation
    {
        public string test = DateTime.Now.ToString();

        public StocktakingOperation(Logger logger)
            : base(logger)
        {

        }
    }

class OperationFactory<T> where T : Operation
    {
        private Func<T> ObjectCreation;

        private T ValidObject;


        public OperationFactory(Func<T> ObjectCreation)
        {
            IsValid = false;
            this.ObjectCreation = ObjectCreation;
        }


        /// <summary>
        /// While is True then the same operation is returned.
        /// Set it to False to invalidate current operation so the next call to get operation will return new operation.
        /// </summary>
        public bool IsValid { get; set; }



        public T GetOperation()
        {
            if (IsValid == false)
            {
                ValidObject = ObjectCreation();
                IsValid = true;
            }

            return ValidObject;
        }

    }


class StocktakingOperationFactory : OperationFactory<StocktakingOperation>
    {
        public StocktakingOperationFactory(Func<StocktakingOperation> ObjectCreation)
            : base(ObjectCreation)
        {

        }
    }

kernel.Bind<StocktakingOperation>().ToSelf();

kernel.Bind<StocktakingOperationFactory>().ToMethod(c =>
            new StocktakingOperationFactory(() => { return kernel.Get<StocktakingOperation>(); })
            ).InSingletonScope();
kernel.Bind<StocktakingPresenter>().ToSelf().InSingletonScope();

工厂：

public abstract class Operation
    {
        protected Logger logger;

        public Operation(Logger logger)
        {
            this.logger = logger;
        }
    }


public class StocktakingOperation : Operation
    {
        public string test = DateTime.Now.ToString();

        public StocktakingOperation(Logger logger)
            : base(logger)
        {

        }
    }

class OperationFactory<T> where T : Operation
    {
        private Func<T> ObjectCreation;

        private T ValidObject;


        public OperationFactory(Func<T> ObjectCreation)
        {
            IsValid = false;
            this.ObjectCreation = ObjectCreation;
        }


        /// <summary>
        /// While is True then the same operation is returned.
        /// Set it to False to invalidate current operation so the next call to get operation will return new operation.
        /// </summary>
        public bool IsValid { get; set; }



        public T GetOperation()
        {
            if (IsValid == false)
            {
                ValidObject = ObjectCreation();
                IsValid = true;
            }

            return ValidObject;
        }

    }


class StocktakingOperationFactory : OperationFactory<StocktakingOperation>
    {
        public StocktakingOperationFactory(Func<StocktakingOperation> ObjectCreation)
            : base(ObjectCreation)
        {

        }
    }

kernel.Bind<StocktakingOperation>().ToSelf();

kernel.Bind<StocktakingOperationFactory>().ToMethod(c =>
            new StocktakingOperationFactory(() => { return kernel.Get<StocktakingOperation>(); })
            ).InSingletonScope();
kernel.Bind<StocktakingPresenter>().ToSelf().InSingletonScope();

类别操作工厂，其中T:操作
{
私有Func对象创建；
私人T ValidObject；
公共操作工厂（Func对象创建）
{
IsValid=false；
this.ObjectCreation=ObjectCreation；
}
/// 
///如果为True，则返回相同的操作。
///将其设置为False将使当前操作无效，以便下一次调用get操作将返回新操作。
/// 
公共bool有效{get；set；}
公共T GetOperation（）
{
if（IsValid==false）
{
ValidObject=ObjectCreation（）；
IsValid=true；
}
返回有效对象；
}
}
分类盘点操作工厂：操作工厂
{
公共库存操作工厂（Func对象创建）
：base（ObjectCreation）
{
}
}

演示者

class StocktakingPresenter : BaseOperationPresenter<StocktakingPresentersManager, OPERATION_TYPE>
    {

        public StocktakingPresenter(QuickForm QuickForm, StocktakingOperationFactory OperationFactory, VIEW_TYPE view, Workspace workspace, Logger logger)
            : base(QuickForm, OperationFactory, view, workspace, logger)
        {}


    }

class StocktakingPresenter:BaseOperationPresenter
{
公共盘点演示者（快速表单快速表单，盘点操作工厂操作工厂，视图类型视图，工作区工作区，记录器）
：基本（快速表单、操作工厂、视图、工作区、记录器）
{}
}

和国际奥委会：

public abstract class Operation
    {
        protected Logger logger;

        public Operation(Logger logger)
        {
            this.logger = logger;
        }
    }


public class StocktakingOperation : Operation
    {
        public string test = DateTime.Now.ToString();

        public StocktakingOperation(Logger logger)
            : base(logger)
        {

        }
    }

class OperationFactory<T> where T : Operation
    {
        private Func<T> ObjectCreation;

        private T ValidObject;


        public OperationFactory(Func<T> ObjectCreation)
        {
            IsValid = false;
            this.ObjectCreation = ObjectCreation;
        }


        /// <summary>
        /// While is True then the same operation is returned.
        /// Set it to False to invalidate current operation so the next call to get operation will return new operation.
        /// </summary>
        public bool IsValid { get; set; }



        public T GetOperation()
        {
            if (IsValid == false)
            {
                ValidObject = ObjectCreation();
                IsValid = true;
            }

            return ValidObject;
        }

    }


class StocktakingOperationFactory : OperationFactory<StocktakingOperation>
    {
        public StocktakingOperationFactory(Func<StocktakingOperation> ObjectCreation)
            : base(ObjectCreation)
        {

        }
    }

kernel.Bind<StocktakingOperation>().ToSelf();

kernel.Bind<StocktakingOperationFactory>().ToMethod(c =>
            new StocktakingOperationFactory(() => { return kernel.Get<StocktakingOperation>(); })
            ).InSingletonScope();
kernel.Bind<StocktakingPresenter>().ToSelf().InSingletonScope();

kernel.Bind（）.ToSelf（）；
kernel.Bind（）.ToMethod（c=>
新StocktakingOperationFactory（（）=>{return kernel.Get（）；}）
).InSingletonScope（）；
kernel.Bind（）.ToSelf（）.InSingletonScope（）；

每当您向IOC请求演示者时，它都会返回具有相同操作工厂的相同演示者。如果将IsValid设置为false，则操作工厂可以返回相同对象或新对象。 为解决此问题而创建的示例代码：

操作：

public abstract class Operation
    {
        protected Logger logger;

        public Operation(Logger logger)
        {
            this.logger = logger;
        }
    }


public class StocktakingOperation : Operation
    {
        public string test = DateTime.Now.ToString();

        public StocktakingOperation(Logger logger)
            : base(logger)
        {

        }
    }

class OperationFactory<T> where T : Operation
    {
        private Func<T> ObjectCreation;

        private T ValidObject;


        public OperationFactory(Func<T> ObjectCreation)
        {
            IsValid = false;
            this.ObjectCreation = ObjectCreation;
        }


        /// <summary>
        /// While is True then the same operation is returned.
        /// Set it to False to invalidate current operation so the next call to get operation will return new operation.
        /// </summary>
        public bool IsValid { get; set; }



        public T GetOperation()
        {
            if (IsValid == false)
            {
                ValidObject = ObjectCreation();
                IsValid = true;
            }

            return ValidObject;
        }

    }


class StocktakingOperationFactory : OperationFactory<StocktakingOperation>
    {
        public StocktakingOperationFactory(Func<StocktakingOperation> ObjectCreation)
            : base(ObjectCreation)
        {

        }
    }

kernel.Bind<StocktakingOperation>().ToSelf();

kernel.Bind<StocktakingOperationFactory>().ToMethod(c =>
            new StocktakingOperationFactory(() => { return kernel.Get<StocktakingOperation>(); })
            ).InSingletonScope();
kernel.Bind<StocktakingPresenter>().ToSelf().InSingletonScope();

工厂：

public abstract class Operation
    {
        protected Logger logger;

        public Operation(Logger logger)
        {
            this.logger = logger;
        }
    }


public class StocktakingOperation : Operation
    {
        public string test = DateTime.Now.ToString();

        public StocktakingOperation(Logger logger)
            : base(logger)
        {

        }
    }

class OperationFactory<T> where T : Operation
    {
        private Func<T> ObjectCreation;

        private T ValidObject;


        public OperationFactory(Func<T> ObjectCreation)
        {
            IsValid = false;
            this.ObjectCreation = ObjectCreation;
        }


        /// <summary>
        /// While is True then the same operation is returned.
        /// Set it to False to invalidate current operation so the next call to get operation will return new operation.
        /// </summary>
        public bool IsValid { get; set; }



        public T GetOperation()
        {
            if (IsValid == false)
            {
                ValidObject = ObjectCreation();
                IsValid = true;
            }

            return ValidObject;
        }

    }


class StocktakingOperationFactory : OperationFactory<StocktakingOperation>
    {
        public StocktakingOperationFactory(Func<StocktakingOperation> ObjectCreation)
            : base(ObjectCreation)
        {

        }
    }

kernel.Bind<StocktakingOperation>().ToSelf();

kernel.Bind<StocktakingOperationFactory>().ToMethod(c =>
            new StocktakingOperationFactory(() => { return kernel.Get<StocktakingOperation>(); })
            ).InSingletonScope();
kernel.Bind<StocktakingPresenter>().ToSelf().InSingletonScope();

类别操作工厂，其中T:操作
{
私有Func对象创建；
私人T ValidObject；
公共操作工厂（Func对象创建）
{
IsValid=false；
this.ObjectCreation=ObjectCreation；
}
/// 
///如果为True，则返回相同的操作。
///将其设置为False将使当前操作无效，以便下一次调用get操作将返回新操作。
/// 
公共bool有效{get；set；}
公共T GetOperation（）
{
if（IsValid==false）
{
ValidObject=ObjectCreation（）；
IsValid=true；
}
返回有效对象；
}
}
分类盘点操作工厂：操作工厂
{
公共库存操作工厂（Func对象创建）
：base（ObjectCreation）
{
}
}

演示者

class StocktakingPresenter : BaseOperationPresenter<StocktakingPresentersManager, OPERATION_TYPE>
    {

        public StocktakingPresenter(QuickForm QuickForm, StocktakingOperationFactory OperationFactory, VIEW_TYPE view, Workspace workspace, Logger logger)
            : base(QuickForm, OperationFactory, view, workspace, logger)
        {}


    }

class StocktakingPresenter:BaseOperationPresenter
{
公共盘点演示者（快速表单快速表单，盘点操作工厂操作工厂，视图类型视图，工作区工作区，记录器）
：基本（快速表单、操作工厂、视图、工作区、记录器）
{}
}

和国际奥委会：

public abstract class Operation
    {
        protected Logger logger;

        public Operation(Logger logger)
        {
            this.logger = logger;
        }
    }


public class StocktakingOperation : Operation
    {
        public string test = DateTime.Now.ToString();

        public StocktakingOperation(Logger logger)
            : base(logger)
        {

        }
    }

class OperationFactory<T> where T : Operation
    {
        private Func<T> ObjectCreation;

        private T ValidObject;


        public OperationFactory(Func<T> ObjectCreation)
        {
            IsValid = false;
            this.ObjectCreation = ObjectCreation;
        }


        /// <summary>
        /// While is True then the same operation is returned.
        /// Set it to False to invalidate current operation so the next call to get operation will return new operation.
        /// </summary>
        public bool IsValid { get; set; }



        public T GetOperation()
        {
            if (IsValid == false)
            {
                ValidObject = ObjectCreation();
                IsValid = true;
            }

            return ValidObject;
        }

    }


class StocktakingOperationFactory : OperationFactory<StocktakingOperation>
    {
        public StocktakingOperationFactory(Func<StocktakingOperation> ObjectCreation)
            : base(ObjectCreation)
        {

        }
    }

kernel.Bind<StocktakingOperation>().ToSelf();

kernel.Bind<StocktakingOperationFactory>().ToMethod(c =>
            new StocktakingOperationFactory(() => { return kernel.Get<StocktakingOperation>(); })
            ).InSingletonScope();
kernel.Bind<StocktakingPresenter>().ToSelf().InSingletonScope();

kernel.Bind（）.ToSelf（）；
kernel.Bind（）.ToMethod（c=>
新StocktakingOperationFactory（（）=>{return kernel.Get（）；}）
).InSingletonScope（）；
kernel.Bind（）.ToSelf（）.InSingletonScope（）；

您可能不需要将依赖项注入到单例中。将该依赖项的工厂注入到单例中，并在每次需要实例时调用该工厂上的create。您可以随时在服务定位器中注入，以在每次需要时解决依赖项。好的，这是一个解决方案，但我想知道是否有更简单的解决方案。一些.OnResolved方法将非常简单。我想知道为什么没有这样的事情。老实说，这是一个非常简单的解决方案；）注入工厂不适用，因为实际上有几个类（A1、A2、A3…）具有B依赖性。在所有这些类中，B对象在某些范围内使用。从作用域退出并再次进入后，应该创建一个新的B实例。服务定位器不被视为反p吗