CA2202, come risolvere questo caso

Qualcuno può dirmi come rimuovere tutti gli avvisi CA2202 dal seguente codice?

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

Avviso 7 CA2202: Microsoft.Usage: L'oggetto 'cryptoStream' può essere eliminato più di una volta nel metodo 'CryptoServices.Encrypt (string, byte [], byte [])'. Per evitare di generare un'eccezione System.ObjectDisposedException, non chiamare Dispose più di una volta su un oggetto .: Righe: 34

Avviso 8 CA2202: Microsoft.Usage: L'oggetto "memoryStream" può essere eliminato più di una volta nel metodo "CryptoServices.Encrypt (string, byte [], byte [])". Per evitare di generare un'eccezione System.ObjectDisposedException, non chiamare Dispose più di una volta su un oggetto .: Righe: 34, 37

È necessario Visual Studio Code Analysis per visualizzare questi avvisi (non sono avvisi del compilatore c #).

Questo si compila senza preavviso:

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

Modifica in risposta ai commenti: ho appena verificato di nuovo che questo codice non genera l'avviso, mentre quello originale sì. Nel codice originale CryptoStream.Dispose()eMemoryStream().Dispose( ) vengono effettivamente chiamati due volte (il che può essere un problema o meno).

Il codice modificato funziona come segue: i riferimenti vengono impostati su null, non appena la responsabilità dello smaltimento viene trasferita a un altro oggetto. Ad esempio, memoryStreamè impostato su nulldopo che la chiamata al CryptoStreamcostruttore è riuscita. cryptoStreamè impostato su null, dopo che la chiamata al StreamWritercostruttore è riuscita. Se non si verifica alcuna eccezione, streamWriterviene smaltito nel finallyblocco ea sua volta smaltirà CryptoStreame MemoryStream.

In questo caso dovresti sopprimere gli avvisi. Il codice che si occupa degli articoli usa e getta dovrebbe essere coerente e non dovresti preoccuparti che altre classi si assumano la proprietà degli articoli usa e getta che hai creato e Disposeli richiamino .

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

AGGIORNAMENTO: Nella documentazione di IDisposable.Dispose puoi leggere questo:

Se il metodo Dispose di un oggetto viene chiamato più di una volta, l'oggetto deve ignorare tutte le chiamate successive alla prima. L'oggetto non deve generare un'eccezione se il suo metodo Dispose viene chiamato più volte.

Si può sostenere che questa regola esiste in modo che gli sviluppatori possano utilizzare l' usingistruzione in modo sano in una cascata di articoli usa e getta, come ho mostrato sopra (o forse questo è solo un bell'effetto collaterale). Per lo stesso motivo, quindi, CA2202 non ha alcuno scopo utile e dovrebbe essere soppresso dal punto di vista del progetto. Il vero colpevole sarebbe un'implementazione difettosa di Disposee CA1065 dovrebbe occuparsene (se è sotto la tua responsabilità).

Bene, è accurato, il metodo Dispose () su questi flussi verrà chiamato più di una volta. La classe StreamReader assumerà la "proprietà" di cryptoStream, quindi l'eliminazione di streamWriter eliminerà anche cryptoStream. Allo stesso modo, la classe CryptoStream si assume la responsabilità per memoryStream.

Questi non sono esattamente bug reali, queste classi .NET sono resistenti a più chiamate Dispose (). Ma se vuoi sbarazzarti dell'avviso, dovresti eliminare l'istruzione using per questi oggetti. E addolorati un po 'quando pensi a cosa succederà se il codice genera un'eccezione. Oppure chiudi l'avvertimento con un attributo. O semplicemente ignora l'avvertimento poiché è sciocco.

Quando uno StreamWriter viene eliminato, eliminerà automaticamente lo Stream avvolto (qui: CryptoStream ). CryptoStream dispone anche automaticamente lo Stream avvolto (qui: MemoryStream ).

Quindi il tuo MemoryStream viene eliminato sia dal CryptoStream che dall'istruzione using . E il tuo CryptoStream viene disposto dallo StreamWriter e dall'istruzione using esterna .

