C# 如果检查，则反转

我有一个庞大的检查列表，例如检查整数是4还是10，如果是4，它会将这个int更改为10，反之亦然，所以我的if检查如下：

int i = getval();
if (i == 4)
{
    i = 10;
}
else if (i == 10)
{
    i = 4;
}

---

我的问题是，还有另一种方法可以做到这一点，而无需检查每个条件。

您正在寻找语句

int i = getval();
switch(i)       
      {         
         case 4:   
            i = 10;
            break;                  
         case 10:            
            i = 4;
            break;                 
         default:            
            Console.WriteLine("Invalid selection. Please select 4 or 10.");            
            break;      
       }

---

您不会绕过某种if/switch语句，因为从4到10再返回没有简单的方法。 如果在0和X之间进行交换，则可以转到

variable=X-variable可以互换，但是对于4和10，上面的代码就可以了。
试试这个：

int i = getval() == 4 ? 10 : 4;

这应该检查
getval（）
是否为4，然后在4和10之间切换。
这就是您想要的

int i = getval();
switch (i)
{
    case 4:
    i=10;
    break;
    case 10:
    i=4;
    break;
}

如果你有一个大的列表，你可以考虑一些列表结构。
static Dictionary<int, int> exchange = new Dictionary<int, int>();

static Constructor()
{
    AddExchangePair(4, 10);
    AddExchangePair(3, 12);
    ...
}

static void AddExchangePair(int a, int b)
{
    exchange.Add(a,b);
    exchange.Add(b,a);
}

public staic bool Exchange(ref int value)
{
    int newValue = 0;
    bool exchanged = exchange.TryGetValue(value, out newValue);
    if (exchanged) value = newValue;
    return exchanged;
}

静态字典交换=新字典（）；
静态构造函数（）
{
加法器交换对（4，10）；
加法器交换对（3，12）；
...
}
静态无效加法交换对（int a，int b）
{
加入（a，b）；
加入（b，a）；
}
公共staic布尔交换（参考整数值）
{
int newValue=0；
bool exchanged=exchange.TryGetValue（值，out newValue）；
如果（交换）值=新值；
交换的回报；
}

这适用于庞大的交换对列表

如果使用重复的号码调用AddExchangePair，例如（7,14）和（14,16），则会出现异常。你可能不得不考虑在那种情况下该怎么办。
 < P>有人把我打了这个（写得更好），但自从我写了代码以后，我就把它张贴了。

我还想指出的是，在我们的两个答案中使用
ref
可能只是为了保持与您的问题的一致性，实际上类似的东西可能会使用函数方法，因此，它将调用
I=Swap（I），而不是调用
Swap（ref I）
如果未找到匹配项，Swap将返回其输入。当然，你可能需要使用
ref
，这是有原因的——我只是想不出一个显而易见的理由

void Main()
{   
    int i;

    i = 1; 
    Swap(ref i); // no swap
    Console.WriteLine (i);

    i = 10; 
    Swap(ref i); // swap with 4
    Console.WriteLine (i);

    i = 4;
    Swap(ref i); // swap with 10
    Console.WriteLine (i);
}

void Swap(ref int i)
{
    if(swaps == null)
    {
        swaps = new List<Tuple<int, int>>();
        swaps.Add(Tuple.Create(4, 10));
    }

    int compareTo = i;
    var swap1 = from c in swaps where c.Item1 == compareTo select c.Item2;
    var swap2 = from c in swaps where c.Item2 == compareTo select c.Item1;

    if(swap1.Any())
        i = swap1.Single();
    else if(swap2.Any())
        i = swap2.Single();
}

List<Tuple<int, int>> swaps;

我不同意使用开关，因为你有一个“庞大的支票清单”。我会在字典的支持下检查它自己的类。这将有助于最小化switch语句的大小，并强制将检查与代码的其余部分分开：

class Cases
{
    private  static readonly Dictionary<int, int>
        List = new Dictionary<int, int>
        {
            {9, 5},
            {3, 2},
            {7, 12},
            {4, 10}
        }; 
    public static int GetCaseValue (int v)
    {
        int result = 0;
        return List.TryGetValue(v, out result) ? result : v;
    }
}
class Program
{
    public static void Main()
    { 
        var test = Cases.GetCaseValue(4);
        test = Cases.GetCaseValue(12);
    }
}

类案例
{
专用静态只读字典
列表=新字典
{
{9, 5},
{3, 2},
{7, 12},
{4, 10}
}; 
公共静态int GetCaseValue（int v）
{
int结果=0；
返回列表.TryGetValue（v，输出结果）？结果：v；
}
}
班级计划
{
公共静态void Main（）
{ 
var测试=案例。GetCaseValue（4）；
测试=案例。GetCaseValue（12）；
}
}
我猜你错过了第一句话，我有一个庞大的检查列表，例如检查……这应该仍然有效，不管列表有多大，对吗？你只是把它放在一个循环中。我不知道c#，但你可以像这样在10和4之间交替I的值：
I=7-I
我有一个庞大的支票列表。你所有的支票都是这种类型的吗？e、 g.如果是这两个值中的一个交换？它们都涉及到
getval（）
的结果吗？还是更复杂？好吧，只有在这种情况下才会如此。我还有另外一个值，比如9和5。不过还是要谢谢你，我想switch会帮上忙的。一本
字典怎么样？因此您可以编写
var i=MyDictionary[getval（）]仅适用于大型收藏。你能告诉我们你的数据源是什么吗？随机的想法——如果你必须得到最大的性能（并且类似的东西可能是在C/C++或汇编中），我想知道是否可以设计一个棘手的位级算法……你可能想考虑移动<代码> value = NealValuy；<代码>到新行以提高可读性+1考虑使用字典收集大量数据很困难。注意，在本例中，您需要将{4,10}和{10,4}添加到字典中。您的交换函数做得很好。我喜欢它模仿内部对TryGetValue的调用。@Casperah，关于您所指的列表结构-类似于B树的东西？我想知道在某个地方.NET集合中是否已经存在这种情况……谢谢：）一旦你开始使用对象初始值设定项，你就再也不会回去了。并且将对象初始值设定项与集合初始值设定项一起使用——这真是一种美！
1
4
10

class Cases
{
    private  static readonly Dictionary<int, int>
        List = new Dictionary<int, int>
        {
            {9, 5},
            {3, 2},
            {7, 12},
            {4, 10}
        }; 
    public static int GetCaseValue (int v)
    {
        int result = 0;
        return List.TryGetValue(v, out result) ? result : v;
    }
}
class Program
{
    public static void Main()
    { 
        var test = Cases.GetCaseValue(4);
        test = Cases.GetCaseValue(12);
    }
}