CA2202、このケースを解決する方法

次のコードからすべてのCA2202警告を削除する方法を誰かに教えてもらえますか？

public static byte[] Encrypt(string data, byte[] key, byte[] iv)
{
    using(MemoryStream memoryStream = new MemoryStream())
    {
        using (DESCryptoServiceProvider cryptograph = new DESCryptoServiceProvider())
        {
            using (CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptograph.CreateEncryptor(key, iv), CryptoStreamMode.Write))
            {
                using(StreamWriter streamWriter = new StreamWriter(cryptoStream))
                {
                    streamWriter.Write(data);
                }
            }
        }
        return memoryStream.ToArray();
    }
}

警告7 CA2202：Microsoft.Usage：メソッド 'CryptoServices.Encrypt（string、byte []、byte []）'でオブジェクト 'cryptoStream'を複数回破棄できます。System.ObjectDisposedExceptionの生成を回避するために、オブジェクトに対してDisposeを複数回呼び出さないでください。：行：34

警告8 CA2202：Microsoft.Usage：メソッド 'CryptoServices.Encrypt（string、byte []、byte []）'でオブジェクト 'memoryStream'を複数回破棄できます。System.ObjectDisposedExceptionの生成を回避するには、オブジェクトに対してDisposeを複数回呼び出さないでください。：行：34、37

これらの警告を表示するにはVisual Studio Code Analysisが必要です（これらはC＃コンパイラの警告ではありません）。

これは警告なしでコンパイルされます：

    public static byte[] Encrypt(string data, byte[] key, byte[] iv)
    {
        MemoryStream memoryStream = null;
        DESCryptoServiceProvider cryptograph = null;
        CryptoStream cryptoStream = null;
        StreamWriter streamWriter = null;
        try
        {
            memoryStream = new MemoryStream();
            cryptograph = new DESCryptoServiceProvider();
            cryptoStream = new CryptoStream(memoryStream, cryptograph.CreateEncryptor(key, iv), CryptoStreamMode.Write);
            var result = memoryStream;              
            memoryStream = null;
            streamWriter = new StreamWriter(cryptoStream);
            cryptoStream = null;
            streamWriter.Write(data);
            return result.ToArray();
        }
        finally
        {
            if (memoryStream != null)
                memoryStream.Dispose();
            if (cryptograph != null)
                cryptograph.Dispose();
            if (cryptoStream != null)
                cryptoStream.Dispose();
            if (streamWriter != null)
                streamWriter.Dispose();
        }
    }

