CA1011 : Si possible, transmettez les types de base en tant que paramètresCA1011: Consider passing base types as parameters

TypeNameTypeName ConsiderPassingBaseTypesAsParametersConsiderPassingBaseTypesAsParameters
CheckIdCheckId CA1011CA1011
CategoryCategory Microsoft.DesignMicrosoft.Design
Modification avec ruptureBreaking Change RuptureBreaking

CauseCause

Une déclaration de méthode inclut un paramètre formel est un type dérivé, et la méthode appelle uniquement les membres du type de base du paramètre.A method declaration includes a formal parameter that is a derived type, and the method calls only members of the base type of the parameter.

Description de la règleRule description

Lorsqu’un type de base est spécifié en tant que paramètre dans une déclaration de méthode, tout type dérivé du type de base peut être passé en tant qu’argument correspondant à la méthode.When a base type is specified as a parameter in a method declaration, any type that is derived from the base type can be passed as the corresponding argument to the method. Lorsque l’argument est utilisé à l’intérieur du corps de méthode, la méthode spécifique qui est exécutée dépend du type de l’argument.When the argument is used inside the method body, the specific method that is executed depends on the type of the argument. Si la fonctionnalité supplémentaire fournie par le type dérivé n’est pas obligatoire, utilisation du type de base permet une utilisation plus large de la méthode.If the additional functionality that is provided by the derived type is not required, use of the base type allows wider use of the method.

Comment corriger les violationsHow to fix violations

Pour corriger une violation de cette règle, modifier le type du paramètre à son type de base.To fix a violation of this rule, change the type of the parameter to its base type.

Quand supprimer les avertissementsWhen to suppress warnings

Il est possible de supprimer un avertissement de cette règleIt is safe to suppress a warning from this rule

  • Si la méthode requiert la fonctionnalité spécifique fournie par le type dérivéif the method requires the specific functionality that is provided by the derived type

    - ou -- or -

  • Pour mettre en œuvre que seul le type dérivé, ou un type plus dérivé, est passé à la méthode.to enforce that only the derived type, or a more derived type, is passed to the method.

    Dans ce cas, le code sera plus robuste en raison de la vérification de type fort fourni par le compilateur et le runtime.In these cases, the code will be more robust because of the strong type checking that is provided by the compiler and runtime.

ExempleExample

L’exemple suivant montre une méthode, ManipulateFileStream, qui peut être utilisé uniquement avec un FileStream objet, ce qui enfreint cette règle.The following example shows a method, ManipulateFileStream, that can be used only with a FileStream object, which violates this rule. Une deuxième méthode, ManipulateAnyStream, satisfait la règle en remplaçant le FileStream paramètre en utilisant un Stream.A second method, ManipulateAnyStream, satisfies the rule by replacing the FileStream parameter by using a Stream.

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);
            }
        }
    }
}
using namespace System;
using namespace System::IO;

namespace DesignLibrary
{
   public ref class StreamUser
   {
      int anInteger;

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

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

using namespace DesignLibrary;

static void main()
{
   StreamUser^ someStreamUser = gcnew StreamUser();
   FileStream^ testFileStream = 
      gcnew FileStream("test.dat", FileMode::OpenOrCreate);
   MemoryStream^ testMemoryStream = 
      gcnew MemoryStream(gcnew array<Byte>{});

   // Cannot be used with testMemoryStream.
   someStreamUser->ManipulateFileStream(testFileStream);

   someStreamUser->ManipulateAnyStream(testFileStream);
   someStreamUser->ManipulateAnyStream(testMemoryStream);

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

CA1059 : Les membres ne doivent pas exposer certains types concretsCA1059: Members should not expose certain concrete types