Quais são as melhores práticas para eliminar gradualmente o código obsoleto?

Eu tenho a necessidade de eliminar gradualmente um método obsoleto. Estou ciente do [Obsolete]atributo. A Microsoft possui um guia de práticas recomendadas para fazer isso?

Aqui está o meu plano atual:

R. Eu não quero criar uma nova montagem porque os desenvolvedores precisariam adicionar uma nova referência aos seus projetos e espero receber muita tristeza do meu chefe e colegas de trabalho, se eles precisarem fazer isso. Também não mantemos várias versões de montagem. Nós usamos apenas a versão mais recente. Alterar essa prática exigiria alterar nosso processo de implantação, o que é um grande problema (é preciso ensinar as pessoas a fazer coisas com o TFS em vez do FinalBuilder e fazê-las desistir do FinalBuilder)

B. Marque o método antigo como obsoleto.

C. Como a implementação está mudando (não a assinatura do método), preciso renomear o método em vez de criar uma sobrecarga. Portanto, para conscientizar os usuários do método adequado, pretendo adicionar uma mensagem ao [Obsolete]atributo. Essa parte me incomoda, porque a única alteração que estou fazendo é separar o método da string de conexão. Mas, como não estou adicionando uma nova montagem, não vejo como contornar isso.

Resultado:

[Obsolete("Please don't use this anymore because it does not implement IMyDbProvider.  Use XXX instead.")];
        /// <summary>
        /// 
        /// </summary>
        /// <param name="settingName"></param>
        /// <returns></returns>
        public static Dictionary<string, Setting> ReadSettings(string settingName)
        {
            return ReadSettings(settingName, SomeGeneralClass.ConnectionString);
        }

        public Dictionary<string, Setting> ReadSettings2(string settingName)
        {
            return ReadSettings(settingName);// IMyDbProvider.ConnectionString private member added to class.  Probably have to make this an instance method.
        }

A Microsoft usa o atributo [obsoleto] para informar aos desenvolvedores que o método, propriedade ou classe está obsoleta e pode ser alterada (ou não é suportada) em versões futuras.

Isso fornece pelo menos um ciclo de lançamento para notificar os usuários da sua API que o recurso está "desaparecendo" e remover referências a ela em versões futuras do software.

Quanto tempo você deixa o recurso original depende inteiramente de você. Se você deseja "encorajar fortemente" os desenvolvedores a usar seus novos recursos em relação aos antigos, você só precisa de um ciclo de lançamento adicional para removê-lo. Se você pretende ter compatibilidade permanente com versões anteriores, pode deixá-lo para sempre.

Como Brian aponta, se você está apenas alterando a implementação subjacente, mas não a assinatura do método, pode não ser necessário fazer nada disso.

Como a implementação está mudando (não a assinatura do método), preciso renomear o método em vez de criar uma sobrecarga.

Eu não entendo Se a implementação está mudando, mas a assinatura não está, por que você faria isso? Deixe o método "antigo" usar a implementação nova e aprimorada. Qualquer desenvolvedor que consome essa API estará revirando os olhos quando vir um método com a mesma assinatura exata criada e avisos de descontinuação em suas chamadas de método existentes. (Você consegue pensar em um momento em que isso aconteceu em uma API?)

Se você não tiver certeza se a alteração da implementação subjacente desse método funcionará, verifique o comportamento com testes de unidade antes e depois de alterar a implementação.