Assim como nós, humanos, todo código possui um ciclo de vida. Nenhum código é eterno. Temos que saber dar devidos fins a eles.
Quando um trecho de código não é mais utilizado, um dos caminhos mais simples é "arrancá-lo" do código. Sumir com ele, apagar, queimar, matar, enfim, qualquer modo que torne ele inutilizável.
Normalmente quando um novo programador assume o projeto, o primeiro instinto que ele tem é refazer o projeto todo. O primeiro motivo para refazê-lo é que a curva de aprendizado do código legado pode ser grande, e tomar tempo. Se ele refizer o projeto, conhecerá todo o código e não precisará ficar horas entendendo que foi feito pelo outro programador.
O segundo motivo é que o antigo programador pode, em diversos pontos do código, ter utilizado um método de programação muito conhecido, o POG (Programação Orientada a Gambiarras). Neste método é muito comum fazer as coisas do modo mais fácil, menos legível, e não recomendado na literatura técnica.
Além disso, outro motivo para apagar alguns métodos do código é a evolução natural do código. O cliente solicitou alterações, o escopo mudou e os métodos ficaram obsoletos.
Como então podemos gerenciar isto de uma forma elegante na plataforma .NET? Antes de entender como gerenciar códigos obsoletos, vamos entender alguns conceitos da plataforma .NET.
Quando se deseja associar alguma informação a um bloco de código, ou especificar uma determinada função a ele, é possível adicionar algumas linhas de código antes de sua declaração que contém alguma determinada instrução ou informação. Estas linhas adicionais de código são chamadas de atributos. Atributos podem ser utilizados, por exemplo, para:
Para utilizar o método obsoleto, é preciso utilizar o atributo "Obsolete", conforme listagem abaixo. Neste caso, um comentário pode ser adicionado ao atributo, dando as novas instruções ao programador, como por exemplo: utilize o método salvarNovo(), ao invés do salvar().
[Obsolete("Utilize o salvarNovo() no lugar")]
public void Salvar(){
(.. linhas antigas de código)
}
public void salvarNovo (){
(.. linhas novas de código)
}
Caso você queira forçar a troca de todas as chamadas para o novo método, utilize o segundo atributo para "true", assim será levantado um erro em todas as chamadas, e o código só irá compilar se o método for substituído.
[Obsolete("Utilize o salvarNovo() no lugar"), true]
public void Salvar(){
(.. linhas antigas de código)
}
Vejamos o código que está por trás do atributo, dentro do framework.
namespace System
{
[AttributeUsage(
AttributeTargets.Class |
AttributeTargets.Struct |
AttributeTargets.Enum |
AttributeTargets.Interface |
AttributeTargets.Delegate |
AttributeTargets.Method |
AttributeTargets.Constructor |
AttributeTargets.Property |
AttributeTargets.Field |
AttributeTargets.Event,
Inherited = false)
]
public class ObsoleteAttribute: Attribute
{
public ObsoleteAttribute() {...}
public ObsoleteAttribute(string message) {...}
public ObsoleteAttribute(string message, bool error) {...}
public string Message { get {...} }
public bool IsError { get {...} }
}
}
Fonte: http://msdn.microsoft.com/en-us/library/aa664623(VS.71).aspx
Se um programa utilizar um trecho de código (classe, método, propriedade...) que está marcado com o atributo obsoleto (Obsolete), o compilador pode receber automaticamente uma mensagem de erro, e não autorizar a compilar o projeto, sem que o método seja substituído. Este erro só ocorre se o parâmetro de causar erro estiver setado para true.
Dentro do Visual Studio, o programador recebe uma notificação visual que o método está obsoleto, como por exemplo, um sublinhado verde, e pode tomar as devidas providências, geralmente descrita no próprio atributo.
Marcando um método como obsoleto a equipe de programação pode ter um histórico do que foi desenvolvido, e um melhor controle do que esta sendo desenvolvido, deixando o código mais seguro, pois evita que alguma substituição seja esquecida.
Forte Abraço!

um ponto importante é a tecnica de refactoring! tb! ajuda no desenvolvimento e manutencao do codigo!
Parabens! Boa coluna!

Camilo, sem dúvida!!
Refactoring deve estar cada vez mais presente na vida do desenvolvedor, ainda mais quem trabalha com escopo aberto. As mudanças no dia a dia do programador são inúmeras, seja por parte do cliente, seja por questão tecnológica. Uma boa documentação, e um bom processo de codificação ajuda muito a manter o sistema estável nas mudanças de versão. Para .Net existem excelentes ferramentas que auxiliam no processo de refactoring. Inclusive plugins para Visual Studio. Alguns pagos. Tem um artigo meu "Turbine o seu Visual Studio", aqui no Imasters, que fala um pouco desta ferramenta.
Forte Abraço!
Thomas Alexander Semple
Os textos publicados neste espaço são de responsabilidade única de seus autores (colunistas e leitores) e podem não expressar necessariamente a opinião do iMasters.
Thomas Alexander Semple é engenheiro eletrônico com ênfase em telecomunicações e é líder de projetos da T4W. Com mais de 10 anos de experiência, participa de projetos para empresas dos mais diversos segmentos. A T4W (www.t4w.com.br) é uma empresa de tecnologia onde sua área de desenvolvimento vem atendendo empresas de médio e grande porte em projetos corporativos e especiais. Thomas A. Semple também escreve periodicamente para as revistas .Net Magazine e Web Mobile.
2001 - iMasters FFPA Informática Ltda - Todos os direitos reservados.