Estoy buscando una biblioteca o código fuente que proporcione métodos de protección, como la comprobación de argumentos nulos. Obviamente, esto es bastante simple de construir, pero me pregunto si ya hay algo para .NET. Una búsqueda básica de Google no reveló mucho..NET Guard Class Library?
No es CuttingEdge.Conditions. Ejemplo de uso de la página:
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;
}
Otro enfoque agradable, que no está envasado en una biblioteca, pero podría ser fácilmente, on Paint.Net blog:
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 en my project y se podía tomar prestado el código desde allí.
Dado el Code Contracts de Microsoft que sale con .NET 4.0 Intentaré encontrar uno que sea más compatible, si es posible, y si no, escríbalo usted mismo. De esta forma, cuando actualice a .NET 4.0 (eventualmente) la migración será más fácil.
Existen varios métodos que puede utilizar.
Mi favorito es el uso de programación orientada a aspectos. Echa un vistazo a PostSharp.
También puede echar un vistazo a SpeC#, una extensión de C#
En 4.0, tendrá una biblioteca contrato con todas las funciones.
Por último, un colega mío ha llegado con una biblioteca de guardia bastante útil: http://blueonionsoftware.com/blog.aspx?p=ca49cb62-7ea2-43c5-96aa-91d11774fb48
no sé de ninguno que están disponibles comercialmente. Existe algún tipo de soporte para este tipo de código en los patrones & prácticas Enterprise Library. También hay muchos proyectos de código abierto que parecen hacer esto también (en diversos grados) en CodePlex: http://www.codeplex.com/Project/ProjectDirectory.aspx?ProjectSearchText=validation.
La mayoría de las veces, este tipo de bibliotecas terminan siendo escritas a medida y se mantienen internas a la compañía que las usa.
Hay compatibilidad en .NET 4.0 para proporcionar mecanismos para hacer esto usando Code Contracts, que se basan en SpeC#.
Hace poco escribí un post acerca de las clases de guardia (no haber encontrado ninguna información tampoco): http://ajdotnet.wordpress.com/2009/08/01/posting-guards-guard-classes-explained/
También publicó una aplicación respectiva clase Guardia (no dude en utilizar este código como es, o para ajustarla a su necesidades): ajdotnet.wordpress.com/guard-class/
Con respecto a la relación entre las clases Guard y Code Contract en .NET 4.0 (sucesor de SpeC#), eche un vistazo a la siguiente publicación: www.leading -edge-dev.de/?p=438
(disculpe los enlaces fragmentados, el sitio solo permite uno enlace ...)
HIH, AJ.NET
Instale el paquete nuget netfx-guard.También obtienes fragmentos de código notnull y notempty, y funciona tan rápido como tus verificaciones manuales
Estoy marcando esto como la respuesta aceptada porque sin duda se ajusta a mis necesidades. –