OU opérateur en C#

Pas, vous pouvez le faire:

if (new[] { "b", "c" }.Contains(a))

si vous avez la LINQ extensions disponibles, mais ce n'est guère une amélioration.

---

En réponse au commentaire à propos de la performance, voici quelques notions de code de timing. Notez que le code doit être considérée d'un œil critique, j'ai peut-être fait des choses ici qui faussent les timings.

Les résultats de la première:

||, not found: 26 ms
||, found: 8 ms
array.Contains, not found: 1407 ms
array.Contains, found: 1388 ms
array.Contains, inline array, not found: 1456 ms
array.Contains, inline array, found: 1427 ms
switch-statement, not interned, not found: 26 ms
switch-statement, not interned, found: 14 ms
switch-statement, interned, not found: 25 ms
switch-statement, interned, found: 8 ms

Tout le code a été exécuté à deux reprises, et ne passent nr. 2 a été signalé, pour supprimer JITting généraux à partir de l'équation. Les deux passes exécutées chaque type de contrôle d'un million de fois, et exécuté à la fois où l'élément à trouver a été l'un des éléments de la trouver (c'est le if à l'exécution de son bloc), et une fois où l'élément n'a pas été (le bloc ne serait pas exécuter). Les horaires de chacun est rapporté. Je l'ai testé à la fois un pré-construit tableau et qui est intégrée à chaque fois, cette partie, je ne suis pas sûr combien le compilateur déduit et optimise loin, il y a peut être une faille ici.

Dans tous les cas, il apparaît que l'utilisation d'un interrupteur de la déclaration, avec ou sans stage la chaîne en premier, donne à peu près les mêmes résultats que la simple ou de l'instruction, qui est attendue, alors que le tableau de la recherche est beaucoup plus coûteux, ce qui pour moi était également prévu.

Merci de bricoler avec le code, et de corriger (ou un commentaire) si il y a des problèmes.

Et voici le code source, plutôt longue:

using System;
using System.Linq;
using System.Diagnostics;
namespace StackOverflow826081
{
class Program
{
private const Int32 ITERATIONS = 1000000;
static void Main()
{
String a;
String[] ops = CreateArray();
Int32 count;
Stopwatch sw = new Stopwatch();
Int32 pass = 0;
Action<String, Int32> report = delegate(String title, Int32 i)
{
if (pass == 2)
Console.Out.WriteLine(title + ": " + sw.ElapsedMilliseconds + " ms");
};
for (pass = 1; pass <= 2; pass++)
{
#region || operator
a = "a";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
if (a == "b" || a == "c")
{
count++;
}
}
sw.Stop();
report("||, not found", count);
sw.Reset();
a = "b";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
if (a == "b" || a == "c")
{
count++;
}
}
sw.Stop();
report("||, found", count);
sw.Reset();
#endregion
#region array.Contains
a = "a";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
if (ops.Contains(a))
{
count++;
}
}
sw.Stop();
report("array.Contains, not found", count);
sw.Reset();
a = "b";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
if (ops.Contains(a))
{
count++;
}
}
sw.Stop();
report("array.Contains, found", count);
sw.Reset();
#endregion           
#region array.Contains
a = "a";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
if (CreateArray().Contains(a))
{
count++;
}
}
sw.Stop();
report("array.Contains, inline array, not found", count);
sw.Reset();
a = "b";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
if (CreateArray().Contains(a))
{
count++;
}
}
sw.Stop();
report("array.Contains, inline array, found", count);
sw.Reset();
#endregion
#region switch-statement
a = GetString().Substring(0, 1); //avoid interned string
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
switch (a)
{
case "b":
case "c":
count++;
break;
}
}
sw.Stop();
report("switch-statement, not interned, not found", count);
sw.Reset();
a = GetString().Substring(1, 1); //avoid interned string
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
switch (a)
{
case "b":
case "c":
count++;
break;
}
}
sw.Stop();
report("switch-statement, not interned, found", count);
sw.Reset();
#endregion                      
#region switch-statement
a = "a";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
switch (a)
{
case "b":
case "c":
count++;
break;
}
}
sw.Stop();
report("switch-statement, interned, not found", count);
sw.Reset();
a = "b";
sw.Start();
count = 0;
for (Int32 index = 0; index < ITERATIONS; index++)
{
switch (a)
{
case "b":
case "c":
count++;
break;
}
}
sw.Stop();
report("switch-statement, interned, found", count);
sw.Reset();
#endregion
}
}
private static String GetString()
{
return "ab";
}
private static String[] CreateArray()
{
return new String[] { "b", "c" };
}
}
}

OriginalL'auteur Lasse Vågsæther Karlsen

À ma connaissance, ce n'est pas une option.

OriginalL'auteur Ian Jacobs

Non, pas avec cette syntaxe. Mais il existe de nombreuses options pour le code.

if ("bc".Contains(a)) { } //Maybe check a.Length == 1, too.
if ((a[0] & 0x62) == 0x62) { } //Maybe check a.Length == 1, too.
if (new String[] { "b", "c" }.Contains(a)) { }

Peut-être vous pourriez faire quelques surcharge d'opérateur et d'obtenir votre syntaxe de travail, mais cela dépend vraiment de ce que vous voulez atteindre et il est difficile de dire à partir de votre exemple simple.

OriginalL'auteur Daniel Brückner

Non, ce n'est pas la façon dont l'opérateur ou (||) travaille en C#.

Une autre solution, si elle rend le code moins lisible, est de créer une fonction qui vérifie la valeur que vous voulez, quelque chose de similaire à:

public static bool Any(object a, params object[] b)
{
foreach(object item in b)
{
if(a == b)
{
return true;
}
}
return false;
}

OriginalL'auteur Jake Basile