Non dichiarare membri statici su tipi generici

Articolo
09/12/2008

Aggiornamento: novembre 2007

TypeName	DoNotDeclareStaticMembersOnGenericTypes
CheckId	CA1000
Categoria	Microsoft.Design
Breaking Change	Breaking

Causa

Un tipo generico visibile contiene un membro static (Shared in Visual Basic).

Descrizione della regola

Quando viene chiamato un membro static di tipo generico, è necessario specificare l'argomento di tipo relativo al tipo. Quando viene chiamato un membro di istanza generica che non supporta l'inferenza, è necessario specificare l'argomento di tipo relativo al membro. La sintassi per la specifica dell'argomento di tipo in questi due casi è diversa e dà facilmente adito a confusione, come dimostrato nelle chiamate seguenti:

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

In generale è consigliabile evitare entrambe le dichiarazioni precedenti, in modo che non sia necessario specificare l'argomento di tipo quando viene chiamato il membro. Ne risulta una sintassi per la chiamata di membri in generics che non si differenzia dalla sintassi per membri non-generics. Per ulteriori informazioni, vedere I metodi generici devono fornire parametri di tipo.

Correzione di violazioni

Per correggere una violazione di questa regola, rimuovere il membro statico oppure cambiarlo in un membro di istanza.

Esclusione di avvisi

Non escludere un avviso da questa regola. La presenza di generics in una sintassi facile da comprendere e utilizzare riduce il tempo necessario all'apprendimento e aumenta la frequenza di adozione di nuove librerie.

Esempio

Nell'esempio riportato di seguito viene illustrato un metodo che provoca tale violazione.

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

Nell'esempio precedente, la dichiarazione di un membro statico su un tipo generico forza l'utente a specificare l'argomento di tipo quando questo viene chiamato.

Nell'esempio seguente viene risolta la violazione precedente spostando il parametro di tipo T dalla classe al metodo, in modo che possa essere dedotto dal compilatore quando viene chiamato.