CA1407: Evitar membros estáticos em tipos visíveis no COM

Item	Valor
RuleId	CA1407
Categoria	Microsoft.Interoperability
Alteração da falha	Sem interrupção

Causa

Um tipo marcado especificamente como visível para o COM (Component Object Model) contém um método public``static.

Descrição da regra

O COM não dá suporte a métodos static.

Essa regra ignora acessadores de propriedade e evento, métodos de sobrecarga de operador ou métodos marcados usando o atributo System.Runtime.InteropServices.ComRegisterFunctionAttribute ou o atributo System.Runtime.InteropServices.ComUnregisterFunctionAttribute.

Por padrão, o seguinte é visível para COM: assemblies, tipos públicos, membros de instância pública em tipos públicos e todos os membros de tipos de valor público.

Para que essa regra ocorra, um nível ComVisibleAttribute de assembly precisa ser definido como false e a classe ComVisibleAttribute precisa ser definida como true, como mostra o código a seguir.

using System;
using System.Runtime.InteropServices;

[assembly: ComVisible(false)]
namespace Samples
{
    [ComVisible(true)]
    public class MyClass
    {
        public static void DoSomething()
        {
        }
    }
}

Como corrigir violações

Para corrigir uma violação dessa regra, altere o design para usar um método de instância que fornece a mesma funcionalidade que o método static.

Quando suprimir avisos

É seguro suprimir um aviso dessa regra se um cliente COM não exigir acesso à funcionalidade fornecida pelo método static.

Violação de exemplo

Descrição

O exemplo a seguir mostra um método static que viola essa regra.

Código

using System;
using System.Runtime.InteropServices;
using System.Collections.ObjectModel; 

[assembly: ComVisible(false)] 

namespace Samples
{    
    [ComVisible(true)]    
    public class Book    
    {        
        private Collection<string> _Pages = new Collection<string>();         
        
        public Book()        
        {        
        }         
        
        public Collection<string> Pages        
        {            
            get { return _Pages; }        
        }                
        
        // Violates this rule        
        public static Book FromPages(string[] pages)        
        {            
            if (pages == null)                
                throw new ArgumentNullException("pages");             
                
            Book book = new Book();             
            
            foreach (string page in pages)            
            {                
                book.Pages.Add(page);            
            }             return book;        
        }    
    }
}

Comentários

Neste exemplo, o método Book.FromPages não pode ser chamado do COM.

Exemplo de correção

Descrição

Para corrigir a violação no exemplo anterior, você pode alterar o método para um método de instância, mas isso não faz sentido nesta instância. Uma solução melhor é aplicar ComVisible(false) explicitamente ao método para deixar claro a outros desenvolvedores que o método não pode ser visto do COM.

O exemplo a seguir se aplica ao método ComRegisterFunctionAttribute.

Código

using System;
using System.Runtime.InteropServices;
using System.Collections.ObjectModel;

[assembly: ComVisible(false)]

namespace Samples
{
    [ComVisible(true)]
    public class Book
    {
        private Collection<string> _Pages = new Collection<string>();

        public Book()
        {
        }

        public Collection<string> Pages
        {
            get { return _Pages; }
        }

        [ComVisible(false)]
        public static Book FromPages(string[] pages)
        {
            if (pages == null)
                throw new ArgumentNullException("pages");

            Book book = new Book();

            foreach (string page in pages)
            {
                book.Pages.Add(page);
            }

            return book;
        }
    }
}

Regras relacionadas

CA1017: Marcar assemblies com ComVisibleAttribute

CA1406: Evitar argumentos Int64 para clientes do Visual Basic 6

CA1413: Evitar campos não públicos em tipos de valor visíveis no COM

Confira também

Interoperação com código não gerenciado