CA1011: Considerar a passagem de tipos base como parâmetros

Item	Valor
RuleId	CA1011
Categoria	Microsoft.Design
Alteração da falha	Quebra

Causa

Uma declaração de método inclui um parâmetro formal que é um tipo derivado e o método chama apenas membros do tipo base do parâmetro.

Descrição da regra

Quando um tipo de base é especificado como um parâmetro em uma declaração de método, qualquer tipo derivado do tipo de base pode ser passado como o argumento correspondente ao método. Quando o argumento é usado dentro do corpo do método, o método específico que é executado depende do tipo do argumento. Se a funcionalidade adicional fornecida pelo tipo derivado não for necessária, o uso do tipo de base permitirá um uso mais amplo do método.

Como corrigir violações

Para corrigir uma violação dessa regra, altere o tipo do parâmetro para seu tipo base.

Quando suprimir avisos

É seguro suprimir um aviso desta regra

• se o método exigir a funcionalidade específica fornecida pelo tipo derivado

  - ou -

• para impor que apenas o tipo derivado ou um tipo mais derivado seja passado para o método .

Nesses casos, o código será mais robusto devido à verificação de tipo forte fornecida pelo compilador e pelo runtime.

Exemplo

O exemplo a seguir mostra um método ManipulateFileStream, que pode ser usado apenas com um objeto FileStream, que viola essa regra. Um segundo método ManipulateAnyStream satisfaz a regra substituindo o parâmetro FileStream usando um Stream.

C#

using System;
using System.IO;

namespace DesignLibrary
{
    public class StreamUser
    {
        int anInteger;

        public void ManipulateFileStream(FileStream stream)
        {
            while ((anInteger = stream.ReadByte()) != -1)
            {
                // Do something.
            }
        }

        public void ManipulateAnyStream(Stream anyStream)
        {
            while ((anInteger = anyStream.ReadByte()) != -1)
            {
                // Do something.
            }
        }
    }

    class TestStreams
    {
        static void Main()
        {
            StreamUser someStreamUser = new StreamUser();
            MemoryStream testMemoryStream = new MemoryStream(new byte[] { });
            using (FileStream testFileStream =
                     new FileStream("test.dat", FileMode.OpenOrCreate))
            {
                // Cannot be used with testMemoryStream.
                someStreamUser.ManipulateFileStream(testFileStream);

                someStreamUser.ManipulateAnyStream(testFileStream);
                someStreamUser.ManipulateAnyStream(testMemoryStream);
            }
        }
    }
}

VB

Imports System
Imports System.IO

Namespace DesignLibrary

    Public Class StreamUser

        Sub ManipulateFileStream(ByVal stream As IO.FileStream)
            If stream Is Nothing Then Throw New ArgumentNullException("stream")

            Dim anInteger As Integer = stream.ReadByte()
            While (anInteger <> -1)
                ' Do something.
                anInteger = stream.ReadByte()
            End While
        End Sub

        Sub ManipulateAnyStream(ByVal anyStream As IO.Stream)
            If anyStream Is Nothing Then Throw New ArgumentNullException("anyStream")

            Dim anInteger As Integer = anyStream.ReadByte()
            While (anInteger <> -1)
                ' Do something.
                anInteger = anyStream.ReadByte()
            End While
        End Sub
    End Class


   Public Class TestStreams
   
      Shared Sub Main()
            Dim someStreamUser As New StreamUser()
            Dim testFileStream As New FileStream( _
               "test.dat", FileMode.OpenOrCreate)
            Dim testMemoryStream As New MemoryStream(New Byte() {})

            ' Cannot be used with testMemoryStream.
            someStreamUser.ManipulateFileStream(testFileStream)
            someStreamUser.ManipulateAnyStream(testFileStream)
            someStreamUser.ManipulateAnyStream(testMemoryStream)
            testFileStream.Close()
        End Sub
   End Class
End Namespace

Regras relacionadas

CA1059: Membros não devem expor determinados tipos concretos