Não declarará membros estático tipos genéricos

Artigo
08/25/2010

TypeName	DoNotDeclareStaticMembersOnGenericTypes
CheckId	CA1000
Category (Categoria)	Microsoft.Design
Quebrando alterar	Quebrando

Causa

Um tipo genérico visível externamente contém um static (Shared no Visual Basic) membros.

Descrição da regra

Quando um static membro de um tipo genérico é chamado, o argumento de tipo deve ser especificado para o tipo. Quando um membro de instância genérico que não oferece suporte à inferência é chamado, o argumento de tipo deve ser especificado para o membro.A sintaxe para especificar o argumento do tipo nesses dois casos é diferente e com com facilidade confuso, sistema autônomo demonstram sistema autônomo seguintes chamadas:

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

Em geral, as duas declarações anteriores devem ser evitadas, de modo que o argumento de tipo não tenha a ser especificado quando o membro é chamado.Isso resultados em uma sintaxe para membros de chamada no genéricos não é diferente da sintaxe para não genéricos.Para obter mais informações, consulte Métodos genéricos devem fornecer o parâmetro de tipo.

Como corrigir violações

Para corrigir uma violação dessa regra, remover o membro estático ou alterá-lo para um membro de instância.

Quando suprimir avisos

Não suprimir um aviso da regra.Fornecer genéricos em uma sintaxe que seja fácil de entender e usar reduz o time que é necessário para aprender e aumenta a taxa de adoção de novas bibliotecas.

Exemplo

O exemplo a seguir mostra um método que causa essa violação.

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

No exemplo acima, declarar um membro estático em um tipo genérico força o usuário para especificar o argumento de tipo quando chamá-lo.

O exemplo a seguir corrige a violação acima, movendo o parâmetro de tipo T, da classe do método, permitindo que ele ser inferido pelo compilador quando chamado.