É um cheiro de código se você está criando frequentemente um objeto apenas para chamar um método nele

Eu herdei uma base de código onde há muito código que é mais ou menos assim:

SomeDataAdapter sda = new SomeDataAdapter();
sda.UpdateData(DataTable updateData);

E então sda nunca é usado novamente.

Isso é um cheiro de código que indica que esses métodos devem realmente ser métodos de classe estática?

Eu consideraria um cheiro de arquitetura em que UpdateData provavelmente deveria pertencer a uma classe 'service'.

Onde os dados são uma Apple. Onde AppleAdapter é a classe de serviço / business intelligence. Onde AppleService é uma referência Singleton a um AppleAdapter que existe fora do método atual.

private static volatile AppleAdapter _appleService = null;
private static object _appleServiceLock = new object();
private AppleAdapter AppleService
{
    get
    {
        if (_appleService == null)
        {
            lock (_appleServiceLock)
            {
                if (_appleService == null)
                    _appleService = new AppleAdapter();
            }
        }
        return _appleService;
    }
}

public SomeAppleRelatedMethod(Apple apple)
{
    AppleService.UpdateData(apple);
}

Eu não acho que o que você está fazendo esteja errado necessariamente, mas se SomeDataAdapter realmente representar algum tipo de serviço de negócios sem estado, um singleton seria a melhor prática para ele. Espero que ajude! O exemplo fornecido é uma maneira sofisticada de garantir nenhuma contenção do _appleService se ele for nulo e acessado exatamente ao mesmo tempo por dois ou mais encadeamentos.

Você sabe o que? Se SomeDataAdapter for um ADO IDbDataAdapter (o que quase certamente é), desconsidere toda a resposta!

: P

Não tenho permissão para adicionar um comentário à pergunta original, mas se você puder especificar onde esse código existe.

Se esse código representa uma implementação personalizada de um IDbDataAdapter, e o UpdateData está criando um IDbConnection, IDbCommand e conectando tudo nos bastidores, então não, eu não consideraria um cheiro de código, porque agora estamos falando de fluxos e outros coisas que precisam ser descartadas quando terminarmos de usá-las.

Eu acho que esse problema é ainda mais profundo do que isso. Mesmo se você o refatorar para um método estático, obterá o código onde você chama o método estático único em todo o lugar. Que na minha opinião é o cheiro do código em si. Pode indicar que está faltando alguma abstração importante. Talvez você queira criar um código que faça algum pré e pós-processamento, permitindo alterar o que acontece no meio. Esse pré e pós-processamento conterão as chamadas comuns, enquanto o intervalo dependerá da implementação concreta.

Mais ou menos. Isso geralmente significa que você deseja distribuir uma função e seu idioma de escolha não permite. É meio desajeitado e deselegante, mas se você está preso em um idioma sem funções de primeira classe, não há muito o que fazer.

Se nenhum desses objetos estiver sendo passado como argumento para outras funções, você poderá transformá-los em métodos estáticos e nada mudará.

Se o estado de posse torna uma determinada classe mais utilitária, funcional ... reutilizável, então não. Por alguma razão, o padrão de design de comando vem à mente; esse motivo certamente não é o desejo de afogar Robert Harvey.

Defina "frequentemente". Com que frequência você instancia o objeto? Muito - provavelmente não?

É provável que haja problemas maiores no seu sistema. Ficar estático comunicará mais claramente ao programador que o estado interno do objeto não está mudando - ótimo.

Se o estado está sendo afetado, e você precisa começar a tornar estáticas outras coisas para tornar a primeira coisa estática, é necessário perguntar quais partes precisam ser estáticas e quais não.

Sim , é um cheiro de código, apenas um pequeno.

Torne-o um método estático e siga em frente. Não há nada errado com métodos estáticos. Depois que um padrão de uso surge, você pode se preocupar em abstrair o padrão.

O cheiro aqui é que esse é um código processual envolto (minimamente) em objetos.

Deve haver uma razão pela qual você deseja executar essa operação na tabela de dados, mas, em vez de modelar essa operação com outras operações relacionadas que compartilham alguma semântica (ou seja, têm um significado comum), o autor acabou de criar um novo procedimento dentro de um novo classe e chamou.

Em uma linguagem funcional, é assim que você faria as coisas;) mas no paradigma OO, você deseja modelar algumas abstrações que incluem essa operação. Em seguida, você usaria técnicas de OO para detalhar esse modelo e fornecer um conjunto de operações relacionadas que preservam algumas semânticas.

Portanto, o principal cheiro aqui é que o autor está usando classes, provavelmente porque o compilador exige isso, sem organizar as operações em um modelo conceitual.

Observe sempre que você vê o programa sendo modelado em vez do espaço problemático . É um sinal de que o design pode se beneficiar de mais reflexão. Em outras palavras, cuidado com as classes, todas sendo "xAdaptor" e "xHandler" e "xUtility", e geralmente vinculadas a um modelo de domínio anêmico . Isso significa que alguém está apenas agrupando código por conveniência, em vez de modelar os conceitos que deseja implementar.