コメントに応じて編集：このコードでは警告が生成されないが、元のコードでは生成されることを再度確認しました。元のコードでは、CryptoStream.Dispose()およびMemoryStream().Dispose(）は実際には2回呼び出されます（問題になる場合とそうでない場合があります）。

変更されたコードは次のように機能します。null破棄の責任が別のオブジェクトに移されるとすぐに、参照はに設定されます。たとえば、コンストラクタの呼び出しが成功memoryStreamしたnull後にが設定されCryptoStreamます。コンストラクタへの呼び出しが成功した後、cryptoStreamはに設定されます。例外が発生しない場合は、ブロックに配置され、次に破棄されます。nullStreamWriterstreamWriterfinallyCryptoStreamMemoryStream

この場合、警告を抑制する必要があります。使い捨てを扱うコードは一貫している必要があり、他のクラスが作成した使い捨ての所有権を取得し、Disposeそれらを呼び出すことを気にする必要はありません。

[SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")]
public static byte[] Encrypt(string data, byte[] key, byte[] iv) {
  using (var memoryStream = new MemoryStream()) {
    using (var cryptograph = new DESCryptoServiceProvider())
    using (var cryptoStream = new CryptoStream(memoryStream, cryptograph.CreateEncryptor(key, iv), CryptoStreamMode.Write))
    using (var streamWriter = new StreamWriter(cryptoStream)) {
      streamWriter.Write(data);
    }
    return memoryStream.ToArray();
  }
}

UPDATE：でIDisposable.Disposeのドキュメントあなたはこれを読むことができます：

オブジェクトのDisposeメソッドが2回以上呼び出される場合、オブジェクトは、最初の呼び出し以降のすべての呼び出しを無視する必要があります。Disposeメソッドが複数回呼び出された場合、オブジェクトは例外をスローしてはなりません。

このルールは、using上で示したように、使い捨てのカスケードで開発者がステートメントを正しく使用できるようにするために存在すると主張できます（または、おそらくこれは素晴らしい副作用です）。同様に、CA2202は有用な目的を果たさないため、プロジェクトごとに抑制する必要があります。実際の原因はの不完全な実装でDisposeあり、CA1065がそれを処理する必要があります（責任がある場合）。

まあ、それは正確です。これらのストリームのDispose（）メソッドは複数回呼び出されます。StreamReaderクラスは、cryptoStreamの「所有権」を取得するため、streamWriterを破棄すると、cryptoStreamも破棄されます。同様に、CryptoStreamクラスは、memoryStreamの責任を引き継ぎます。

これらは、実際のバグではありません。これらの.NETクラスは、複数のDispose（）呼び出しに対して耐性があります。ただし、警告を取り除きたい場合は、これらのオブジェクトのusingステートメントを削除する必要があります。そして、コードが例外をスローした場合にどうなるかを推論するときは、少し苦痛を覚えます。または、警告を属性でシャットダウンします。またはそれはばかげているので警告を無視してください。

ときのStreamWriterが配置されて、それが自動的に包まれ処分されますストリーム（：ここCryptoStreamを）。CryptoStreamは、ラップされたStream（ここでは、MemoryStream）も自動的に破棄します。

したがって、MemoryStreamはCryptoStreamとusingステートメントの両方によって破棄されます。そして、CryptoStreamは、StreamWriterと外部のusingステートメントによって破棄されます。

いくつかの実験の後、警告を完全に取り除くことは不可能のようです。理論的には、MemoryStreamを破棄する必要がありますが、その後、理論的にはそのToArrayメソッドにアクセスできなくなりました。実際には、MemoryStreamを破棄する必要がないので、このソリューションを使用してCA2000警告を抑制します。

var memoryStream = new MemoryStream();

using (var cryptograph = new DESCryptoServiceProvider())
using (var writer = new StreamWriter(new CryptoStream(memoryStream, ...)))
{
    writer.Write(data);
}

return memoryStream.ToArray();

私はを使用してこれを行い#pragma warning disableます。

.NET Frameworkガイドラインでは、IDisposable.Disposeを複数回呼び出すことができるように実装することを推奨しています。IDisposable.DisposeのMSDNの説明から：

Disposeメソッドが複数回呼び出された場合、オブジェクトは例外をスローしてはなりません

したがって、警告はほとんど意味がないようです：

System.ObjectDisposedExceptionの生成を回避するには、オブジェクトでDisposeを複数回呼び出さないでください。

標準の実装ガイドラインに準拠していない、不適切に実装されたIDisposableオブジェクトを使用している場合、警告が役立つ可能性があると思われるかもしれません。しかし、あなたがしているように.NET Frameworkのクラスを使用するときは、＃pragmaを使用して警告を抑制しても安全だと思います。そして、私見これは、この警告についてのMSDNドキュメントで提案されているように、フープを通過するよりも好ましいです。

私のコードでも同様の問題に直面していました。

CA2202全体がトリガーされるように見えます MemoryStreamコンストラクター（CA2000）で例外が発生した場合にできるされるように見えます。

これは次のように解決できます：

 1 public static byte[] Encrypt(string data, byte[] key, byte[] iv)
 2 {
 3    MemoryStream memoryStream = GetMemoryStream();
 4    using (DESCryptoServiceProvider cryptograph = new DESCryptoServiceProvider())
 5    {
 6        CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptograph.CreateEncryptor(key, iv), CryptoStreamMode.Write);
 7        using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
 8        {
 9            streamWriter.Write(data);
10            return memoryStream.ToArray();
11        }
12    }
13 }
14
15 /// <summary>
16 /// Gets the memory stream.
17 /// </summary>
18 /// <returns>A new memory stream</returns>
19 private static MemoryStream GetMemoryStream()
20 {
21     MemoryStream stream;
22     MemoryStream tempStream = null;
23     try
24     {
25         tempStream = new MemoryStream();
26
27         stream = tempStream;
28         tempStream = null;
29     }
30     finally
31     {
32         if (tempStream != null)
33             tempStream.Dispose();
34     }
35     return stream;
36 }

memoryStream最後の内部を返す必要があることに注意してくださいusingステートメント（行10）cryptoStream、streamWriter usingステートメントで使用されるため、行11で破棄されるため、行11 memoryStreamでも破棄されるためmemoryStreamです（これは、cryptoStream）。

少なくともこのコードは私にとってはうまくいきました。

編集：

おかしいかもしれませんが、私はあなたが GetMemoryStreamメソッドを次のコードにと、

/// <summary>
/// Gets a memory stream.
/// </summary>
/// <returns>A new memory stream</returns>
private static MemoryStream GetMemoryStream()
{
    return new MemoryStream();
}

同じ結果が得られます。

暗号ストリームは、メモリストリームに基づいています。

起こっているように見えるのは、（使用の終わりに）クリポストリームが破棄されると、メモリストリームも破棄され、その後、メモリストリームが再び破棄されることです。

私はこれを正しい方法で解決したかった-それは警告を抑制せずに、すべての使い捨てオブジェクトを正しく処分せずに。

3つのストリームのうち2つをフィールドとして取り出しDispose()、クラスのメソッドに配置しました。はい、IDisposableインターフェイスを実装することは必ずしもあなたが探しているものではないかもしれませんが、ソリューションdispose()はコード内のすべてのランダムな場所からの呼び出しに比べてかなりきれいに見えます。

public class SomeEncryption : IDisposable
    {
        private MemoryStream memoryStream;

        private CryptoStream cryptoStream;

        public static byte[] Encrypt(string data, byte[] key, byte[] iv)
        {
             // Do something
             this.memoryStream = new MemoryStream();
             this.cryptoStream = new CryptoStream(this.memoryStream, encryptor, CryptoStreamMode.Write);
             using (var streamWriter = new StreamWriter(this.cryptoStream))
             {
                 streamWriter.Write(plaintext);
             }
            return memoryStream.ToArray();
        }

       public void Dispose()
        { 
             this.Dispose(true);
             GC.SuppressFinalize(this);
        }

       protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.memoryStream != null)
                {
                    this.memoryStream.Dispose();
                }

                if (this.cryptoStream != null)
                {
                    this.cryptoStream.Dispose();
                }
            }
        }
   }

