CA2202, como solucionar este caso

¿Alguien puede decirme cómo eliminar todas las advertencias CA2202 del siguiente código?

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

Advertencia 7 CA2202: Microsoft.Usage: El objeto 'cryptoStream' se puede eliminar más de una vez en el método 'CryptoServices.Encrypt (string, byte [], byte [])'. Para evitar generar una System.ObjectDisposedException, no debe llamar a Dispose más de una vez en un objeto .: Líneas: 34

Advertencia 8 CA2202: Microsoft.Usage: El objeto 'memoryStream' se puede eliminar más de una vez en el método 'CryptoServices.Encrypt (string, byte [], byte [])'. Para evitar generar una System.ObjectDisposedException, no debe llamar a Dispose más de una vez en un objeto .: Líneas: 34, 37

Necesita Visual Studio Code Analysis para ver estas advertencias (estas no son advertencias del compilador de C #).

Esto se compila sin previo aviso:

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

Edite en respuesta a los comentarios: Acabo de verificar nuevamente que este código no genera la advertencia, mientras que el original sí. En el código original, CryptoStream.Dispose()y MemoryStream().Dispose() en realidad se llaman dos veces (lo que puede ser un problema o no).

El código modificado funciona de la siguiente manera: las referencias se establecen en null, tan pronto como la responsabilidad de la eliminación se transfiere a otro objeto. Por ejemplo, memoryStreamse establece en nulldespués de que la llamada al CryptoStreamconstructor se haya realizado correctamente. cryptoStreamse establece en null, después de que la llamada al StreamWriterconstructor se haya realizado correctamente. Si no ocurre ninguna excepción, streamWriterse desecha en el finallybloque y, a su vez , se elimina CryptoStreamy MemoryStream.

Debe suprimir las advertencias en este caso. El código que se ocupa de los desechables debe ser coherente y no debería tener que preocuparse de que otras clases se apropien de los desechables que haya creado y también los utilicen 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();
  }
}

ACTUALIZACIÓN: En la documentación de IDisposable.Dispose puede leer esto:

Si se llama al método Dispose de un objeto más de una vez, el objeto debe ignorar todas las llamadas después de la primera. El objeto no debe lanzar una excepción si su método Dispose se llama varias veces.

Se puede argumentar que esta regla existe para que los desarrolladores puedan emplear la usingdeclaración con cordura en una cascada de desechables, como he mostrado anteriormente (o tal vez esto sea solo un efecto secundario agradable). De la misma manera, CA2202 no tiene ningún propósito útil, y debe suprimirse por proyecto. El verdadero culpable sería una implementación defectuosa de Dispose, y CA1065 debería encargarse de eso (si es bajo su responsabilidad).

Bueno, es preciso, el método Dispose () en estos flujos se llamará más de una vez. La clase StreamReader tomará la 'propiedad' del cryptoStream, por lo que eliminar streamWriter también eliminará cryptoStream. De manera similar, la clase CryptoStream asume la responsabilidad de memoryStream.

Estos no son exactamente errores reales, estas clases .NET son resistentes a múltiples llamadas Dispose (). Pero si desea deshacerse de la advertencia, debe eliminar la instrucción using para estos objetos. Y sufra un poco al razonar qué pasará si el código arroja una excepción. O cierre la advertencia con un atributo. O simplemente ignore la advertencia ya que es una tontería.

Cuando se elimina un StreamWriter , automáticamente eliminará el Stream envuelto (aquí: CryptoStream ). CryptoStream también elimina automáticamente el Stream envuelto (aquí: el MemoryStream ).

Entonces, su MemoryStream es eliminado tanto por CryptoStream como por la declaración using . Y su CryptoStream es eliminado por StreamWriter y la declaración de uso externa .

Después de un poco de experimentación, parece imposible deshacerse completamente de las advertencias. Teóricamente, MemoryStream debe eliminarse, pero, en teoría, ya no podría acceder a su método ToArray. Prácticamente, no es necesario eliminar un MemoryStream, por lo que optaría por esta solución y suprimiría la advertencia CA2000.

var memoryStream = new MemoryStream();

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

return memoryStream.ToArray();

Haría esto usando #pragma warning disable.

Las Pautas de .NET Framework recomiendan implementar IDisposable.Dispose de tal manera que se pueda llamar varias veces. De la descripción de MSDN de IDisposable .

El objeto no debe lanzar una excepción si su método Dispose se llama varias veces

Por lo tanto, la advertencia parece no tener sentido:

Para evitar generar una System.ObjectDisposedException, no debe llamar a Dispose más de una vez en un objeto

Supongo que se podría argumentar que la advertencia puede ser útil si está utilizando un objeto IDisposable mal implementado que no sigue las pautas de implementación estándar. Pero cuando usa clases de .NET Framework como lo está haciendo, diría que es seguro suprimir la advertencia usando un #pragma. Y en mi humilde opinión, esto es preferible a pasar por aros como se sugiere en la documentación de MSDN para esta advertencia .

Me enfrenté a problemas similares en mi código.

Parece que todo el asunto CA2202 se activa porque MemoryStreamse puede eliminar si se produce una excepción en el constructor (CA2000).

Esto podría resolverse así:

 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 }

Tenga en cuenta que tenemos que devolver el memoryStreaminterior de la última usingdeclaración (línea 10) porque cryptoStreamse elimina en la línea 11 (porque se usa en la streamWriter usingdeclaración), lo que lleva memoryStreama obtener también en la línea 11 (porque memoryStreamse usa para crear cryptoStream).

Al menos este código funcionó para mí.

EDITAR:

Por gracioso que parezca, descubrí que si reemplaza el GetMemoryStreammétodo con el siguiente código,

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

obtienes el mismo resultado.

El cryptostream se basa en el memorystream.

Lo que parece estar sucediendo es que cuando se elimina el flujo criptográfico (al final del uso), el flujo de memoria también se elimina, entonces el flujo de memoria se elimina de nuevo.

Quería resolver esto de la manera correcta, es decir, sin suprimir las advertencias y desechar correctamente todos los objetos desechables.

Saqué 2 de los 3 flujos como campos y los eliminé en el Dispose()método de mi clase. Sí, la implementación de la IDisposableinterfaz puede no ser necesariamente lo que está buscando, pero la solución parece bastante limpia en comparación con las dispose()llamadas desde todos los lugares aleatorios del código.

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

Fuera del tema, pero le sugiero que utilice una técnica de formato diferente para agrupar usings:

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

También recomiendo usar vars aquí para evitar repeticiones de nombres de clases realmente largos.

PS Gracias a @ShellShock para señalar que no puedo omitir para los apoyos primero usingya que haría memoryStreamen la returndeclaración fuera del alcance.

¡Evite todos los usos y utilice Dispose-Calls anidados!

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

Solo quería desenvolver el código para que podamos ver múltiples llamadas a Disposelos objetos:

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

Si bien la mayoría de las clases .NET son (con suerte) resistentes al error de múltiples llamadas a .Dispose, no todas las clases son tan defensivas contra el mal uso del programador.

FX Cop lo sabe y le advierte.

Tiene algunas opciones;

• solo llame Disposeuna vez a cualquier objeto; no useusing
• sigue llamando a dispose dos veces y espero que el código no se bloquee
• suprime la advertencia

Usé este tipo de código que toma bytes [] y devuelve bytes [] sin usar flujos

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

De esta forma, todo lo que tiene que hacer es la conversión de cadena a byte [] usando codificaciones.