Dopo alcuni esperimenti, sembra impossibile eliminare completamente gli avvertimenti. Teoricamente, MemoryStream deve essere eliminato, ma in teoria non potresti più accedere al suo metodo ToArray. In pratica, non è necessario eliminare un MemoryStream, quindi sceglierei questa soluzione e sopprimerei l'avviso CA2000.

var memoryStream = new MemoryStream();

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

return memoryStream.ToArray();

Lo farei usando #pragma warning disable .

Le linee guida di .NET Framework consigliano di implementare IDisposable.Dispose in modo tale che possa essere richiamato più volte. Dalla descrizione MSDN di IDisposable.Dispose :

L'oggetto non deve generare un'eccezione se il suo metodo Dispose viene chiamato più volte

Pertanto l'avvertimento sembra essere quasi privo di significato:

Per evitare di generare un'eccezione System.ObjectDisposedException, non chiamare Dispose più di una volta su un oggetto

Immagino che si potrebbe sostenere che l'avviso potrebbe essere utile se si utilizza un oggetto IDisposable implementato male che non segue le linee guida di implementazione standard. Ma quando si utilizzano classi da .NET Framework come si fa, direi che è sicuro sopprimere l'avviso utilizzando un #pragma. E IMHO questo è preferibile ai cerchi come suggerito nella documentazione MSDN per questo avviso .

Ho dovuto affrontare problemi simili nel mio codice.

Sembra che l'intera operazione CA2202 sia stata attivata perché MemoryStreampuò essere eliminata se si verifica un'eccezione nel costruttore (CA2000).

Questo potrebbe essere risolto in questo modo:

 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 }

Si noti che dobbiamo restituire l' memoryStreaminterno dell'ultima usingistruzione (riga 10) perché cryptoStreamviene eliminata alla riga 11 (perché è usata streamWriter usingnell'istruzione), il che porta memoryStreama essere eliminata anche alla riga 11 (perché memoryStreamviene utilizzata per creare il cryptoStream).

Almeno questo codice ha funzionato per me.

MODIFICARE:

Per quanto possa sembrare divertente, ho scoperto che se sostituisci il GetMemoryStreammetodo con il seguente codice,

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

ottieni lo stesso risultato.

Il cryptostream è basato sul flusso di memoria.

Quello che sembra accadere è che quando il crypostream viene smaltito (al termine dell'uso) anche il flusso di memoria viene smaltito, quindi il flusso di memoria viene nuovamente smaltito.

Volevo risolvere questo problema nel modo giusto, ovvero senza sopprimere gli avvertimenti e smaltire correttamente tutti gli oggetti usa e getta.

Ho estratto 2 dei 3 flussi come campi e li Dispose()ho disposti nel metodo della mia classe. Sì, l'implementazione IDisposabledell'interfaccia potrebbe non essere necessariamente ciò che stai cercando, ma la soluzione sembra abbastanza pulita rispetto alle dispose()chiamate da tutte le posizioni casuali nel codice.

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

Fuori tema ma ti suggerirei di utilizzare una tecnica di formattazione diversa per raggruppare usingi messaggi:

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

Sostengo anche l'utilizzo di var s qui per evitare ripetizioni di nomi di classi molto lunghi.

PS Grazie a @ShellShock per aver sottolineato che non posso omettere prima le parentesi graffe usingcome farebbe memoryStreamin una returndichiarazione fuori dall'ambito.

Evita tutti gli utilizzi e usa Dispose-Calls nidificate!

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

Volevo solo scartare il codice in modo da poter vedere più chiamate a Disposesugli oggetti:

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

Sebbene la maggior parte delle classi .NET sia (si spera) resiliente contro l'errore di più chiamate a .Dispose, non tutte le classi sono così difensive contro l'uso improprio del programmatore.

FX Cop lo sa e ti avverte.

Hai poche scelte;

• chiama solo Disposeuna volta su qualsiasi oggetto; non usareusing
• continua a chiamare dispose due volte e spero che il codice non si blocchi
• sopprimere l'avvertimento

Ho usato questo tipo di codice che accetta byte [] e restituisce byte [] senza utilizzare flussi

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

In questo modo tutto ciò che devi fare è convertire da stringa a byte [] usando le codifiche.