se le istruzioni corrispondono a più valori

Question

Un modo più semplice di scrivere questo se dichiarazione?

if (value==1 || value==2)

Per esempio ... in SQL si può dire where value in (1,2) invece di where value=1 or value=2.

Sto cercando qualcosa che potesse funzionare con qualsiasi tipo di base ... string, int, ecc

Answer 1

ne dite:

if (new[] {1, 2}.Contains(value)) 

Si tratta di un hack però :)

O se non vi occupate di creare il proprio metodo di estensione, è possibile creare la seguente:

public static bool In<T>(this T obj, params T[] args) 
{ 
    return args.Contains(obj); 
} 

e si può usare in questo modo:

if (1.In(1, 2)) 

:)

Answer 2

Se si dispone di un elenco, è possibile utilizzare .Contains (yourObject), se sei solo cercandolo esistente (come un dove). Altrimenti guarda il metodo di estensione Linq. Any().

Answer 3

In generale, no.

Sì, ci sono casi in cui l'elenco è in un Array o List, ma non è il caso generale.

Answer 4

E 'questo quello che stai cercando?

if (new int[] { 1, 2, 3, 4, 5 }.Contains(value)) 

Answer 5

utilizzando LINQ,

if(new int[] {1, 2}.Contains(value))

Ma avrei dovuto pensare che l'originale, se è più veloce.

Answer 6

Un modo più complicato :) che emula 'IN' di SQL:

public static class Ext {  
    public static bool In<T>(this T t,params T[] values){ 
     foreach (T value in values) { 
      if (t.Equals(value)) { 
       return true; 
      } 
     } 
     return false; 
    } 
} 

if (value.In(1,2)) { 
    // ... 
} 

Ma andare per il modo standard, è più leggibile.

EDIT: una soluzione migliore, secondo @ suggerimento di Kobi:

public static class Ext {  
    public static bool In<T>(this T t,params T[] values){ 
     return values.Contains(t); 
    } 
} 

Answer 7

Utilizzando metodi di estensione:

public static class ObjectExtension 
{ 
    public static bool In(this object obj, params object[] objects) 
    { 
     if (objects == null || obj == null) 
      return false; 
     object found = objects.FirstOrDefault(o => o.GetType().Equals(obj.GetType()) && o.Equals(obj)); 
     return (found != null); 
    } 
} 

Ora si può fare questo:

string role= "Admin"; 
if (role.In("Admin", "Director")) 
{ 
    ... 
} 

Answer 8

public static bool EqualsAny<T>(IEquatable<T> value, params T[] possibleMatches) { 
    foreach (T t in possibleMatches) { 
     if (value.Equals(t)) 
      return true; 
    } 
    return false; 
} 
public static bool EqualsAny<T>(IEquatable<T> value, IEnumerable<T> possibleMatches) { 
    foreach (T t in possibleMatches) { 
     if (value.Equals(t)) 
      return true; 
    } 
    return false; 
} 

Answer 9

In alternativa, e questo darebbe una maggiore flessibilità se il test sui valori diversi da 1 o 2, in futuro, è quello di utilizzare un'istruzione switch

switch(value) 
{ 
case 1: 
case 2: 
    return true; 
default: 
    return false 
} 

Answer 10

Più facile è soggettivo, ma forse l'istruzione switch sarebbe più facile? Non è necessario ripetere la variabile, in modo che più valori possano adattarsi alla linea e una riga con molti confronti è più leggibile della controparte che utilizza l'istruzione if.

Answer 11

Un extensionmethod come questo sarebbe farlo ...

public static bool In<T>(this T item, params T[] items) 
{ 
    return items.Contains(item); 
} 

usare in questo modo:

Console.WriteLine(1.In(1,2,3)); 
Console.WriteLine("a".In("a", "b")); 

Answer 12

In vb.net o C# Mi aspetterei che l'approccio generale più veloce per confrontare un variabile rispetto a qualsiasi numero ragionevole di oggetti con nome separato (al contrario, ad esempio, di tutte le cose in una collezione) sarà semplicemente confrontare ogni oggetto con il confronto e molto come hai fatto. È certamente possibile creare un'istanza di una raccolta e vedere se contiene l'oggetto, e farlo potrebbe essere più espressivo che comparare l'oggetto con tutti gli oggetti individualmente, ma a meno che non si usi un costrutto che il compilatore può riconoscere esplicitamente, tale codice quasi certamente sarà molto più lento del semplice fare i confronti individuali. Non mi preoccuperei della velocità se il codice per sua natura funzionasse al massimo poche centinaia di volte al secondo, ma sarei diffidare dal fatto che il codice venga riproposto a qualcosa che viene eseguito molto più spesso di quanto inizialmente previsto.

Un approccio alternativo, se una variabile è qualcosa come un tipo di enumerazione, consiste nel scegliere valori di enumerazione power-of-two per consentire l'uso di maschere di bit. Se il tipo di enumerazione ha 32 o meno valori validi (ad esempio, iniziando Harry = 1, Ron = 2, Hermione = 4, Ginny = 8, Neville = 16) uno potrebbe memorizzarli in un numero intero e controllare più bit contemporaneamente in un singolo operazione ((if ((thisOne & (Harry | Ron | Neville | Beatrix))! = 0)/* Esegui qualcosa * /. Ciò consentirà un codice veloce, ma limitato alle enumerazioni con un numero limitato di valori.

Un approccio un po 'più potente, ma che deve essere usato con cautela, consiste nell'usare alcuni bit del valore per indicare gli attributi di qualcosa, mentre altri bit identificano l'elemento. Ad esempio, il bit 30 potrebbe indicare che un personaggio è maschio il bit 29 potrebbe indicare un amico di Harry ecc., mentre i bit più bassi distinguono tra i personaggi: questo approccio consentirebbe di aggiungere personaggi che potrebbero o meno essere amici di Harry, senza richiedere il codice che controlla per amico di Harry per cambiare. Un avvertimento è che bisogna fare una distinzione tra le costanti di enumerazione utilizzate per impostare un valore di enumerazione e quelle utilizzate per testarlo. Ad esempio, per impostare una variabile per indicare Harry, si potrebbe desiderare di impostarla su 0x60000001, ma per vedere se una variabile è Harry, si dovrebbe testare il bit con 0x00000001.

Un altro approccio, che può essere utile se il numero totale di valori possibili è moderato (ad esempio 16-16.000 o giù di lì) deve avere una matrice di flag associata a ciascun valore.Si potrebbe quindi codificare qualcosa come "if (((characterAttributes [theCharacter] & chracterAttribute.Male)! = 0)". Questo approccio funzionerà al meglio quando il numero di caratteri è piuttosto ridotto Se l'array è troppo grande, i messaggi di cache potrebbero rallentare giù il codice al punto che il test contro un piccolo numero di caratteri singolarmente sarebbe più veloce.

Answer 13

Se si cerca un valore in un elenco fisso di valori molte volte, HashSet <T> dovrebbe essere utilizzato, anche solo per HashSet mentre memorizza/cerca i dati nell'albero di ricerca binario

HashSet<int> nums = new HashSet<int> { 1, 2, 3, 4, 5 }; 
// .... 
if (nums.Contains(value)) 

Answer 14

Ho avuto lo stesso problema bu lo ha risolto con uno switch di stato (un valore che si sta attivando) { caso 1: il codice che si desidera verificare; caso 2: il codice che si desidera verificare; predefinito: restituire un valore }