CA2202, bu durum nasıl çözülür

Herhangi biri bana tüm CA2202 uyarılarını aşağıdaki koddan nasıl kaldıracağımı söyleyebilir mi?

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

Uyarı 7 CA2202: Microsoft.Usage: 'cryptoStream' nesnesi, 'CryptoServices.Encrypt (dize, bayt [], bayt [])' yönteminde birden çok kez atılabilir. Bir System.ObjectDisposedException oluşturmaktan kaçınmak için, bir nesnede Dispose'u birden fazla kez çağırmamalısınız .: Satırlar: 34

Uyarı 8 CA2202: Microsoft.Usage: 'memoryStream' nesnesi, 'CryptoServices.Encrypt (string, bayt [], bayt [])' yönteminde birden fazla atılabilir. Bir System.ObjectDisposedException oluşturmaktan kaçınmak için, bir nesnede Dispose'u birden fazla kez çağırmamalısınız .: Satırlar: 34, 37

Bu uyarıları görmek için Visual Studio Code Analysis gerekir (bunlar c # derleyici uyarıları değildir).

Bu uyarı olmadan derlenir:

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

Düzenleme yorumlara yanıt olarak: Sadece orijinal bir yok olurken bu kod, uyarı yol açmadığından tekrar doğrulanması. Orijinal kodda CryptoStream.Dispose()ve MemoryStream().Dispose() aslında iki kez çağrılır (bu bir sorun olabilir veya olmayabilir).

Değiştirilen kod şu şekilde çalışır: nullatma sorumluluğu başka bir nesneye aktarılır aktarılmaz referanslar olarak ayarlanır . Örneğin memoryStream, kurucuya nullçağrı CryptoStreambaşarılı olduktan sonra olarak ayarlanır . yapıcıya çağrı başarılı olduktan sonra cryptoStreamolarak ayarlanır . Herhangi bir istisna olmazsa , bloğa atılır ve karşılığında ve imha edilir .nullStreamWriterstreamWriterfinallyCryptoStreamMemoryStream

Bu durumda uyarıları bastırmalısınız. Tek kullanımlık malzemelerle ilgilenen kod tutarlı olmalı ve diğer sınıfların oluşturduğunuz tek kullanımlık malzemelerin sahipliğini almasına ve ayrıca Disposeonları çağırmasına dikkat etmeniz gerekmez.

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

GÜNCELLEME: In IDisposable.Dispose belgelerinde bunu okuyabilir:

Bir nesnenin Dispose yöntemi birden fazla çağrılırsa, nesnenin ilkinden sonraki tüm çağrıları yoksayması gerekir. Dispose yöntemi birden çok kez çağrılırsa nesne bir istisna atmamalıdır.

Geliştiricilerin, usingyukarıda gösterdiğim gibi (ya da belki de bu sadece güzel bir yan etkidir) ifadeyi bir tek kullanımlık malzeme dizisinde mantıklı bir şekilde kullanabilmeleri için bu kuralın var olduğu iddia edilebilir . Aynı şekilde, CA2202 hiçbir yararlı amaca hizmet etmez ve proje açısından bastırılmalıdır. Gerçek suçlu, hatalı bir uygulama olacaktır Disposeve CA1065 bununla ilgilenmelidir (eğer sizin sorumluluğunuzdaysa).

Doğru, bu akışlardaki Dispose () yöntemi birden fazla çağrılacak. StreamReader sınıfı, cryptoStream'in 'sahipliğini' alacaktır, böylece streamWriter'ın elden çıkarılması da cryptoStream'i elden çıkaracaktır. Benzer şekilde, CryptoStream sınıfı, memoryStream'in sorumluluğunu üstlenir.

Bunlar tam olarak gerçek hatalar değildir, bu .NET sınıfları birden çok Dispose () çağrısına karşı dayanıklıdır. Ancak uyarıdan kurtulmak istiyorsanız, bu nesneler için using ifadesini bırakmalısınız. Ve kod bir istisna atarsa ​​ne olacağını düşünürken kendinize biraz acı verin. Veya uyarıyı bir öznitelikle kapatın. Ya da aptalca olduğu için uyarıyı görmezden gelin.

Bir StreamWriter atıldığında, sarılmış Akışı otomatik olarak atar (burada: CryptoStream ). CryptoStream ayrıca sarılmış Akışı otomatik olarak ortadan kaldırır (burada: MemoryStream ).

Dolayısıyla, MemoryStream'iniz hem CryptoStream hem de using ifadesi tarafından düzenlenir . Ve CryptoStream tarafından elden StreamWriter ve dış kullanarak deyimi.

Bazı deneylerden sonra, uyarılardan tamamen kurtulmak imkansız gibi görünüyor. Teorik olarak, MemoryStream'in atılması gerekir, ancak o zaman teorik olarak ToArray yöntemine artık erişemezsiniz. Pratik olarak, bir MemoryStream'in atılmasına gerek yoktur, bu yüzden bu çözüme gidip CA2000 uyarısını bastırırdım.

var memoryStream = new MemoryStream();

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

return memoryStream.ToArray();

Bunu kullanarak yapardım #pragma warning disable.

.NET Framework Yönergeleri, IDisposable.Dispose'un birden çok kez çağrılabilecek şekilde uygulanmasını önerir. Gönderen IDisposable.Dispose MSDN açıklaması :

Dispose yöntemi birden çok kez çağrılırsa nesne bir istisna atmamalıdır

Bu nedenle uyarı neredeyse anlamsız görünüyor:

Bir System.ObjectDisposedException oluşturmaktan kaçınmak için, bir nesnede Dispose'u birden fazla kez çağırmamalısınız.

Standart uygulama yönergelerine uymayan kötü uygulanmış bir IDisposable nesne kullanıyorsanız uyarının yardımcı olabileceği iddia edilebilir. Ancak sizin yaptığınız gibi .NET Framework'teki sınıfları kullanırken, bir #pragma kullanarak uyarıyı bastırmanın güvenli olduğunu söyleyebilirim. Ve IMHO, bu uyarı için MSDN belgelerinde önerildiği gibi çemberlerden geçmek tercih edilir .

Kodumda benzer sorunlarla karşılaştım.

Yapıcıda MemoryStream(CA2000) istisna oluşursa elden çıkarılabileceği için CA2202 olayının tamamı tetiklenmiş gibi görünüyor .

Bu şu şekilde çözülebilir:

 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 }

