Qual è il design migliore: determinare se una funzione deve essere eseguita al di fuori di essa o all'interno di essa?

Il bit importante è chi possiede la barra ? Se non è chiaro, considera se B può essere all'altezza del suo nome del metodo considerando il valore di Bar. Se è così, allora rendilo parte di B. Se così non fosse, allora rendilo parte di A.

In uno scenario reale, generalmente troverai metodi che soddisfano una responsabilità di progettazione e metodi di supporto che soddisfano i passaggi di implementazione. Generalmente, la decisione di chiamare un metodo di implementazione risiede nel metodo API, che è generalmente il metodo pubblico.

public class Control {
    public bool IsVisible;
    public void Render() {
       if (this.IsVisible) {
          this.PrepareForRender();
       }
    }
    private void PrepareForRender() {
       // just do it. Don't check IsVisible
    }
 }

È possibile che tu abbia due diversi metodi API che si chiamano a vicenda. In tal caso, suggerirei di ricorrere alla semantica del perché B non viene eseguito quando Bar è falso? È perché B non è necessario, quindi B dovrebbe decidere.

 public class List {
    public int Count;
    public void SetTo(object[] values) {
       this.Clear(); // need to clear values; don't really care how
    }
    public void Clear() {
       // Count = 0 is just a shortcut to fulfilling Clear's responsibility
       if (this.Count == 0) return; 
    }
 }

È perché B non è corretto? Quindi A dovrebbe decidere.

public class File {
    public bool IsBinary;
    public void Write() {
       if (this.IsBinary) {
          this.OpenBinaryStream();
       } else {
          this.OpenTextStream();
       }     
    }
    private void OpenBinaryStream() {
    }
    private void OpenTextStream() {
    }
 }

Perché è attivamente dannoso? A dovrebbe decidere e B dovrebbe lanciare un'eccezione:

public class File {
    public bool UseSecureDelete;
    public void Delete() {
       if (this.UseSecureDelete) {
          this.ZeroBytes();
       }
    }
    private void ZeroBytes() {
       if (!this.UseSecureDelete) throw new InvalidOperationException();
    }
 }

Non sono assolutamente d'accordo con @jmquigley.

Qualunque "guadagno in termini di prestazioni" è qui in gioco è minuscolo e trascurabile.

La condizione "se" dovrebbe risiedere nel membro in cui è logicamente (o anche semanticamente) una parte di.

Dal momento che non ci hai indizi su quali siano le reali funzioni dell'oggetto o del membro, solo tu puoi prendere questa decisione.

Dipende se foo() e B() giacciono sullo stesso livello di astrazione.

Se lo fanno, allora Opzione A è preferibile.

Altrimenti ( foo() è un dettaglio di implementazione di B() e quindi inferiore a B() ) L'opzione B è migliore.

Quindi, il principio guida qui è: non mescolare i livelli di astrazione .

Vince il codice più breve. Non vuoi avere più aspetti di:

 if(!bar.contains(baz))
   B(baz, stuff);

Se non vuoi MAI aggiungere qualcosa al bar già presente, la seconda implementazione è chiaramente superiore.

Tuttavia, in quasi tutti i linguaggi moderni, puoi creare bar un set, quindi pronunciare qualcosa del tipo:

if (bar.add(baz))
  // more stuff

Ti suggerisco di consultare la mitica anatra di gomma del "Anatra debugging dell'anima" famosa. Non lasciatevi ingannare dai suoi poteri di debugging perché è anche abile nel capire i problemi di progettazione.