トピック外ですが、グループ化に別のフォーマット手法を使用することをお勧めしますusing：

using (var memoryStream = new MemoryStream())
{
    using (var cryptograph = new DESCryptoServiceProvider())
    using (var encryptor = cryptograph.CreateEncryptor(key, iv))
    using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
    using (var streamWriter = new StreamWriter(cryptoStream))
    {
        streamWriter.Write(data);
    }

    return memoryStream.ToArray();
}

私はまた、 var本当に長いクラス名の繰り返しを避けるために、ここでsます。

PS指摘してくれた@ShellShockのおかげで、範囲外のステートメントで作成されるusingためmemoryStream、最初に中括弧を省略できませんreturn。

すべての使用を避け、ネストされたDispose-Callsを使用してください！

    public static byte[] Encrypt(string data, byte[] key, byte[] iv)
    {
        MemoryStream memoryStream = null;
        DESCryptoServiceProvider cryptograph = null;
        CryptoStream cryptoStream = null;
        StreamWriter streamWriter = null;

        try
        {
            memoryStream = new MemoryStream();
            cryptograph = new DESCryptoServiceProvider();
            cryptoStream = new CryptoStream(memoryStream, cryptograph.CreateEncryptor(key, iv), CryptoStreamMode.Write);
            streamWriter = new StreamWriter(cryptoStream);

            streamWriter.Write(data);
            return memoryStream.ToArray();
        }
        finally 
        {
            if(streamWriter != null)
                streamWriter.Dispose();
            else if(cryptoStream != null)
                cryptoStream.Dispose();
            else if(memoryStream != null)
                memoryStream.Dispose();

            if (cryptograph != null)
                cryptograph.Dispose();
        }
    }

Disposeオブジェクトの複数の呼び出しを確認できるように、コードをラップ解除したかっただけです。

memoryStream = new MemoryStream()
cryptograph = new DESCryptoServiceProvider()
cryptoStream = new CryptoStream()
streamWriter = new StreamWriter()

memoryStream.Dispose(); //implicitly owned by cryptoStream
cryptoStream.Dispose(); //implicitly owned by streamWriter
streamWriter.Dispose(); //through a using

cryptoStream.Dispose(); //INVALID: second dispose through using
cryptograph.Dispose(); //through a using
memorySTream.Dipose(); //INVALID: second dispose through a using

return memoryStream.ToArray(); //INVALID: accessing disposed memoryStream

ほとんどの.NETクラスは（願わくば）への複数の呼び出しのミスに対して回復力がありますが.Dispose、すべてのクラスがプログラマーの誤用に対する防御力があるわけではありません。

FX Copはこれを知っており、警告します。

いくつかの選択肢があります。

• Dispose任意のオブジェクトで1回だけ呼び出します。使わないusing
• disposeを2度呼び出し続け、コードがクラッシュしないことを願って
• 警告を抑制

ストリームを使用せずにbyte []を受け取り、byte []を返すこの種のコードを使用しました

public static byte[] Encrypt(byte[] data, byte[] key, byte[] iv)
{
  DES des = new DES();
  des.BlockSize = 128;
  des.Mode = CipherMode.CBC;
  des.Padding = PaddingMode.Zeros;
  des.IV = IV
  des.Key = key
  ICryptoTransform encryptor = des.CreateEncryptor();

  //and finaly operations on bytes[] insted of streams
  return encryptor.TransformFinalBlock(plaintextarray,0,plaintextarray.Length);
}

このようにすれば、エンコーディングを使用して文字列からbyte []に​​変換するだけです。