相关疑难解决方法(0)

我读的是无处不在三元运营商应该是比快,或至少一样的,它的等效if- else块.

但是,我做了以下测试,发现事实并非如此:

Random r = new Random();
int[] array = new int[20000000];
for(int i = 0; i < array.Length; i++)
{
    array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);

long value = 0;
DateTime begin = DateTime.UtcNow;

foreach (int i in array)
{
    if (i > 0)
    {
        value += 2;
    }
    else
    {
        value += 3;
    }
    // if-else block above takes on average 85 ms

    // OR I can use a ternary operator:
    // value += …

来自文档:

as运算符就像一个转换器,除了它在转换失败时产生null而不是引发异常.更正式地说,表达形式:

   expression as type

Run Code Online (Sandbox Code Playgroud)

相当于:

  expression is type ? (type)expression : (type) null

Run Code Online (Sandbox Code Playgroud)

除了表达式只评估一次.

那你为什么不选择这样或那样做呢？为什么有两个铸造系统？

MSDN上的这篇文章指出,您可以根据需要使用尽可能多的try catch块,并且不会产生任何性能成本,因为不会引发任何实际异常.
因为我总是认为即使没有抛出异常,try-catch总是会受到很小的性能影响,所以我做了一点测试.

 private void TryCatchPerformance()
        {
            int iterations = 100000000;

            Stopwatch stopwatch = Stopwatch.StartNew();
            int c = 0;
            for (int i = 0; i < iterations; i++)
            {
                try
                {
                   // c += i * (2 * (int)Math.Floor((double)i));
                    c += i * 2;
                }
                catch (Exception ex)
                {
                    throw;
                }
            }
            stopwatch.Stop();
            WriteLog(String.Format("With try catch: {0}", stopwatch.ElapsedMilliseconds));

            Stopwatch stopwatch2 = Stopwatch.StartNew();
            int c2 = 0;
            for (int i = 0; i < iterations; i++)
            {
              //  c2 …

我想知道一段锁定代码如何减慢我的代码,即使代码从未执行过.以下是一个示例:

public void Test_PerformanceUnit()
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    Random r = new Random();
    for (int i = 0; i < 10000; i++)
    {
        testRand(r);
    }
    sw.Stop();
    Console.WriteLine(sw.ElapsedTicks);
}

public object testRand(Random r)
{
    if (r.Next(1) > 10)
    {
        lock(this) {
            return null;
        }
    }
    return r;
}

这段代码在我的机器上运行〜1300ms.如果我们移除锁定块(但保持其身体),我们得到750毫秒.几乎是双倍,即使代码永远不会运行!

当然这段代码什么也没做.我注意到它在一个类中添加一些延迟初始化,其中代码检查对象是否已初始化,如果没有初始化它.问题是初始化被锁定并且即使在第一次调用之后也会减慢所有内容.

我的问题是:

1. 为什么会这样？
2. 如何避免减速

我使用以下代码来测试try块的速度有多慢.令我惊讶的是,try块使它更快.为什么？

public class Test {
    int value;

    public int getValue() {
        return value;
    }

    public void reset() {
        value = 0;
    }

    // Calculates without exception
    public void method1(int i) {
        value = ((value + i) / i) << 1;
        // Will never be true
        if ((i & 0xFFFFFFF) == 1000000000) {
            System.out.println("You'll never see this!");
        }
    }

    public static void main(String[] args) {
        int i;
        long l;
        Test t = new Test();

        l = System.currentTimeMillis();
        t.reset();
        for (i = …

我有2个int数组.

int[] data1 #
int[] data2 #

我想创建第3个int [] data3,这是其他2个数组之间的差异.

让我们取data1中的第一个值.

值为15(例如).

现在让我们在data2中取第一个值.

值为3(例如).

data3中的第一个值为12.

但是,如果第一个值是相反的,即

data1[0]  = 3
data2[0]  = 15

然后差异将是-12.但我希望它只有12岁.

目前我有一个for循环,我在那里做计算的东西来获得那种类型的结果.

1. 有没有办法在不通过循环枚举的情况下执行data1-data2 = data3？
2. 如果是这样,我可以在不使用减号的情况下获得差异吗？

谢谢

NB回应'关闭者'.我同意你的观点.我需要在这个问题上添加的是:

我正在寻找最有效(最快的方式,但低内存是第二优先)来促进这一点.使用Linq(据我所知)可能是最慢的方法？

我有以下内容:

string outOfRange = "2147483648"; // +1 over int.MaxValue

显然,如果你有一个数字以外的东西,这将失败:

var defaultValue = 0;
int.TryParse(outOfRange, out defaultValue);

我的问题是,因为这是一个数字,并且它会失败,你int.TryParse()怎么知道它失败了,因为字符串超出了它存储在容器的范围内？

在性能方面使用try {} catch {}块的最佳做法是什么？

foreach (var one in all)
{
    try
    {
        //do something
    }
    catch { }
}

要么

try
{
    foreach (var one in all)
    {
        // do something
    }
}
catch { }

目前我使用List<int> ints = tuple.Item2.Select(s => s.Value).ToList()但是当tuple.Item2有1000个项目时,这看起来效率低下.有没有更好的方法实现这一目标 除了使用for循环.