Am citit peste tot că operatorul ternar ar trebui să fie mai rapid decât, sau, cel puțin, la fel ca echivalentul său "dacă" - "altceva" bloc.
Cu toate acestea, am făcut următorul test si am aflat l'nu e cazul:
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 += i > 0 ? 2 : 3; // takes 157 ms
}
DateTime end = DateTime.UtcNow;
MessageBox.Show("Measured time: " + (end-begin).TotalMilliseconds + " ms.\r\nResult = " + value.ToString());
Calculatorul meu a luat 85 de ms pentru a rula codul de mai sus. Dar dacă aș comentariu "dacă" - "altceva" bucată, și decomentați operatorul ternar linie, va dura aproximativ 157 ms.
De ce se întâmplă acest lucru?
Pentru a răspunde la această întrebare, am'll examineze ansamblul cod produs prin X86 și X64 Jit pentru fiecare dintre aceste cazuri.
32: foreach (int i in array)
0000007c 33 D2 xor edx,edx
0000007e 83 7E 04 00 cmp dword ptr [esi+4],0
00000082 7E 1C jle 000000A0
00000084 8B 44 96 08 mov eax,dword ptr [esi+edx*4+8]
33: {
34: if (i > 0)
00000088 85 C0 test eax,eax
0000008a 7E 08 jle 00000094
35: {
36: value += 2;
0000008c 83 C3 02 add ebx,2
0000008f 83 D7 00 adc edi,0
00000092 EB 06 jmp 0000009A
37: }
38: else
39: {
40: value += 3;
00000094 83 C3 03 add ebx,3
00000097 83 D7 00 adc edi,0
0000009a 42 inc edx
32: foreach (int i in array)
0000009b 39 56 04 cmp dword ptr [esi+4],edx
0000009e 7F E4 jg 00000084
30: for (int x = 0; x < iterations; x++)
000000a0 41 inc ecx
000000a1 3B 4D F0 cmp ecx,dword ptr [ebp-10h]
000000a4 7C D6 jl 0000007C
59: foreach (int i in array)
00000075 33 F6 xor esi,esi
00000077 83 7F 04 00 cmp dword ptr [edi+4],0
0000007b 7E 2D jle 000000AA
0000007d 8B 44 B7 08 mov eax,dword ptr [edi+esi*4+8]
60: {
61: value += i > 0 ? 2 : 3;
00000081 85 C0 test eax,eax
00000083 7F 07 jg 0000008C
00000085 BA 03 00 00 00 mov edx,3
0000008a EB 05 jmp 00000091
0000008c BA 02 00 00 00 mov edx,2
00000091 8B C3 mov eax,ebx
00000093 8B 4D EC mov ecx,dword ptr [ebp-14h]
00000096 8B DA mov ebx,edx
00000098 C1 FB 1F sar ebx,1Fh
0000009b 03 C2 add eax,edx
0000009d 13 CB adc ecx,ebx
0000009f 89 4D EC mov dword ptr [ebp-14h],ecx
000000a2 8B D8 mov ebx,eax
000000a4 46 inc esi
59: foreach (int i in array)
000000a5 39 77 04 cmp dword ptr [edi+4],esi
000000a8 7F D3 jg 0000007D
57: for (int x = 0; x < iterations; x++)
000000aa FF 45 E4 inc dword ptr [ebp-1Ch]
000000ad 8B 45 E4 mov eax,dword ptr [ebp-1Ch]
000000b0 3B 45 F0 cmp eax,dword ptr [ebp-10h]
000000b3 7C C0 jl 00000075
32: foreach (int i in array)
00000059 4C 8B 4F 08 mov r9,qword ptr [rdi+8]
0000005d 0F 1F 00 nop dword ptr [rax]
00000060 45 85 C9 test r9d,r9d
00000063 7E 2B jle 0000000000000090
00000065 33 D2 xor edx,edx
00000067 45 33 C0 xor r8d,r8d
0000006a 4C 8B 57 08 mov r10,qword ptr [rdi+8]
0000006e 66 90 xchg ax,ax
00000070 42 8B 44 07 10 mov eax,dword ptr [rdi+r8+10h]
33: {
34: if (i > 0)
00000075 85 C0 test eax,eax
00000077 7E 07 jle 0000000000000080
35: {
36: value += 2;
00000079 48 83 C5 02 add rbp,2
0000007d EB 05 jmp 0000000000000084
0000007f 90 nop
37: }
38: else
39: {
40: value += 3;
00000080 48 83 C5 03 add rbp,3
00000084 FF C2 inc edx
00000086 49 83 C0 04 add r8,4
32: foreach (int i in array)
0000008a 41 3B D2 cmp edx,r10d
0000008d 7C E1 jl 0000000000000070
0000008f 90 nop
30: for (int x = 0; x < iterations; x++)
00000090 FF C1 inc ecx
00000092 41 3B CC cmp ecx,r12d
00000095 7C C9 jl 0000000000000060
59: foreach (int i in array)
00000044 4C 8B 4F 08 mov r9,qword ptr [rdi+8]
00000048 45 85 C9 test r9d,r9d
0000004b 7E 2F jle 000000000000007C
0000004d 45 33 C0 xor r8d,r8d
00000050 33 D2 xor edx,edx
00000052 4C 8B 57 08 mov r10,qword ptr [rdi+8]
00000056 8B 44 17 10 mov eax,dword ptr [rdi+rdx+10h]
60: {
61: value += i > 0 ? 2 : 3;
0000005a 85 C0 test eax,eax
0000005c 7F 07 jg 0000000000000065
0000005e B8 03 00 00 00 mov eax,3
00000063 EB 05 jmp 000000000000006A
00000065 B8 02 00 00 00 mov eax,2
0000006a 48 63 C0 movsxd rax,eax
0000006d 4C 03 E0 add r12,rax
00000070 41 FF C0 inc r8d
00000073 48 83 C2 04 add rdx,4
59: foreach (int i in array)
00000077 45 3B C2 cmp r8d,r10d
0000007a 7C DA jl 0000000000000056
57: for (int x = 0; x < iterations; x++)
0000007c FF C1 inc ecx
0000007e 3B CD cmp ecx,ebp
00000080 7C C6 jl 0000000000000048
În primul rând: de ce este cod X86 mult mai lent decât X64?
Acest lucru se datorează următoarele caracteristici de cod:
adc
), dar numai 1 pe X64 ("add").În al doilea rând: de ce este operatorul ternar mai lent pe atât X86 și X64?
Acest lucru se datorează o diferență subtilă în ordinea operațiunilor cu impact JIT's de optimizare. Pentru a JIT operatorul ternar, mai degrabă decât direct de codificare cu " 2 " și " 3 " în " add " instrucțiuni mașină înșiși, JIT crearea unei variabile intermediare (într-un registru) să dețină rezultat. Acest registru este apoi semn-extins la 32 de biți la 64 de biți înainte de a adăuga la "valoare". Din moment ce toate de acest lucru este efectuat în registre pentru X64, în ciuda creșterii semnificative în complexitate pentru operatorul ternar impactul net este oarecum redusă la minimum.
X86 JIT pe de altă parte, este influențată într-o mai mare măsură pentru adăugarea unui nou intermediar valoare în bucla interioară provoacă-l pentru a "deversare" o altă valoare, rezultând în cel puțin 2 suplimentare accese de memorie în bucla interioară (a se vedea punctele de acces către [ebp-14h]
în X86 cod ternar).
EDIT: schimba... vezi mai jos.
Pot't reproduce rezultatele pe x64 CLR, dar nu poate pe x86. Pe x64 nu pot vedea un mic diferența (mai puțin de 10%) între operatorul condiționată și dacă/altceva, dar's mult mai mici decât tine're a vedea.
Am'am făcut următoarele modificări potențiale:
/o+ /debug-
, și a alerga afară debuggerRezultatele cu /platforma:x64
(fără "ignor" linii):
if/else with 1 iterations: 17ms
conditional with 1 iterations: 19ms
if/else with 1000 iterations: 17875ms
conditional with 1000 iterations: 19089ms
Rezultatele cu /platforma:x86
(fără "ignor" linii):
if/else with 1 iterations: 18ms
conditional with 1 iterations: 49ms
if/else with 1000 iterations: 17901ms
conditional with 1000 iterations: 47710ms
Sistemul meu detalii:
Deci, spre deosebire de înainte, cred că de tine sunt vezi o diferență reală - și l's toți de-a face cu x86 JIT. Am ar't ca să-ți spun exact ce este cauza diferență - am poate actualiza post mai tarziu cu mai multe detalii daca pot deranjez pentru a merge în cordbg :)
Interesant, fără sortare matrice în primul rând, am termina cu testele care dura aproximativ 4,5 x cât mai mult, cel puțin pe x64. Parerea mea este ca acest lucru este de a face cu ramura de predicție.
Cod:
using System;
using System.Diagnostics;
class Test
{
static void Main()
{
Random r = new Random(0);
int[] array = new int[20000000];
for(int i = 0; i < array.Length; i++)
{
array[i] = r.Next(int.MinValue, int.MaxValue);
}
Array.Sort(array);
// JIT everything...
RunIfElse(array, 1);
RunConditional(array, 1);
// Now really time it
RunIfElse(array, 1000);
RunConditional(array, 1000);
}
static void RunIfElse(int[] array, int iterations)
{
long value = 0;
Stopwatch sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
{
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
}
}
sw.Stop();
Console.WriteLine("if/else with {0} iterations: {1}ms",
iterations,
sw.ElapsedMilliseconds);
// Just to avoid optimizing everything away
Console.WriteLine("Value (ignore): {0}", value);
}
static void RunConditional(int[] array, int iterations)
{
long value = 0;
Stopwatch sw = Stopwatch.StartNew();
for (int x = 0; x < iterations; x++)
{
foreach (int i in array)
{
value += i > 0 ? 2 : 3;
}
}
sw.Stop();
Console.WriteLine("conditional with {0} iterations: {1}ms",
iterations,
sw.ElapsedMilliseconds);
// Just to avoid optimizing everything away
Console.WriteLine("Value (ignore): {0}", value);
}
}
Diferența chiar nu't au mult de a face cu dacă/altceva vs ternare.
Se uită la jitted disassemblies (am castigat't repaste aici, pls vedea @280Z28's de răspuns), se pare că're compara mere și portocale. Într-un singur caz, puteți crea două tipuri diferite de +=
operațiunile cu valori constante și care o alegi depinde de o condiție, iar în celălalt caz, puteți crea un +=
unde value să add depinde de o condiție.
Dacă doriți cu adevărat să compare dacă/altceva vs ternare, ar fi mai corect comparație (acum ambele vor fi la fel de "lent", sau am putea spune chiar ternar este un pic mai repede):
int diff;
if (i > 0)
diff = 2;
else
diff = 3;
value += diff;
vs
value += i > 0 ? 2 : 3;
Acum demontare pentru `dacă/altceva devine așa cum se arată mai jos. Rețineți că acest lucru este mai rău decât ternare caz, deoarece se renunțe la utilizarea de registre pentru variabila buclă ("eu"), precum și.
if (i > 0)
0000009d cmp dword ptr [ebp-20h],0
000000a1 jle 000000AD
{
diff = 2;
000000a3 mov dword ptr [ebp-24h],2
000000aa nop
000000ab jmp 000000B4
}
else
{
diff = 3;
000000ad mov dword ptr [ebp-24h],3
}
value += diff;
000000b4 mov eax,dword ptr [ebp-18h]
000000b7 mov edx,dword ptr [ebp-14h]
000000ba mov ecx,dword ptr [ebp-24h]
000000bd mov ebx,ecx
000000bf sar ebx,1Fh
000000c2 add eax,ecx
000000c4 adc edx,ebx
000000c6 mov dword ptr [ebp-18h],eax
000000c9 mov dword ptr [ebp-14h],edx
000000cc inc dword ptr [ebp-28h]
Edit:
Adăugat un exemplu care poate fi făcut cu if-else declarație, dar nu condiționată de operator.
Înainte de a răspunde, vă rugăm să aveți o privire de [Care este mai rapid?] pe Domnul Lippert's blog. Și cred că Domnul Ersönmez's answer este cel mai corect aici.
Am'm încercând să menționez ceva ce ar trebui să păstreze în minte, cu un nivel înalt limbaj de programare.
În primul rând, am'am mai auzit că operatorul condiționată ar trebui să fie mai repede sau la fel de performanta cu if-else declarație în C♯.
Motivul este simplu că, dacă nu's nici o operațiune cu if-else declarație:
if (i > 0)
{
value += 2;
}
else
{
}
Cerința de condițional operatorul este trebuie să existe o valoare cu fiecare parte, și în C♯ necesită, de asemenea, că atât partea de :
are același tip. Acest lucru face să fie diferit de if-else declarație. Astfel, întrebarea ta devine întrebarea cum de instrucțiuni al aparatului de cod este generat astfel încât diferența de performanță.
Cu operatorul condiționată, semantic este:
Orice expresie este evaluată, nu's o valoare.
Dar dacă-altceva declarație:
Dacă expresia este evaluată la adevărat, face ceva; dacă nu, face un alt lucru.
O valoare nu este în mod necesar implicat cu if-else declarație. Presupunerea ta este posibilă numai cu optimizarea.
Un alt exemplu pentru a demonstra diferența dintre ele ar fi următoarele:
var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
if(i>0)
array1[1]=4;
else
array2[2]=4;
codul de mai sus compilează, cu toate acestea, înlocuiți-l dacă-altceva declarație cu operatorul condiționată doar de câștigat't compila:
var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
(i>0?array1[1]:array2[2])=4; // incorrect usage
Condiționată operator și if-else sunt conceptual același lucru atunci când faci același lucru, poate chiar mai repede cu operatorul condiționată in C, deoarece C este mai aproape de asamblare a platformei.
Pentru codul original-ați furnizat, condiționată de operator este folosit într-un foreach buclă, care ar încurca lucrurile pentru a vedea diferența dintre ele. Așa că m-am'm a propune următorul cod:
public static class TestClass {
public static void TestConditionalOperator(int i) {
long value=0;
value+=i>0?2:3;
}
public static void TestIfElse(int i) {
long value=0;
if(i>0) {
value+=2;
}
else {
value+=3;
}
}
public static void TestMethod() {
TestConditionalOperator(0);
TestIfElse(0);
}
}
și următoarele două versiune a IL de optimizat și nu. Deoarece acestea sunt de mult timp, am'm, folosind o imagine pentru a arăta, partea dreaptă este optimizat unul:
În ambele versiune de cod, IL de operatorul condiționată pare mai scurt decât dacă-altceva declarație, și nu mai este nici o îndoială de cod mașină în cele din urmă a generat. Următoarele sunt instrucțiunile de ambele metode, și fosta imagine este non-optimizat, acesta din urmă este optimizat unul:
Non-optimizat de instrucțiuni: (Click pentru a vedea imaginea la dimensiunea completă.)
Optimizat de instrucțiuni: (Click pentru a vedea imaginea la dimensiunea completă.)
În cele din urmă, blocul galben este cod executat daca i<=0
, și blocul albastru este atunci când i>0
. În oricare versiune de instrucțiuni, dacă-altceva declarație este mai scurtă.
Rețineți că, pentru diferite instrucțiuni, [IPC] nu este neapărat același lucru. În mod logic, pentru aceeași instrucțiune, mai multe instrucțiuni cost ciclu mai lung. Dar dacă instrucțiunea preluarea timp și țeavă/cache au fost, de asemenea, să ia în considerare, atunci numărul real timpul de executie depinde de procesor. Procesorul poate prezice, de asemenea, ramuri.
Procesoarele moderne au chiar mai multe nuclee, lucrurile pot fi mult mai complexe și cu asta. Dacă ești un procesor Intel utilizator, ați putea dori să aibă o privire de [Intel® 64 și IA-32 Arhitecturi de Optimizare Manual de Referință].
Eu nu't știu dacă a existat un hardware implementat CLR, dar daca da, probabil ai ajunge mai repede cu operatorul condiționată, deoarece IL este evident mai mică.
Notă: Toate cod-mașină sunt de x86.
Am făcut ceea ce Jon Skeet făcut-o și a fugit printr-1 repetare și 1000 de iterații și a primit un rezultat diferit de ambele OP și Jon. În al meu, ternar este doar cu puțin mai repede. Mai jos este codul exact:
static void runIfElse(int[] array, int iterations)
{
long value = 0;
Stopwatch ifElse = new Stopwatch();
ifElse.Start();
for (int c = 0; c < iterations; c++)
{
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
}
}
ifElse.Stop();
Console.WriteLine(String.Format("Elapsed time for If-Else: {0}", ifElse.Elapsed));
}
static void runTernary(int[] array, int iterations)
{
long value = 0;
Stopwatch ternary = new Stopwatch();
ternary.Start();
for (int c = 0; c < iterations; c++)
{
foreach (int i in array)
{
value += i > 0 ? 2 : 3;
}
}
ternary.Stop();
Console.WriteLine(String.Format("Elapsed time for Ternary: {0}", ternary.Elapsed));
}
static void Main(string[] args)
{
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;
runIfElse(array, 1);
runTernary(array, 1);
runIfElse(array, 1000);
runTernary(array, 1000);
Console.ReadLine();
}
Ieșirea din programul meu:
timpul Scurs de if-Else: 00:00:00.0140543
timpul Scurs pentru Ternare: 00:00:00.0136723
timpul Scurs de if-Else: 00:00:14.0167870
timpul Scurs pentru Ternare: 00:00:13.9418520
Un alt termen în milisecunde:
timpul Scurs de if-Else: 20
timpul Scurs pentru Ternare: 19
timpul Scurs de if-Else: 13854
timpul Scurs pentru Ternare: 13610
Aceasta se execută în 64-bit XP, si am fugit fara depanare.
Edit - x86 care Rulează în:
Nu's o mare diferență folosind x86. Acest lucru a fost făcut fără de depanare de pe și de pe același xp 64-bit mașină ca și mai înainte, dar construit pentru Procesoare x86. Asta arata mai mult ca OP's.
timpul Scurs de if-Else: 18
timpul Scurs pentru Ternare: 35
timpul Scurs de if-Else: 20512
timpul Scurs pentru Ternare: 32673
Asamblor codul generat va spun povestea:
a = (b > c) ? 1 : 0;
Generează:
mov edx, DWORD PTR a[rip]
mov eax, DWORD PTR b[rip]
cmp edx, eax
setg al
Întrucât:
if (a > b) printf("a");
else printf("b");
Generează:
mov edx, DWORD PTR a[rip]
mov eax, DWORD PTR b[rip]
cmp edx, eax
jle .L4
;printf a
jmp .L5
.L4:
;printf b
.L5:
Deci ternar can fi mai scurt și mai rapid, pur și simplu, din cauza folosind mai puține instrucțiuni și nu sare if sunteți în căutarea pentru adevărat/fals. Dacă utilizați alte valori decât 1 și 0, veți obține același cod ca dacă/altceva, de exemplu:
a = (b > c) ? 2 : 3;
Generează:
mov edx, DWORD PTR b[rip]
mov eax, DWORD PTR c[rip]
cmp edx, eax
jle .L6
mov eax, 2
jmp .L7
.L6:
mov eax, 3
.L7:
Care este la fel ca dacă/altceva.
Se uită la IL generate, sunt 16 operațiunile de mai puțin, decât dacă/altceva declarație (copierea și lipirea @JonSkeet's cod). Cu toate acestea, asta nu't înseamnă că ar trebui să fie un rapid proces!
Pentru a rezuma diferențele în IL, dacă/altceva metodă se traduce destul de mult la fel ca C# cod prevede (efectuarea plus în ramură) întrucât condiționată codul de sarcini, fie 2 sau 3 pe stiva (în funcție de valoare) și apoi adaugă-l la valoarea in afara condiționată.
Pe de altă diferență este de ramificare de instruire utilizate. Dacă/altceva metodă folosește un brtrue (filiala dacă este adevărat) pentru a sari peste prima condiție, și necondiționat de ramură pentru a sari de la prima afară de cazul în declarație. Condiționată de cod foloseste un bgt (filiala dacă este mai mare decât) în loc de un brtrue, care ar putea fi, eventual, un ritm mai lent de comparație.
De asemenea (după ce a citit despre branch prediction) poate exista o penalizare de performanță pentru ramura fiind mai mici. Ramura condiționată are doar 1 instruire în cadrul ramurii dar dacă/altceva are 7. Acest lucru ar explica de ce nu's o diferență între utilizarea de lungă și int, pentru că schimbarea la un int reduce numărul de instrucțiuni în dacă/altceva ramuri de 1 (de a face read-ahead mai puțin)
Rula fără depanare ctrl+F5 se pare debugger încetinește atât ifs și ternare în mod semnificativ, dar se pare că încetinește operatorul ternar mult mai mult.
Atunci când am rula codul de mai jos aici sunt rezultatele mele. Cred că mici milisecundă diferența este cauzată de compilator optimizarea max=max și eliminarea, dar este, probabil, nu face asta de optimizare pentru operatorul ternar. Dacă cineva ar putea verifica de asamblare și confirma acest lucru ar fi minunat.
--Run #1--
Type | Milliseconds
Ternary 706
If 704
%: .9972
--Run #2--
Type | Milliseconds
Ternary 707
If 704
%: .9958
--Run #3--
Type | Milliseconds
Ternary 706
If 704
%: .9972
Cod
for (int t = 1; t != 10; t++)
{
var s = new System.Diagnostics.Stopwatch();
var r = new Random(123456789); //r
int[] randomSet = new int[1000]; //a
for (int i = 0; i < 1000; i++) //n
randomSet[i] = r.Next(); //dom
long _ternary = 0; //store
long _if = 0; //time
int max = 0; //result
s.Start();
for (int q = 0; q < 1000000; q++)
{
for (int i = 0; i < 1000; i++)
max = max > randomSet[i] ? max : randomSet[i];
}
s.Stop();
_ternary = s.ElapsedMilliseconds;
max = 0;
s = new System.Diagnostics.Stopwatch();
s.Start();
for (int q = 0; q < 1000000; q++)
{
for (int i = 0; i < 1000; i++)
if (max > randomSet[i])
max = max; // I think the compiler may remove this but not for the ternary causing the speed difference.
else
max = randomSet[i];
}
s.Stop();
_if = s.ElapsedMilliseconds;
Console.WriteLine("--Run #" + t+"--");
Console.WriteLine("Type | Milliseconds\nTernary {0}\nIf {1}\n%: {2}", _ternary, _if,((decimal)_if/(decimal)_ternary).ToString("#.####"));
}
În codul de mai jos dacă/altceva pare a fi de aproximativ 1,4 ori mai repede decât operatorul ternar. Cu toate acestea, am constatat că, introducând o variabilă temporară scade operatorul ternar's a rula timp de aproximativ 1,4 ori:
Dacă/Altceva: 98 ms
Ternare: 141 ms
Ternare cu var temp: 100 ms
using System;
using System.Diagnostics;
namespace ConsoleApplicationTestIfElseVsTernaryOperator
{
class Program
{
static void Main(string[] args)
{
Random r = new Random(0);
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;
Stopwatch stopwatch = new Stopwatch();
value = 0;
stopwatch.Restart();
foreach (int i in array)
{
if (i > 0)
{
value += 2;
}
else
{
value += 3;
}
// 98 ms
}
stopwatch.Stop();
Console.WriteLine("If/Else: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");
value = 0;
stopwatch.Restart();
foreach (int i in array)
{
value += (i > 0) ? 2 : 3;
// 141 ms
}
stopwatch.Stop();
Console.WriteLine("Ternary: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");
value = 0;
int tempVar = 0;
stopwatch.Restart();
foreach (int i in array)
{
tempVar = (i > 0) ? 2 : 3;
value += tempVar;
// 100ms
}
stopwatch.Stop();
Console.WriteLine("Ternary with temp var: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");
Console.ReadKey(true);
}
}
}