Come dovrei andare a specificare che un particolare parametro del mio metodo non è annullabile senza inserire le mie eccezioni all'interno del metodo stesso?C# Specificare il parametro del metodo non è annullabile
C'è qualcosa di simile,
public void Foo (String myRequiredString nullable){
}
Niente integrato, ma si poteva guardare il concetto di "progettazione per contratto", come attuata in (per esempio) LinFu.
Non è possibile, in pratica. Potresti forse usare AOP (come PostSharp) per farne alcuni tramite attributi, o contratti di codice in 4.0 (permettendo controlli in fase di compilazione); ma non esiste un "tipo di riferimento non nullable" (da confrontare con il "valore-tipo nullable" ecc.). Non ultimo: a cosa sarebbero destinati i campi? e quale sarebbe il default (...) essere?
Ci sono state richieste di includere qualcosa nella langauge per aiutare (essenzialmente facendo il controllo nulla per te), ma non è successo. Qualcosa di simile:
public void Foo (string! myRequiredString nullable) {...}
In C# 4.0 è possibile utilizzare Contratti di codice: InfoQ: .NET 4 Feature Focus: Code Contracts.
Tutte le altre soluzioni al momento coinvolgono i controlli del codice di runtime. È possibile utilizzare un framework AOP come PostSharp per iniettare il codice nel metodo, ma tutto si riduce al codice nel metodo.
Uso i contratti di codice con il mio lavoro .NET 3.5/VS2008: http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx –
Oltre ad entrare in qualche versione beta di .NET ... che, seppur eccitante, è rischiosa e non risponde alla tua domanda.
Per ora purtroppo la cosa migliore che puoi fare è aggiungere commenti Intellisense al tuo codice che avvisa di non passare null.
/// <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!");
}
}
ci sono alcune hackish solutions là fuori dove le persone hanno messo in atto una struct nonnullable generica, ma la linea di fondo è quello che vuoi è per Visual Studio non lasciare che si digita "Foo (null)" e per mettere in guardia se lo fai o ti dai qualche errore del compilatore, e il fatto è che per il 99,99% delle chiamate di metodo dove qualcosa non dovrebbe essere annullabile, dovrai fare il == controllo nullo e lanciare comunque una ArgumentNullException, perché tu non so che l'argomento è nullo fino al runtime. Anche se ci fosse quello che stai cercando in C# almeno il compilatore dovrà aggiungere il controllo null e lanciare ArgumentNullException.
Credo che sto dicendo che quello che stai cercando è "zucchero sintattico" per salvare le tue dita un po 'di movimento. Per ora, se sei stufo di digitare, ti consiglio di creare uno snippet di codice.
La libreria Contratti di codice da .NET 4.0 è disponibile pubblicamente per .NET 3.5 e VS2008 . http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx –
Attualmente sto lavorando su questo argomento in C#. .NET ha Nullable <T> per i tipi di valore, ma la funzione inversa non esiste per i tipi di riferimento.
Ho creato NotNullable <T> per i tipi di riferimento e ho spostato il problema da if (non più controlli per null) al dominio datatype. Tuttavia, questo rende l'applicazione per generare eccezioni in runtime e non in fase di compilazione, ma è comunque molto utile per me.
Questo è anche implementato in C# 4.0, in Visual Studio 2010 beta 1. –
In che modo DBC è diverso dal verificare nel metodo se l'argomento è nullo o meno e lanciare un ArgumentNullException f.i. quando l'argomento è nullo? –
Funzionalmente, non è davvero.Sintatticamente, tuttavia, rende chiara l'intenzione dall'interfaccia esterna del metodo decorandolo con un attributo appropriato. –