Como e por que decidir entre os métodos de nomeação com os prefixos "get" e "find"

Eu sempre tenho problemas para descobrir se devo nomear um determinado método começando com getSomethingversus findSomething.

O problema reside na criação de auxiliares para APIs mal projetadas. Isso geralmente ocorre ao obter dados de um objeto, o que requer o objeto como parâmetro. Aqui está um exemplo simples:

public String getRevision(Item item) {
    service.load(item, "revision");
    // there is usually more work to do before getting the data..
    try {
        return item.get_revision();
    }
    catch(NotLoadedException exception) {
        log.error("Property named 'property_name' was not loaded", exception);
    }
    return null;
}

Como e por que decidir entre nomear esse método como getRevision()ou findRevision()?

Uso Getquando sei que o tempo de recuperação será muito curto (como em uma pesquisa de uma tabela de hash ou btree).

Findimplica um processo de pesquisa ou algoritmo computacional que requer um período de tempo "mais longo" para ser executado (por algum valor arbitrário de mais tempo).

Eu diria que isso findpode falhar, mas getnão deveria.

Para citar uma conversa que geralmente tenho com meus filhos:

eu: Ei garoto! Vá me encontrar algumas baterias

kid: Mas onde eles estão?

eu: Foi por isso que eu disse para você encontrá- los. Se eu soubesse onde eles estavam, teria dito para você buscá- los. Ou você pode perguntar à sua mãe.

A mesma idéia vale:

• use "get" para um método que retorna uma informação disponível mais barata (e provavelmente pode ser incorporada ou otimizada) ou para uma informação pertencente exclusivamente a esse objeto.

• use "find" para um método que funciona para obter uma informação ou usa outros objetos para encontrá-la.

Encontrar implica não ter o resultado, como ao executar uma consulta ao banco de dados com alguns parâmetros que podem mudar entre as chamadas. Get, por outro lado, implica que os resultados são conhecidos pelo método antecipadamente ou não serão alterados uma vez conhecidos, que não há parâmetros para a chamada.
Então, eu usaria, por exemplo, Customer findCustomerById (long customerId) e Customer getCustomer ()

Eu aplico o seguinte padrão:

• Foo GetFoo() não pode retornar nulo e sua complexidade é O (log (n)) ou menor
• bool TryGetFoo(out Foo) pode retornar nulo e sua complexidade é O (log (n)) ou menor
• Foo FindFoo() não pode retornar nulo e sua complexidade é maior que O (log (n))
• bool TryFindFoo(out Foo) pode retornar nulo e sua complexidade é maior que O (log (n))

Dessa forma, o código é bem claro sobre a intenção e a complexidade que você pode esperar.

Normalmente, os Getters são para acesso direto à lista ou dicionário / conjunto.
Os Finders são pesquisa profunda, varredura completa da lista, etc ...

No seu caso:

public bool TryGetRevision( Item item, out String revision ) 
{
    service.load( item, "revision" );
    // there is usually more work to do before getting the data..
    try 
    {
        revision = item.get_revision();
        return true;
    }
    catch( NotLoadedException exception )
    {
        log.error( "Property named 'property_name' was not loaded", exception );
        revision = "";
        return false;
    }
}

geté apropriado em qualquer caso _ de fato, é geralmente assumido que, para obter algo, você precisa encontrá-lo primeiro. Então, se você não tiver certeza, use get.

Eu usaria findmétodos como findMinimum()ou findOptimal(), ou seja, onde existe algum algoritmo especial que calcula o valor de retorno, e não faz simplesmente uma solicitação ao DB, sistema de arquivos, servidor remoto, etc. para receber alguns dados.

Não use encontrar ou obter prefixos. Isso é uma violação do UniformAccessPrinciple, criado por bertrand meyer. Por que não criar um método como o seguinte:

public String revision(Item item)

Geralmente usarei Getpara recuperar um objeto / valor e Findrecuperar sua localização (em uma matriz, por exemplo).

por ex:

object o = obj.GetItem( 'name');

integer i = somearray.Find( 'name');

Para mim, findimplica que pode haver mais de um resultado presente. getimplica apenas um.