C#-将范围限制为三元语句

编辑：最初，本文的示例处理的是哈希代码，因此您将看到一些使用param.GetHashCode（）而不是（1+param）的注释。为了更深入地理解这一点，我将函数改为计算1加上某个数字的绝对值

假设我想创建一个函数来计算某个整数的绝对值（不使用Math.Abs）。我可以写一些类似的东西：

int absoluteValueOfOnePlus(int param)
{
    int onePlusParam= 1 + param;
    return ((onePlusParam> 0) ? (onePlusParam) : (-onePlusParam) );
}

int absoluteValueOfOnePlus(intparam)
{
    return (((int onePlusParam = 1 + param) > 0) ? (onePlusParam) : (-onePlusParam) );
}

我希望将OnePlusSparm的范围限制在三元语句中——类似于：

int absoluteValueOfOnePlus(int param)
{
    int onePlusParam= 1 + param;
    return ((onePlusParam> 0) ? (onePlusParam) : (-onePlusParam) );
}

int absoluteValueOfOnePlus(intparam)
{
    return (((int onePlusParam = 1 + param) > 0) ? (onePlusParam) : (-onePlusParam) );
}

---

我知道这不是有效的C#，但它证明了我试图执行的一个很好的例子——创建一些只存在于三元运算符范围内的变量。

三元表达式的部分是表达式。如果语言设计者允许您的要求，他们可能会对所有表达式而不仅仅是三元表达式这样做。然后，如果（（int n=foo（））！=0）bar（n），您还可以执行

在C#中，声明是语句，而不是表达式。所以答案是不，你不能这么做。但是，
for
语句可以进行声明，因此最接近单个语句的是：

for (int i = param.GetHashCode();;)
    return (i > 0) ? i : -i;

从技术上讲，这是一个单一的声明，尽管是一个复合的声明，并且有两行。但这看起来很糟糕，我不会那样写

如果您主要关心的是最小化
i
的范围，则使用较小的范围：

int positiveHash(string param)
{
    // Some statements here...
    // ...

    // Start a small scope
    {
        int i = param.GetHashCode();
        if (...)
            return ((i > 0) ? (i) : (-i) );
    }

    // Some more C# statements here.
    // i is out of scope here.
}

三元表达式的部分是表达式。如果语言设计者允许您的要求，他们可能会对所有表达式而不仅仅是三元表达式这样做。然后，如果（（int n=foo（））！=0）bar（n），您还可以执行

在C#中，声明是语句，而不是表达式。所以答案是不，你不能这么做。但是，
for
语句可以进行声明，因此最接近单个语句的是：

for (int i = param.GetHashCode();;)
    return (i > 0) ? i : -i;

从技术上讲，这是一个单一的声明，尽管是一个复合的声明，并且有两行。但这看起来很糟糕，我不会那样写

如果您主要关心的是最小化
i
的范围，则使用较小的范围：

int positiveHash(string param)
{
    // Some statements here...
    // ...

    // Start a small scope
    {
        int i = param.GetHashCode();
        if (...)
            return ((i > 0) ? (i) : (-i) );
    }

    // Some more C# statements here.
    // i is out of scope here.
}

我只想写：

int GetPositiveHash(string param)
{
    return Math.Abs(param.GetHashCode());
}

或

aids的可读性、可维护性，更重要的是在这种情况下避免

如果您真的担心性能，那么分析一下您的代码，看看最大的瓶颈在哪里。如果
GetPosiitiveHash（）
造成了最大的瓶颈，我会感到惊讶

您可能希望查看for
String.GetHashCode（）
。您将看到，与
GetHashCode（）
方法中发生的事情相比，三元运算符的节省非常少

值得记住的是：

引用的完整版本是“我们应该忘记小问题
效率，比如说97%的时间：过早优化是关键
我同意这一点。通常不值得
在代码明显出现之前，花大量时间对代码进行微优化
性能瓶颈是

从
我只想写：

int GetPositiveHash(string param)
{
    return Math.Abs(param.GetHashCode());
}

或

aids的可读性、可维护性，更重要的是在这种情况下避免

如果您真的担心性能，那么分析一下您的代码，看看最大的瓶颈在哪里。如果
GetPosiitiveHash（）
造成了最大的瓶颈，我会感到惊讶

您可能希望查看for
String.GetHashCode（）
。您将看到，与
GetHashCode（）
方法中发生的事情相比，三元运算符的节省非常少

值得记住的是：

引用的完整版本是“我们应该忘记小问题
效率，比如说97%的时间：过早优化是关键
我同意这一点。通常不值得
在代码明显出现之前，花大量时间对代码进行微优化
性能瓶颈是

从
中，可以将作用域中的数据变量（
i
）替换为作用域中的函数变量。优点是函数更可能只编写一次，而且不太可能被误用

int positiveHash(string param)
{
    Func<int, int> absoluteValue = i => (i > 0) ? i : -1;

    return absoluteValue(param.GetHashCode());
}

int positiveHash（字符串参数）
{
Func absoluteValue=i=>（i>0）？i:-1；
返回绝对值（param.GetHashCode（））；
}
您可以将作用域中的数据变量（
i
）替换为作用域中的函数变量。优点是函数更可能只编写一次，而且不太可能被误用

int positiveHash(string param)
{
    Func<int, int> absoluteValue = i => (i > 0) ? i : -1;

    return absoluteValue(param.GetHashCode());
}

int positiveHash（字符串参数）
{
Func absoluteValue=i=>（i>0）？i:-1；
返回绝对值（param.GetHashCode（））；
}
除了创建一个新块，您还可以使用内置的绝对值函数
Math.Abs（…）
或定义您自己的lambda/函数

…内置的

public static int hash(string param)
{
    return Math.Abs(param.GetHashCode());
}

。。。拉姆达

static Func<int, int> abs = i => i > 0 ? i : -i;
public static int hash(string param)
{
    return abs(param.GetHashCode());
}

除了创建一个新块之外，您还可以使用内置的绝对值函数
Math.Abs（…）
或定义您自己的lambda/函数

…内置的

public static int hash(string param)
{
    return Math.Abs(param.GetHashCode());
}

。。。拉姆达

static Func<int, int> abs = i => i > 0 ? i : -i;
public static int hash(string param)
{
    return abs(param.GetHashCode());
}

还有我的尝试

static int positiveHash(string param)
{
     return new List<string>() {param}.Select(s => s.GetHashCode()).Select(i => (i > 0) ? (i) : (-i)).Single();
}

static int positiveHash（字符串参数）
{
返回新列表（）{param}.Select（s=>s.GetHashCode（））.Select（i=>（i>0）？（i）：（-i））.Single（）；
}

（当然，您的代码（和我的代码）不好，您需要将您的方法拆分为两个较小的方法）

以及最新的问题

static int absoluteValueOfOnePlus(int intparam)
{
        return new List<int> { intparam }.Select(n => n + 1).Select(i => (i > 0) ? (i) : (-i)).Single();
}

静态int绝对值（int intparam）
{
返回新列表{intparam}。选择（n=>n+1）。选择（i=>i>0）？（i）：（-i））.Single（）；
}
和我的尝试

static int positiveHash(string param)
{
     return new List<string>() {param}.Select(s => s.GetHashCode()).Select(i => (i > 0) ? (i) : (-i)).Single();
}

static int positiveHash（字符串参数）
{
返回新列表（）{param}.Select（s=>s.GetHashCode（））.Select（i=>（i>0）？（i）：（-i））.Single（）；
}

（当然，你（和我）的代码都不好，你需要把你的方法分成两个较小的o