web-dev-qa-db-ja.com

インターセプトvsインジェクション：フレームワークアーキテクチャの決定

私が設計を手助けしているこのフレームワークがあります。いくつかの一般的なコンポーネントを使用して実行する必要があるいくつかの一般的なタスクがあります。特に、ロギング、キャッシング、およびイベントの発生です。

依存性注入を使用してこれらのすべてのコンポーネントを各サービスに（たとえばプロパティとして）導入する方が良いのか、それともサービスの各メソッドにある種のメタデータを配置し、インターセプトを使用してこれらの一般的なタスクを実行するのが良いのかわからない？

次に両方の例を示します。

注入：

public class MyService
{
    public ILoggingService Logger { get; set; }

    public IEventBroker EventBroker { get; set; }

    public ICacheService Cache { get; set; }

    public void DoSomething()
    {
        Logger.Log(myMessage);
        EventBroker.Publish<EventType>();
        Cache.Add(myObject);
    }
}

そしてここに他のバージョンがあります：

遮断：

public class MyService
{
    [Log("My message")]
    [PublishEvent(typeof(EventType))]
    public void DoSomething()
    {

    }
}

ここに私の質問があります：

  1. 複雑なフレームワークに最適なソリューションはどれですか？
  2. インターセプトが成功した場合、メソッドの内部値と対話するための私のオプションは何ですか（たとえば、キャッシュサービスで使用するために？）この動作を実装するために、属性ではなく他の方法を使用できますか？
  3. または、問題を解決する他の解決策があるかもしれませんか？
c#dependency-injection
29
Beatles1692

ロギング、キャッシングなどの横断的関心事は依存関係ではないため、サービスに注入しないでください。ただし、ほとんどの人は完全なインターリーブAOPフレームワークに手を伸ばしているように見えますが、これには素晴らしいデザインパターンがあります： Decorator 。

上記の例では、MyServiceにIMyServiceインターフェースを実装させます。

public interface IMyService
{
    void DoSomething();
}

public class MyService : IMyService
{
    public void DoSomething()
    {
        // Implementation goes here...
    }
}

これにより、MyServiceクラスは横断的な懸念から完全に解放され、 単一の責任の原則 （SRP）に従います。

ロギングを適用するには、ロギングデコレーターを追加します。

public class MyLogger : IMyService
{
    private readonly IMyService myService;
    private readonly ILoggingService logger;

    public MyLogger(IMyService myService, ILoggingService logger)
    {
        this.myService = myService;
        this.logger = logger;
    }

    public void DoSomething()
    {
        this.myService.DoSomething();
        this.logger.Log("something");
    }
}

キャッシング、メータリング、イベントなどを同じ方法で実装できます。各デコレータは正確に1つのことを行うため、SRPにも従うため、任意に複雑な方法でそれらを構成できます。例えば。

