Ne pas déclarer de membres statiques sur les types génériques

Article
08/21/2008

Mise à jour : novembre 2007

TypeName	DoNotDeclareStaticMembersOnGenericTypes
CheckId	CA1000
Catégorie	Microsoft.CSharp
Modification avec rupture	Oui

Cause

Un type générique visible de l'extérieur contient un membre static (Shared en Visual Basic).

Description de la règle

Lorsqu'un membre static d'un type générique est appelé, l'argument de type doit être spécifié pour le type. Lorsqu'un membre d'instance générique qui ne prend pas en charge l'inférence est appelé, l'argument de type doit être spécifié pour le membre. La syntaxe permettant de spécifier l'argument de type dans ces deux cas est différente et peut être facilement confondue, comme l'illustrent les appels suivants :

' Shared method in a generic type.
GenericType(Of Integer).SharedMethod()

' Generic instance method that does not support inference.
someObject.GenericMethod(Of Integer)()

// Static method in a generic type.
GenericType<int>.StaticMethod();

// Generic instance method that does not support inference.
someObject.GenericMethod<int>();

En général, les deux déclarations précédentes doivent être évitées afin que l'argument de type ne soit pas spécifié lors de l'appel au membre. On obtient une syntaxe d'appel aux membres pour les génériques qui est identique à celle pour les non-génériques. Pour plus d'informations, consultez Les méthodes génériques doivent fournir le paramètre de type.

Comment corriger les violations

Pour corriger une violation de cette règle, supprimez le membre statique ou remplacez-le par un membre d'instance.

Quand supprimer les avertissements

Ne supprimez aucun avertissement de cette règle. La fourniture de génériques dans une syntaxe facile à comprendre et à utiliser réduit le délai d'apprentissage nécessaire et augmente le taux d'adoption de nouvelles bibliothèques.

Exemple

L'exemple suivant montre une méthode qui provoque cette violation.

Imports System
Imports System.Runtime.InteropServices

Namespace Samples

    Public NotInheritable Class EnumParser(Of T)

        Private Sub New()
        End Sub

        ' Fires this violation        
        Public Shared Function TryParse(ByVal value As String, <Out()> ByRef result As T) As Boolean

            Try
                result = DirectCast([Enum].Parse(GetType(T), value), T)
                Return True
            Catch ex As ArgumentException
            End Try

            result = Nothing
            Return False

        End Function

    End Class

    Module Program

        Public Sub Main()

            Dim result As DayOfWeek
            ' Must specify type argument            
            If EnumParser(Of DayOfWeek).TryParse("Monday", result) Then
                Console.WriteLine("Conversion Succeeded!")
            End If

        End Sub

    End Module

End Namespace

using System;

namespace Samples
{    
    public static class EnumParser<T>    
    {        // Fires this violation        
        public static bool TryParse(string value, out T result)        
        {            
            try            
            {                
                result = (T)Enum.Parse(typeof(T), value);                
                return true;            
            }            
            catch (ArgumentException)            
            {            
            }
                result = default(T);            
            return false;        
        }    
    }

    static class Program    
    {        
        public static void Main()        
        {            
            DayOfWeek dayOfWeek;            
            // Must specify type argument            
            if (EnumParser<DayOfWeek>.TryParse("Monday", out dayOfWeek))            
            {                
                Console.WriteLine("Conversion Succeeded!");            
            }        
        }    
    }
}

Dans l'exemple précité, déclarer un membre statique sur un type générique force l'utilisateur à spécifier l'argument de type lors de son appel.

L'exemple suivant résout la violation précitée en déplaçant le paramètre de type, T, de la classe à la méthode, ce qui lui permet d'être déduit par le compilateur lorsqu'il est appelé.