memoryStreamSon usingcümlenin (10. satır) içini döndürmemiz gerektiğine dikkat edin çünkü cryptoStream11. satıra yerleştirilir (çünkü streamWriter usingifadede kullanılır ), bu memoryStreamda 11. satıra atılır (çünkü memoryStreamonu oluşturmak için kullanılır cryptoStream).

En azından bu kod benim için çalıştı.

DÜZENLE:

Kulağa komik gelse de, GetMemoryStreamyöntemi aşağıdaki kodla değiştirirseniz,

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

aynı sonucu alırsınız.

Kripto akışı, hafıza akışına dayanmaktadır.

Görünüşe göre, kripto-akış atıldığında (kullanımın sonunda) hafıza akışı da atılır, ardından hafıza akışı tekrar atılır.

Bunu doğru şekilde çözmek istedim - yani uyarıları bastırmadan ve tüm tek kullanımlık nesneleri doğru bir şekilde atmadan.

3 akımdan 2'sini alan olarak Dispose()çıkardım ve sınıfımın yöntemine yerleştirdim . Evet, IDisposablearayüzü uygulamak aradığınız şey olmayabilir, ancak çözüm dispose(), koddaki tüm rastgele yerlerden gelen çağrılara kıyasla oldukça temiz görünüyor .

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

Konu dışı, ancak URL'leri gruplandırmak için farklı bir biçimlendirme tekniği kullanmanızı öneririm 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();
}

Ayrıca var, gerçekten uzun sınıf isimlerinin tekrarlanmasını önlemek için burada s kullanılmasını savunuyorum .

Ben ilk için omit parantez olamaz işaret için @ShellShock PS sayesinde usingo yapar gibi memoryStreamde returnkapsam dışında açıklamada.

Tüm kullanımlardan kaçının ve iç içe geçmiş Dispose-Calls kullanın!

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

Akışları kullanmadan bayt [] alan ve bayt [] döndüren bu tür bir kod kullandım

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

Bu şekilde tek yapmanız gereken, kodlamaları kullanarak dizeden bayta [] dönüştürmektir.

DisposeNesnelerde birden fazla çağrı görebilmek için kodu açmak istedim . Gerçeklik Bunun ne vardır çağıran Disposenesneler üzerinde iki kez:

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

Çoğu .NET sınıfı (umarız) birden çok çağrı yapma hatasına karşı dirençli olsa da .Dispose, tüm sınıflar programcıların kötüye kullanımına karşı savunmacı değildir .

FX Cop bunu bilir ve sizi uyarır.

Birkaç seçeneğiniz var;

• Disposeherhangi bir nesneyi yalnızca bir kez çağırın ; kullanmausing
• dispose'u iki kez aramaya devam edin ve kodun çökmemesini umuyoruz
• uyarıyı bastır