Quali sono i modelli di utilizzo comuni e non più comuni per il lavoro in C# "è". L'ho usato di recente per contare il numero di celle usate in un array tipizzato, (ancora bloccato nella parte inferiore con le classi generate da xsd, dato che xsd2code aveva un numero di problemi con lo schema progettato da IETF, quindi nessun generico).C# Schemi di utilizzo per la parola chiave "è"
Quali altri modelli di utilizzo comuni e più comuni sono offerti.
La parola chiave 'is' è utile per determinare se un oggetto è convertibile in un tipo tramite una conversione di riferimento, di box o di unboxing (C# lang spec 7.9.10). È simile a "come", tranne che in realtà non fa la conversione, ma restituisce semplicemente se è possibile.
È utile in qualsiasi scenario in cui sapere se un oggetto è convertibile in un tipo è utile ma avere l'oggetto tramite un riferimento a quel tipo non è necessario.
if (o is SomeType) {
TakeSomeAction();
}
Se avere un riferimento del tipo specificato il valore è utile, allora è più efficiente utilizzare l'operatore 'come' invece.
// Wrong
if (o is SomeType) {
SomeType st = (SomeType)o;
st.TakeSomeAction();
}
// Right
SomeType st = o as SomeType;
if (st != null) {
st.TakeSomeAction();
}
In realtà, non lo uso quasi mai. Quando ne ho bisogno, di solito è perché ho intenzione di trasmettere il valore al tipo richiesto in ogni caso, quindi preferisco usare come invece.
Compare:
if (x is MyType)
{
MyType y = (MyType)x;
...
}
E:
MyType y = x as MyType;
if (y != null)
{
...
}
Nel primo caso: 2 operazioni (1 tipo assegno + 1 del cast)
Nel secondo caso: 1 (tipo controllo + getto in un colpo)
Se la mia memoria mi serve Bene il codice emesso è fondamentalmente lo stesso –
Ho appena controllato con Reflector, non è ... Comunque non lo farebbe ha senso, dal momento che questi due approcci sono semanticamente diversi (ad esempio 'as' può essere usato solo con tipi di riferimento) –
Non ricordo di aver mai usato is. La maggior parte delle volte, se hai bisogno di sapere se un'istanza è di un certo tipo, devi usarla come tale.
Quindi di solito lo getto direttamente utilizzando as o il casting esplicito se sono sicuro che sia effettivamente del tipo in questione.
Provo a scrivere codice che non è necessario eseguire il cast o trovare informazioni sul tipo più di una volta. Quindi scrivere is prima di un cast di un tipo di riferimento non è certamente raccomandabile.
" è "prima che un cast sia l'unico modo per lanciare in sicurezza" oggetti "su tipi di valori come" come "vuole essere in grado di restituire un valore null, che non è supportato per i tipi di valore. –
@Hans: sì hai ragione, lo riformulo per renderlo specifico per i tipi di riferimento. –
Con l'imminente v4 invece di utilizzare è e in quanto vi è un approccio diverso possibile.
void somemethod(dynamic o)
{
DoStuff(o);
}
DoStuff(neededType o){}
DoStuff(object o){}
che comunque potrebbe avere un successo performnce ma rende per belle leggibilità
dipende se avete bisogno di un riferimento al tipo se is un tipo del tipo specificato. Se è così, dovresti usare `come keyworkd.
MyObject mo = obj as MyObject;
if (mo == null) {
// do something.
} else {
// do something else.
}
che fornirebbe un riferimento che è possibile verificare per null. Altrimenti, usando l'opratore as si finisce per richiedere di eseguire comunque un cast.
Penso che lo schema più comune sia quello usato per quello che fa ...(il resto è piuttosto raro), come in A is B o A strumenti B. –