Devo usare ancora Debug.Assert oggi?

Non vedo alcun motivo per cui non dovresti usare Assert. In questo modo hai già riconosciuto la necessità di protezioni, come le precondizioni e l'amp; invarianti e si stanno muovendo verso Design by Contract . Assert è solo un modo per ottenere questo ...

// Precondition using Asert
void SomeMethod(Foo someParameter)
{
    Debug.Assert(someParameter != null)
}

// Precondition using If-Then-Throw
void SomeMethod(Foo someParameter)
{
    if (someParameter == null)
        throw new ArgumentNullException("someParameter");
}

// Precondition using Code Contracts
void SomeMethod(Foo someParameter)
{
    Contract.Requires(someParameter != null);
}

// Precondition using some custom library
void SomeMethod(Foo someParameter)
{
    Require.ArgumentNotNull(() => someParameter);
}

Tutti sono modi per raggiungere la stessa cosa: robustezza nel codice. Si tratta solo di scegliere un'opzione, di cui Assert è una scelta valida.

Nota che non ho ancora menzionato i test unitari finora, poiché realizzano qualcosa di molto diverso. Un test unitario dimostra formalmente la robustezza del codice esercitando una guardia:

[Test]
void SomeMethod_WhenGivenNull_ThrowsArgumentNullException()
{
    delegate call = () => someObject.SomeMethod(null);

    Assert.That(call).Throws<ArgumentNullException>();
}

Questo è un tipo completamente diverso di asserire ...

** Si noti che in alcuni framework è in realtà abbastanza difficile testare l'unità per un errore di asserzione, in quanto un errore di asserzione può abbattere l'intero runtime, quindi una delle altre opzioni potrebbe essere preferita ... *

Considero le assert e i test unitari come due strumenti diversi nella mia cassetta degli attrezzi. Alcune cose sono più adatte a una, e alcune sono più adatte all'altra.

Ad esempio, in questi giorni uso principalmente asserzioni per convalidare i parametri per metodi non pubblici.

Visualizzo Debug.Assert come ottimizzazione prematura al giorno d'oggi. A meno che tu non abbia davvero bisogno delle prestazioni, sopprimendo l'Assert in modalità di rilascio puoi nascondere i bug più a lungo.

Come MattDavey sottolinea che i contratti di codice possono essere superiori, fornendo un controllo statico anziché dinamico controllando, e se non disponibile, preferirei Trace.Assert o un semplice vecchio if(x) throw SomeException;