PRISMは解決するためにタイプを使用する工場とのインターフェイスを解決します

Question

私はPRISMでアプリケーションを構築しています。このアプリケーションは今後数年間にわたりgrootする予定ですので、モジュラとIoCを念頭に置いて設定します。 このアプリケーションでは、現在、ロギングメカニズムとしてNlogを実装しています。

私はまた、工場

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

ためのインタフェースを作成している

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); 
} 

ロガーのためのインタフェースを作成している私のアプリケーション全体を通してNLogへの参照を追加する必要はありませんのでファクトリは、そのクラスに固有のロガーを作成するために使用できるTypeパラメータを受け取ります。今、私は目標型クラスを使用してインスタンスを持つことを望むILogを使うつもりです。

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

どのように私はこの場合のtypeof演算（にClassA）中でILogFactory.Initialize（タイプtype）を使用しているのIlogを使用するクラスの決意にPRISMに私ILogFactoryを配線することができます。

Answer 1

だから、私は、コードにそれはlog4netの上でこれを依存しないようにする入札価格を変更する必要がありました、私は最終的に私は this blog

で探していたものを見つけたウェブの多くを検索した後、次のコード

の結果

BuildTrackingExtensionは、作成するロガーがどこにあるかを知る必要があります。

InitializeShellが呼び出される前に、私はたLogFactoryを使用していますので、私はRegisterInstanceを使用しています次に

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; } 
} 

私ILogFactory

団結

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

を使用してそれをアップ配線

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; 
     } 
    } 
} 

からロガーを作成するLogCreationExtension