¿Cómo puedo especificar que un parámetro particular de mi método no puede contener nulos sin incluir mis propias excepciones en el método mismo?C# El parámetro del método especificado no puede contener nulos
¿Existe algo así como,
public void Foo (String myRequiredString nullable){
}
Nada incorporada, pero se podría considerar el concepto de "diseño por contrato", como se aplica en (por ejemplo) LinFu.
No puedes, básicamente. Quizás pueda usar el AOP (como PostSharp) para hacer algo por usted a través de atributos, o contratos de código en 4.0 (permitiendo verificaciones en tiempo de compilación); pero no existe un "tipo de referencia no anulable" (para compararlo con el "tipo de valor anulable", etc.). No menos importante: ¿a qué se inicializarían los campos? y ¿qué sería el default (...)?
Ha habido solicitudes para incluir algo en el idioma para ayudar (esencialmente haciendo el cheque nulo para usted), pero no ha sucedido. Algo así como:
public void Foo (string! myRequiredString nullable) {...}
En C# 4.0 se puede utilizar Code Contracts: InfoQ: .NET 4 Feature Focus: Code Contracts.
Todas las demás soluciones en este momento implican verificaciones de código de tiempo de ejecución. Puede usar un marco AOP, como PostSharp para inyectar el código en el método, pero todo se reduce al código en el método.
Uso contratos de código con mi trabajo de .NET 3.5/VS2008: http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx –
Además de entrar en una versión beta de .NET ... que, aunque emocionante, es arriesgado y no responde realmente a su pregunta.
Por ahora, lamentablemente, lo mejor que puede hacer es agregar comentarios de Intellisense a su código que adviertan que no pase nulos.
/// <summary>
/// This Foo method does Bar to something.
/// </summary>
/// <param name="myRequiredString">required, do NOT pass nulls. I really really mean it!</param>
public void Foo(String myRequiredString)
{
if (myRequiredString == null)
{
throw new ArgumentNullException("myRequiredString", "It said required in the name of the argument, dummy!");
}
}
hay algunas hackish solutions por ahí donde la gente ha implementado una estructura NonNullable genérico, pero el fondo es lo que queremos es que el Visual Studio para no dejar de escribir "Foo (nulo)" y para advertir si haces o te da algún error de compilación, y el hecho es que para el 99.99% de las llamadas a métodos donde algo no debe ser anulable, vas a tener que hacer == comprobación nula y lanzar una excepción ArgumentNullException de todas maneras, porque No sé que el argumento es nulo hasta el tiempo de ejecución. Incluso si hubiera lo que buscas en C# como mínimo, el compilador tendrá que agregar el cheque nulo y arrojar ArgumentNullException allí.
Supongo que lo que estás buscando es "azúcar sintáctica" para ahorrar un poco de movimiento a tus dedos. Por ahora, si estás cansado de tipear, te recomendaría crear un Fragmento de código.
La biblioteca de Contratos de código de .NET 4.0 está públicamente disponible para .NET 3.5 y VS2008 . http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx –
Actualmente estoy trabajando en este tema en C#. .NET tiene Nullable <T> para los tipos de valor, pero la función inversa no existe para los tipos de referencia.
Creé NotNullable <T> para tipos de referencia, y moví el problema de if (no más comprobaciones de nulo) al dominio de tipo de datos. Sin embargo, esto hace que la aplicación genere excepciones en tiempo de ejecución y no en tiempo de compilación, pero sigue siendo muy útil para mí.
Esto también se implementa en C# 4.0, en Visual Studio 2010 beta 1. –
¿En qué se diferencia DBC de su método si el argumento es nulo o no, y lanza una ArgumentNullException f.i. cuando el argumento es nulo? –
Funcionalmente, no es realmente.Sintácticamente, sin embargo, hace que la intención sea clara desde la interfaz externa del método al decorarla con un atributo apropiado. –