Não há duas maneiras sobre isso. As sugestões do ReSharper e vários recursos úteis do C # não seriam usados com tanta frequência se você estivesse escrevendo testes de unidade atômica isolados para todo o seu código.
Por exemplo, se você tiver um método estático e precisar apagá-lo, não será possível, a menos que você use uma estrutura de isolamento baseada em perfil. Uma solução alternativa compatível com chamadas é alterar a parte superior do método para usar a notação lambda. Por exemplo:
ANTES:
public static DBConnection ConnectToDB( string dbName, string connectionInfo ) {
}
DEPOIS:
public static Func<string, string, DBConnection> ConnectToDB (dbName, connectionInfo ) {
};
Os dois são compatíveis com chamadas. Os chamadores não precisam mudar. O corpo da função permanece o mesmo.
Em seguida, no seu código Unit-Test, você pode resumir esta chamada assim (supondo que esteja em uma classe chamada Database):
Database.ConnectToDB = (dbName, connectionInfo) => { return null|whatever; }
Tenha o cuidado de substituí-lo pelo valor original depois de terminar. Você pode fazer isso através de um try / finally ou, em sua limpeza de teste de unidade, aquele que é chamado após cada teste, escreva um código como este:
[TestCleanup]
public void Cleanup()
{
typeof(Database).TypeInitializer.Invoke(null, null);
}
que irá invocar novamente o inicializador estático da sua classe.
Os Lambda Funcs não são tão ricos em suporte quanto os métodos estáticos regulares, portanto, essa abordagem tem os seguintes efeitos colaterais indesejáveis:
- Se o método estático era um método de extensão, você deve primeiro alterá-lo para um método que não seja de extensão. O Resharper pode fazer isso automaticamente.
- Se qualquer um dos tipos de dados dos métodos estáticos for um assembly de interoperabilidade incorporada, como o Office, você precisará quebrar o método, encapsular o tipo ou alterá-lo para o tipo 'objeto'.
- Você não pode mais usar a ferramenta de refatoração de assinatura de alterações do Resharper.
Mas digamos que você evite completamente a estática e converta isso em um método de instância. Ainda não é compatível, a menos que o método seja virtual ou implementado como parte de uma interface.
Portanto, na realidade, qualquer um que sugira o remédio para cortar métodos estáticos é torná-los métodos de instância, eles também seriam contra métodos de instância que não são virtuais ou fazem parte de uma interface.
Então, por que o C # tem métodos estáticos?
Por que permite métodos de instâncias não virtuais?
Se você usar um desses "Recursos", simplesmente não poderá criar métodos isolados.
Então, quando você os usa?
Use-os para qualquer código que você não espera que alguém queira apagar. Alguns exemplos:
o método Format () da classe String
o método WriteLine () da classe Console
o método Cosh () da classe Math
E mais uma coisa ... A maioria das pessoas não se preocupa com isso, mas se você puder sobre o desempenho de uma chamada indireta, essa é outra razão para evitar métodos de instância. Há casos em que é um impacto no desempenho. É por isso que existem métodos não virtuais em primeiro lugar.