CA1835: Preferencia de las sobrecargas basadas en memoria de los métodos ReadAsync/WriteAsync en clases basadas en secuencias

Propiedad	Valor
Nombre de tipo	PreferStreamAsyncMemoryOverloads
Identificador de la regla	CA1835
Título	Preferir las sobrecargas basadas en memoria de los métodos ReadAsync/WriteAsync en clases basadas en secuencias
Categoría	Rendimiento
La corrección es problemática o no problemática	Poco problemático
Habilitado de forma predeterminada en .NET 8	Como sugerencia

Causa

Esta regla localiza las invocaciones esperadas de las sobrecargas del método basado en la matriz de bytes para ReadAsync y WriteAsync, y sugiere el uso de las sobrecargas del método basado en memoria en su lugar, porque son más eficaces.

Descripción de la regla

Las sobrecargas del método basado en memoria tienen un uso de memoria más eficaz que las basadas en la matriz de bytes.

La regla funciona en las invocaciones de ReadAsync y WriteAsync de cualquier clase que se herede de Stream.

La regla solo funciona cuando el método está precedido por la palabra clave await.

Método detectado	Método sugerido
ReadAsync(Byte[], Int32, Int32, CancellationToken)	ReadAsync(Memory<Byte>, CancellationToken)
ReadAsync(Byte[], Int32, Int32)	ReadAsync(Memory<Byte>, CancellationToken) con CancellationToken establecido en default en C# o Nothing en Visual Basic.
WriteAsync(Byte[], Int32, Int32, CancellationToken)	WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)
WriteAsync(Byte[], Int32, Int32)	WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) con CancellationToken establecido en default en C# o Nothing en Visual Basic.

Importante

Asegúrese de pasar los argumentos de entero offset y count a las instancias de Memory o ReadOnlyMemory creadas.

Nota

La regla CA1835 está disponible en todas las versiones de .NET en las que las sobrecargas basadas en memoria están disponibles:

• .NET Standard 2.1 y versiones posteriores.
• .NET Core 2.1 y versiones posteriores.

Cómo corregir infracciones

Puede corregirlas manualmente o dejar que Visual Studio lo haga por usted. Para ello, mantenga el puntero sobre la bombilla que aparece junto a la invocación del método y seleccione el cambio sugerido. Ejemplo:

La regla puede detectar diversas infracciones para los métodos ReadAsync y WriteAsync. Estos son algunos ejemplos de los casos que la regla puede detectar:

Ejemplo 1

Invocaciones de ReadAsync, con o sin un argumento CancellationToken:

using System;
using System.IO;
using System.Threading;

class MyClass
{
    public async void MyMethod(CancellationToken ct)
    {
        using (FileStream s = new FileStream("path.txt", FileMode.Create))
        {
            byte[] buffer = new byte[s.Length];
            await s.ReadAsync(buffer, 0, buffer.Length);
            await s.ReadAsync(buffer, 0, buffer.Length, ct);
        }
    }
}

Solución:

using System;
using System.IO;
using System.Threading;

class MyClass
{
    public async void MyMethod(CancellationToken ct)
    {
        using (FileStream s = new FileStream("path.txt", FileMode.Create))
        {
            byte[] buffer = new byte[s.Length];
            await s.ReadAsync(buffer.AsMemory(0, buffer.Length));
            await s.ReadAsync(buffer.AsMemory(0, buffer.Length), ct);
        }
    }
}

Ejemplo 2

Invocaciones de WriteAsync, con o sin un argumento CancellationToken:

using System;
using System.IO;
using System.Threading;

class MyClass
{
    public async void MyMethod(CancellationToken ct)
    {
        using (FileStream s = File.Open("path.txt", FileMode.Open))
        {
            byte[] buffer = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
            await s.WriteAsync(buffer, 0, buffer.Length);
            await s.WriteAsync(buffer, 0, buffer.Length, ct);
        }
    }
}

Solución:

using System;
using System.IO;
using System.Threading;

class MyClass
{
    public async void MyMethod()
    {
        using (FileStream s = File.Open("path.txt", FileMode.Open))
        {
            byte[] buffer = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
            await s.WriteAsync(buffer.AsMemory(0, buffer.Length));
            await s.WriteAsync(buffer.AsMemory(0, buffer.Length), ct);
        }
    }
}

Ejemplo 3

Invocaciones con ConfigureAwait:

using System;
using System.IO;
using System.Threading;

class MyClass
{
    public async void MyMethod()
    {
        using (FileStream s = File.Open("path.txt", FileMode.Open))
        {
            byte[] buffer1 = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
            await s.WriteAsync(buffer1, 0, buffer1.Length).ConfigureAwait(false);

            byte[] buffer2 = new byte[s.Length];
            await s.ReadAsync(buffer2, 0, buffer2.Length).ConfigureAwait(true);
        }
    }
}

Solución:

using System;
using System.IO;
using System.Threading;

class MyClass
{
    public async void MyMethod()
    {
        using (FileStream s = File.Open("path.txt", FileMode.Open))
        {
            byte[] buffer1 = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
            await s.WriteAsync(buffer1.AsMemory(0, buffer1.Length)).ConfigureAwait(false);

            byte[] buffer2 = new byte[s.Length];
            await s.ReadAsync(buffer2.AsMemory(0, buffer.Length)).ConfigureAwait(true);
        }
    }
}

No infracciones

A continuación se muestran algunos ejemplos de las invocaciones en las que no se activará la regla.

El valor devuelto se guarda en una variable Task, en lugar de esperar:

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

class MyClass
{
    public void MyMethod()
    {
        byte[] buffer = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
        using (FileStream s = new FileStream("path.txt", FileMode.Create))
        {
            Task t = s.WriteAsync(buffer, 0, buffer.Length);
        }
    }
}

El método de ajuste devuelve el valor devuelto, en lugar de esperar:

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

class MyClass
{
    public Task MyMethod(FileStream s, byte[] buffer)
    {
        return s.WriteAsync(buffer, 0, buffer.Length);
    }
}

El valor devuelto se usa para llamar a ContinueWith, que es el método que se espera:

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

class MyClass
{
    public void MyMethod()
    {
        byte[] buffer = { 0xBA, 0x5E, 0xBA, 0x11, 0xF0, 0x07, 0xBA, 0x11 };
        using (FileStream s = new FileStream("path.txt", FileMode.Create))
        {
            await s.WriteAsync(buffer, 0, buffer.Length).ContinueWith(c => { /* ... */ });
        }
    }
}

Cuándo suprimir las advertencias

Es seguro suprimir una infracción de esta regla si no le preocupa mejorar el rendimiento al leer o escribir búferes en clases basadas en secuencias.

Supresión de una advertencia

Si solo quiere suprimir una única infracción, agregue directivas de preprocesador al archivo de origen para deshabilitar y volver a habilitar la regla.

#pragma warning disable CA1835
// The code that's violating the rule is on this line.
#pragma warning restore CA1835

Para deshabilitar la regla de un archivo, una carpeta o un proyecto, establezca su gravedad en none del archivo de configuración.

[*.{cs,vb}]
dotnet_diagnostic.CA1835.severity = none

Para obtener más información, consulte Procedimiento para suprimir advertencias de análisis de código.

Vea también

• Reglas de rendimiento