var service = new MyLogger(
    new LoggingService(),
    new CachingService(
        new Cache(),
        new MyService());
39
Mark Seemann

ほんの一握りのサービスについては、Markの答えは良いと思います。新しいサードパーティの依存関係を学習したり導入したりする必要はなく、引き続き適切なSOLID原則に従います。

大量のサービスには、PostSharpやCastle DynamicProxyなどのAOPツールをお勧めします。 PostSharpには無料の（ビールのように）バージョンがあり、最近リリースされた PostSharp Toolkit for Diagnostics 、（ビールとスピーチのように無料）を使用すると、すぐに使えるロギング機能がいくつか提供されます。

6
Matthew Groves

私はフレームワークの設計がこの質問にほぼ直角であると思います-最初にフレームワークのインターフェースに焦点を当てるべきであり、おそらく背景の精神プロセスとして誰かが実際にそれを消費するかもしれないことを考えます。 preventsのようなことをしたくないのですが、それはフレームワーク設計への入力にすぎません。多くのうちの1つ。

2
sethcall

私はこの問題に何度も直面しており、簡単な解決策を思いついたと思います。

最初はデコレータパターンを使用して各メソッドを手動で実装しましたが、何百ものメソッドがある場合、これは非常に退屈になります。

その後、PostSharpを使用することを決定しましたが、単純なコード（多くの）で実現できることだけを行うためにライブラリ全体を含めるという考えは好きではありませんでした。

次に、透過的なプロキシルートをたどりました。これは面白かったが、実行時にILを動的に放出することに関係しており、運用環境でやりたいことにはなりませんでした。

私は最近、T4テンプレートを使用してデコレーターパターンを設計時に自動的に実装することを決めました。T4テンプレートは実際には非常に扱いにくいことがわかり、すぐにこれを実行する必要があったため、以下のコードを作成しました。それは速くて汚いです（そしてそれはプロパティをサポートしていません）がうまくいけば誰かがそれが役に立つと思うでしょう。

これがコードです：

        var linesToUse = code.Split(Environment.NewLine.ToCharArray()).Where(l => !string.IsNullOrWhiteSpace(l));
        string classLine = linesToUse.First();

        // Remove the first line this is just the class declaration, also remove its closing brace
        linesToUse = linesToUse.Skip(1).Take(linesToUse.Count() - 2);
        code = string.Join(Environment.NewLine, linesToUse).Trim()
            .TrimStart("{".ToCharArray()); // Depending on the formatting this may be left over from removing the class

        code = Regex.Replace(
            code,
            @"public\s+?(?'Type'[\w<>]+?)\s(?'Name'\w+?)\s*\((?'Args'[^\)]*?)\)\s*?\{\s*?(throw new NotImplementedException\(\);)",
            new MatchEvaluator(
                match =>
                    {
                        string start = string.Format(
                            "public {0} {1}({2})\r\n{{",
                            match.Groups["Type"].Value,
                            match.Groups["Name"].Value,
                            match.Groups["Args"].Value);

                        var args =
                            match.Groups["Args"].Value.Split(",".ToCharArray())
                                .Select(s => s.Trim().Split(" ".ToCharArray()))
                                .ToDictionary(s => s.Last(), s => s.First());

                        string call = "_decorated." + match.Groups["Name"].Value + "(" + string.Join(",", args.Keys) + ");";
                        if (match.Groups["Type"].Value != "void")
                        {
                            call = "return " + call;
                        }

                        string argsStr = args.Keys.Any(s => s.Length > 0) ? ("," + string.Join(",", args.Keys)) : string.Empty;
                        string loggedCall = string.Format(
                            "using (BuildLogger(\"{0}\"{1})){{\r\n{2}\r\n}}",
                            match.Groups["Name"].Value,
                            argsStr,
                            call);
                        return start + "\r\n" + loggedCall;
                    }));
        code = classLine.Trim().TrimEnd("{".ToCharArray()) + "\n{\n" + code + "\n}\n";

次に例を示します。

public interface ITestAdapter : IDisposable
{
    string TestMethod1();

    IEnumerable<string> TestMethod2(int a);

    void TestMethod3(List<string[]>  a, Object b);
}

次に、ITestAdapterを実装するLoggingTestAdapterというクラスを作成し、Visual Studioにすべてのメソッドを自動実装させてから、上記のコードで実行します。次に、次のようなものが必要です。

public class LoggingTestAdapter : ITestAdapter
{

    public void Dispose()
    {
        using (BuildLogger("Dispose"))
        {
            _decorated.Dispose();
        }
    }
    public string TestMethod1()
    {
        using (BuildLogger("TestMethod1"))
        {
            return _decorated.TestMethod1();
        }
    }
    public IEnumerable<string> TestMethod2(int a)
    {
        using (BuildLogger("TestMethod2", a))
        {
            return _decorated.TestMethod2(a);
        }
    }
    public void TestMethod3(List<string[]> a, object b)
    {
        using (BuildLogger("TestMethod3", a, b))
        {
            _decorated.TestMethod3(a, b);
        }
    }
}

これは、サポートコードと一緒です：

public class DebugLogger : ILogger
{
    private Stopwatch _stopwatch;
    public DebugLogger()
    {
        _stopwatch = new Stopwatch();
        _stopwatch.Start();
    }
    public void Dispose()
    {
        _stopwatch.Stop();
        string argsStr = string.Empty;
        if (Args.FirstOrDefault() != null)
        {
            argsStr = string.Join(",",Args.Select(a => (a ?? (object)"null").ToString()));
        }

        System.Diagnostics.Debug.WriteLine(string.Format("{0}({1}) @ {2}ms", Name, argsStr, _stopwatch.ElapsedMilliseconds));
    }

    public string Name { get; set; }

    public object[] Args { get; set; }
}

public interface ILogger : IDisposable
{
    string Name { get; set; }
    object[] Args { get; set; }
}


public class LoggingTestAdapter<TLogger> : ITestAdapter where TLogger : ILogger,new()
{
    private readonly ITestAdapter _decorated;

    public LoggingTestAdapter(ITestAdapter toDecorate)
    {
        _decorated = toDecorate;
    }

    private ILogger BuildLogger(string name, params object[] args)
    {
        return new TLogger { Name = name, Args = args };
    }

    public void Dispose()
    {
        _decorated.Dispose();
    }

    public string TestMethod1()
    {
        using (BuildLogger("TestMethod1"))
        {
            return _decorated.TestMethod1();
        }
    }
    public IEnumerable<string> TestMethod2(int a)
    {
        using (BuildLogger("TestMethod2", a))
        {
            return _decorated.TestMethod2(a);
        }
    }
    public void TestMethod3(List<string[]> a, object b)
    {
        using (BuildLogger("TestMethod3", a, b))
        {
            _decorated.TestMethod3(a, b);
        }
    }
}
1
JoeS