Por que passar objetos por métodos estáticos seria vantajoso?

Por que haveria uma vantagem em usar um método estático e passar a referência a um objeto como parâmetro, em vez de chamar o método em um objeto?

Para esclarecer o que quero dizer, considere a seguinte classe:

public class SomeClass {
    private double someValue;

    public SomeClass() {
        // Some constructor in which someValue is set
    }

    public void incrementValue() {
        someValue++;
    }
}

Comparado a esta implementação alternativa com um método estático:

public class SomeClass {
    private double someValue;

    public SomeClass() {
        // Some constructor in which someValue is set
    }

    public static void incrementValue(SomeClass obj) {
        obj.someValue++;
    }
}

Minha pergunta não está restrita apenas a essa classe; qualquer ponto em que você passe um objeto em vez de chamá-lo em um método é o que me interessa. Isso é sempre vantajoso? Se sim, por quê?

Um exemplo trivial: quando a instância passada pode legitimamente ser nula e você deseja incorporar o tratamento (não trivial) disso ao método.

No seu exemplo, o método da instância é um vencedor claro.

No caso geral, posso pensar em algumas razões pelas quais um método estático pode ser apropriado:

• Você deseja colocar o método estático em outra classe, pois há uma situação em que faz sentido separar a lógica dos dados (nota: seu exemplo não é um deles).

• Você está passando dois ou mais objetos e deseja enfatizar que eles são de igual importância.

• null é um valor válido (conforme explicado pelo usuário 9000).

Seria sensato incluir os métodos que alteram o estado do objeto como métodos de instância , e não como método estático .

No entanto, podemos encontrar exemplos de métodos estáticos que são puremétodos e tomam o objeto como entrada, como quando precisamos instanciar o objeto com base em certas regras de validação. Por exemplo, o .NET possui o método DateTime.TryParse(String s, DateTime d)para validar e instanciar o objeto. Mas o parâmetro DateTime destá explicitamente marcado como out.

Outro caso pode ser quando comparamos os objetos e queremos obter o objeto desejado como valor de retorno, em vez de um valor booleano / inteiro do resultado da comparação, por exemplo Team.GetHigherScorer(teamA, teamB).IncreaseRanking(). Isso será mais limpo do que:

int compareResult = teamA.compareScoreWith(teamB);
if (compareResult == 1)
    teamA.IncreaseRanking();
else if (compareResult == -1) 
    teamB.IncreaseRanking();

(deixando o caso "empate" por simplicidade).

A injeção de dependência seria um bom motivo para executar a chamada para o método estático. Supondo que a implementação concreta de SomeClasstenha uma cadeia de herança ou seja a implementação de outra classe. Você pode usar uma simulação de um objeto, passá-lo para fins de teste para garantir que seu método faça o que deveria e, em seguida, informar sobre esse status.