PRISM解决与使用类型解决的工厂的接口

我一直在用PRISM构建应用程序，这个应用程序在未来几年中将会很多，所以它被设置为模块化并且考虑到IoC。在这个应用程序中，我正在为日志记录机制实现Nlog。PRISM解决与使用类型解决的工厂的接口

因为我不想在我的整个应用程序添加到NLOG参考我已经创建了一个接口，用于记录

public interface ILog 
{ 
    void Log(LogLevel loglevel, string format); 
    void Log(LogLevel loglevel, string format, params object[] args); 
    void Log(LogLevel loglevel, Exception exc, string format, params object[] args); 
}

我也创建了一个接口，为工厂

public interface ILogFactory 
{ 
    ILog Initialize(Type type); 
}

工厂接受一个Type参数，该参数可用于为该类创建特定的记录器。现在来挑战我要使用ILog的问题我想要一个使用目标类型类的实例。

public class ClassA 
{ 
    private ILog Logger { get; set;} 
    public ClassA(Ilog logger) 
    { 
     Logger = logger; 
    } 
}

我如何电线我ILogFactory到PRISM等使用ILOG一类是采用ILogFactory.Initialize（类型类型），在这种情况下的typeof（ClassA的）的决心。

来源

2016-12-07 KCJ Hendriks

您可以简单地将ILogFactory作为依赖注入到ClassA中。类a只是使用恰好是ILog实现的工厂实例。 – Xeun

我目前正在使用它，它的工作原理，但只需要有一个Ilog使得类更简单 –

是的，我明白你想达到什么目的，但它不会那样工作。您的课程取决于Factory sicne，它不知道如何创建ILogger，但Factory确实如此 - 因此Factory是您班级的依赖项。我认为你只是在解决这个问题。让班级依靠工厂，你很好走 – Xeun

因此搜索更多的网络内容，我终于找到了我一直在寻找的后 this blog

我不得不修改代码，力图使之不依赖于log4net的，这导致在下面的代码

BuildTrackingExtension，我们需要知道我们要创建的记录器在哪里。

public class BuildTrackingExtension : UnityContainerExtension 
{ 
    protected override void Initialize() 
    { 
     Context.Strategies.AddNew<BuildTrackingStrategy>(UnityBuildStage.TypeMapping); 
    } 

    public static IBuildTrackingPolicy GetPolicy(IBuilderContext context) 
    { 
     return context.Policies.Get<IBuildTrackingPolicy>(context.BuildKey, true); 
    } 

    public static IBuildTrackingPolicy SetPolicy(IBuilderContext context) 
    { 
     IBuildTrackingPolicy policy = new BuildTrackingPolicy(); 
     context.Policies.SetDefault(policy); 
     return policy; 
    } 
} 

public class BuildTrackingStrategy : BuilderStrategy 
{ 
    public override void PreBuildUp(IBuilderContext context) 
    { 
     var policy = BuildTrackingExtension.GetPolicy(context) 
      ?? BuildTrackingExtension.SetPolicy(context); 

     policy.BuildKeys.Push(context.BuildKey); 
    } 

    public override void PostBuildUp(IBuilderContext context) 
    { 
     IBuildTrackingPolicy policy = BuildTrackingExtension.GetPolicy(context); 
     if ((policy != null) && (policy.BuildKeys.Count > 0)) 
     { 
      policy.BuildKeys.Pop(); 
     } 
    } 
} 

public interface IBuildTrackingPolicy : IBuilderPolicy 
{ 
    Stack<object> BuildKeys { get; } 
} 

public class BuildTrackingPolicy : IBuildTrackingPolicy 
{ 
    public BuildTrackingPolicy() 
    { 
     BuildKeys = new Stack<object>(); 
    } 

    public Stack<object> BuildKeys { get; private set; } 
}

然后，LogCreationExtension从我ILogFactory

public class LogCreationExtension : UnityContainerExtension 
{ 
    private ILogFactory LogFactory; 
    private LogCreationStrategy strategy; 

    public LogCreationExtension(ILogFactory logFactory) 
    { 
     LogFactory = logFactory; 
    } 
    protected override void Initialize() 
    { 
     strategy = new LogCreationStrategy(LogFactory); 

     Context.Strategies.Add(strategy, UnityBuildStage.PreCreation); 
    } 
} 

public class LogCreationStrategy : BuilderStrategy 
{ 
    public bool IsPolicySet { get; private set; } 

    private ILogFactory LogFactory; 
    public LogCreationStrategy(ILogFactory logFactory) 
    { 
     LogFactory = logFactory; 
    } 

    public override void PreBuildUp(IBuilderContext context) 
    { 
     Type typeToBuild = context.BuildKey.Type; 
     if (typeof(ILog).Equals(typeToBuild)) 
     { 

      if (context.Policies.Get<IBuildPlanPolicy>(context.BuildKey) == null) 
      { 
       Type typeForLog = LogCreationStrategy.GetLogType(context); 
       IBuildPlanPolicy policy = new LogBuildPlanPolicy(typeForLog, LogFactory); 
       context.Policies.Set<IBuildPlanPolicy>(policy, context.BuildKey); 

       IsPolicySet = true; 
      } 
     } 
    } 

    public override void PostBuildUp(IBuilderContext context) 
    { 
     if (IsPolicySet) 
     { 
      context.Policies.Clear<IBuildPlanPolicy>(context.BuildKey); 
      IsPolicySet = false; 
     } 
    } 

    private static Type GetLogType(IBuilderContext context) 
    { 
     Type logType = null; 
     IBuildTrackingPolicy buildTrackingPolicy = BuildTrackingExtension.GetPolicy(context); 
     if ((buildTrackingPolicy != null) && (buildTrackingPolicy.BuildKeys.Count >= 2)) 
     { 
      logType = ((NamedTypeBuildKey)buildTrackingPolicy.BuildKeys.ElementAt(1)).Type; 
     } 
     else 
     { 
      StackTrace stackTrace = new StackTrace(); 
      //first two are in the log creation strategy, can skip over them 
      for (int i = 2; i < stackTrace.FrameCount; i++) 
      { 
       StackFrame frame = stackTrace.GetFrame(i); 
       logType = frame.GetMethod().DeclaringType; 
       if (!logType.FullName.StartsWith("Microsoft.Practices")) 
       { 
        break; 
       } 
      } 
     } 
     return logType; 
    } 
} 

public class LogBuildPlanPolicy : IBuildPlanPolicy 
{ 
    private ILogFactory LogFactory; 
    public LogBuildPlanPolicy(Type logType, ILogFactory logFactory) 
    { 
     LogType = logType; 
     LogFactory = logFactory; 
    } 

    public Type LogType { get; private set; } 

    public void BuildUp(IBuilderContext context) 
    { 
     if (context.Existing == null) 
     { 
      ILog log = LogFactory.Initialize(LogType); 
      context.Existing = log; 
     } 
    } 
}

创建记录器包装它使用统一

 //Container.RegisterType<ILogFactory, NLogLogFactory>(); 
     Container.RegisterInstance<ILogFactory>(_LogFactory); 
     Container.AddNewExtension<BuildTrackingExtension>(); 
     Container.AddNewExtension<LogCreationExtension>();

我，因为我使用的是的LogFactory使用RegisterInstance InitializeShell被称为前

来源

2016-12-07 13:41:07

PRISM解决与使用类型解决的工厂的接口

回答

相关问题