Libreria di classi .NET Guard?

Question

Sto cercando una libreria o un codice sorgente che fornisca metodi di protezione come il controllo di argomenti null. Ovviamente questo è piuttosto semplice da costruire, ma mi chiedo se ce ne siano già là fuori per .NET. Una ricerca di Google di base non ha rivelato molto.

Answer 1

Esistono CuttingEdge.Conditions . Esempio di utilizzo dalla pagina:

public ICollection GetData(Nullable<int> id, string xml, ICollection col)
{
    // Check all preconditions:
    id.Requires("id")
        .IsNotNull()          // throws ArgumentNullException on failure
        .IsInRange(1, 999)    // ArgumentOutOfRangeException on failure
        .IsNotEqualTo(128);   // throws ArgumentException on failure

    xml.Requires("xml")
        .StartsWith("<data>") // throws ArgumentException on failure
        .EndsWith("</data>"); // throws ArgumentException on failure

    col.Requires("col")
        .IsNotNull()          // throws ArgumentNullException on failure
        .IsEmpty();           // throws ArgumentException on failure

    // Do some work

    // Example: Call a method that should not return null
    object result = BuildResults(xml, col);

    // Check all postconditions:
    result.Ensures("result")
        .IsOfType(typeof(ICollection)); // throws PostconditionException on failure

    return (ICollection)result;
}

Un altro approccio gradevole, che non è impacchettato in una libreria, ma potrebbe essere facilmente sul blog di Paint.Net :

public static void Copy<T>(T[] dst, long dstOffset, T[] src, long srcOffset, long length)
{
    Validate.Begin()
            .IsNotNull(dst, "dst")
            .IsNotNull(src, "src")
            .Check()
            .IsPositive(length)
            .IsIndexInRange(dst, dstOffset, "dstOffset")
            .IsIndexInRange(dst, dstOffset + length, "dstOffset + length")
            .IsIndexInRange(src, srcOffset, "srcOffset")
            .IsIndexInRange(src, srcOffset + length, "srcOffset + length")
            .Check();

    for (int di = dstOffset; di < dstOffset + length; ++di)
        dst[di] = src[di - dstOffset + srcOffset];
}

Lo uso in il mio progetto e puoi prendere in prestito il codice da lì.

Answer 2

Dati i Contratti di codice di Microsoft che escono con .NET 4.0, proverei a trovarne uno che è principalmente compatibile, se possibile - e in caso contrario, scrivilo tu stesso. In questo modo quando esegui l'aggiornamento a .NET 4.0 (eventualmente) la migrazione sarà più semplice.

Answer 3

Esistono diversi metodi che è possibile utilizzare.

Il mio preferito è usare la programmazione orientata agli aspetti. Dai un'occhiata a PostSharp.

Puoi anche dare un'occhiata a Spec #, un'estensione a C #

In 4.0, avrai una libreria di contratti completa.

Infine, un mio collega ha creato una biblioteca di guardie piuttosto utile: http://blueonionsoftware.com/blog.aspx?p= ca49cb62-7ea2-43c5-96aa-91d11774fb48

Answer 4

Non ne conosco nessuno disponibile in commercio. C'è un certo supporto per questo tipo di codice nei modelli & amp; pratiche Enterprise Library. Ci sono anche molti progetti open source che sembrano fare altrettanto (in varia misura) su CodePlex: http://www.codeplex.com/Project/ProjectDirectory.aspx?ProjectSearchText=validation .

Il più delle volte, questi tipi di librerie finiscono per essere scritti su misura e rimangono interni alla società che li utilizza.

In .NET 4.0 è disponibile il supporto per fornire meccanismi per farlo utilizzando Contratti di codice , che sono basati su Spec #.

Answer 5

Di recente ho scritto un post sulle classi di guardia (non ho trovato alcuna informazione): http://ajdotnet.wordpress.com/2009/08/01/posting-guards-guard-classes-explained/

Ho anche pubblicato un'implementazione della rispettiva classe Guard (sentiti libero di usare questo codice così com'è o di adattarlo alle tue esigenze): ajdotnet.wordpress.com/guard-class/

Per quanto riguarda la relazione tra le classi Guard e il Contratto di codice in .NET 4.0 (successore di Spec #), dai un'occhiata al seguente post: www.leading-edge-dev.de/?p=438

(scusate i link frammentati, il sito ha permesso un solo link ...)

HIH, AJ.NET

Answer 6

Installa il pacchetto nuget netfx-guard. Ottieni anche frammenti di codice non null e notempty, e si comporta velocemente come i controlli manuali