To strictly do what you want it would look something like this:

public TipoDoRetornoDoMetodoDadosDermaClube ProdutosDermaClube {get; set;}

public bool CarregaProdutosDermaClube(string consulta) {
    var buscaProdutosDermaClube = new BuscaProdutosDermaClubeDAL();
    Retorno = this.buscaProdutosDermaClube.DadosDermaClube("");
    if (string.IsNullOrEmpty(consulta)) {
        return false;
    }
    return Retorno[0].idproduto.Contains(consulta);
}

to get the return would look something like this:

TipoDoRetornoDoMetodoDadosDermaClube variavel;
if (objeto.CarregaProdutosDermaClube("Sei lá o que")) {
    variavel = objeto.Retorno; //isto é horrível
}

Conceptually certain

But this is probably a conceptual error, it is abusing the object for something unnecessary. The most correct thing I understood would be:

public bool CarregaProdutosDermaClube(string consulta, out TipoDoRetornoDoMetodoDadosDermaClube retorno) {
    var buscaProdutosDermaClube = new BuscaProdutosDermaClubeDAL();
    retorno = this.buscaProdutosDermaClube.DadosDermaClube("");
    if (string.IsNullOrEmpty(consulta)) {
        return false;
    }
    return retorno[0].idproduto.Contains(consulta);
}

Here's how it goes:

TipoDoRetornoDoMetodoDadosDermaClube variavel;
if (objeto.CarregaProdutosDermaClube("Sei lá o que", out TipoDoRetornoDoMetodoDadosDermaClube variavel) {
    //faz algo aqui se precisar
}

C # 7

If you are using C # 7 you can do better:

public (bool, TipoDoRetornoDoMetodoDadosDermaClube) CarregaProdutosDermaClube(string consulta) {
    var buscaProdutosDermaClube = new BuscaProdutosDermaClubeDAL();
    retorno = this.buscaProdutosDermaClube.DadosDermaClube("");
    if (string.IsNullOrEmpty(consulta)) {
        return (false, null);
    }
    return (retorno[0].idproduto.Contains(consulta), retorno);
}

Call it like this:

(var ok, var variavel) = objeto.CarregaProdutosDermaClube("Sei lá o que");
if (ok) {
    //faz algo aqui se precisar
}

Tuple

If you still want to use tuple before C # 7 can, but it is not so convenient and optimized.

public Tuple<bool, TipoDoRetornoDoMetodoDadosDermaClube> CarregaProdutosDermaClube(string consulta) {
    var buscaProdutosDermaClube = new BuscaProdutosDermaClubeDAL();
    retorno = this.buscaProdutosDermaClube.DadosDermaClube("");
    if (string.IsNullOrEmpty(consulta)) {
        return Tuple.Create(false, null);
    }
    return Tuple.Create(retorno[0].idproduto.Contains(consulta), retorno);
}

Call it like this:

TipoDoRetornoDoMetodoDadosDermaClube variavel;
var tupla = objeto.CarregaProdutosDermaClube("Sei lá o que");
if (tupla.Item1) {
    variavel = tupla.Item2
}

I can still create a specific class to handle the two values in a more typed way, but I see little advantage and some disadvantages.

There is a implementation proposal of Optional which is a specialization of a tuple. To be cool even C # would need another feature that it does not have. To do more or less, you can copy the idea and create a Optional and use it yourself. But in this circumstance I see no advantage.

In fact maybe just returning the object may suffice. Instead of returning a bool and verifying it, make sure the object is null and make sure it is null when it did not produce a usable result.

There is still the possibility of using exception, but I do not even think this is too bad.

Read more at Why should we avoid returning error codes? .

I've placed it on GitHub for future reference.

It is not possible to expose a local variable outside its scope, so it will be necessary to use a typed property eg:

// Poderá ser acessado por qualquer parte do sistema.
public BuscaProdutosDermaClubeDAL TBuscar {get; set;}
// Ou poderá ser acessada somente pelos metodos da classe.
private BuscaProdutosDermaClubeDAL TBuscar {get; set;}

public bool CarregaProdutosDermaClube(string consulta)
{
   this.TBuscar = new BuscaProdutosDermaClubeDAL();

   var retorno = this.TBuscar.DadosDermaClube("");

    if (consulta != "")
    {
        return retorno[0].idproduto.Contains(consulta);
    }

    return false;
}