Increment. In C# programs int values are incremented in several ways. Some options include the pre-increment and post-increment operators. We can also decrement.
Evaluation order. There are subtle issues related to the order of evaluation. And performance can be affected by how we specify these operations.
Example. Here we increment int variables in different ways. The program shows both the ++ operator (with 2 pluses) and the += operator (with a plus and an equals).
Note The post-increment here begins with the value 0 and changes it to the value 1.
Also You use any constant or other expression resulting in a numeric value in the increment statement.
Detail Pre-increment has 2 pluses before the identifier. The store opcode is executed before the load operation.
Info With pre-increment, the variable value is changed and then you read it and evaluate it.
using System;
class Program
{
static void Main()
{
//
// Shows how increments work.
//int i = 0;
Console.WriteLine(i);
i++; // Add one
Console.WriteLine(i);
i += 2; // Add two
Console.WriteLine(i);
++i; // Add one
Console.WriteLine(i);
i += i; // Multiply by two
Console.WriteLine(i);
//
// Uses increments and assigns.
//int v = 0;
v = i++; // Increment after value copy
Console.WriteLine(v);
Console.WriteLine(i);
v = ++i; // Increment before value copy
Console.WriteLine(v);
Console.WriteLine(i);
}
}0 -
1 Added one
3 Added two
4 Added one
8 Added itself
8 Value copy
9 Increment
10 Value copy
10 Increment
Preincrement. A number is incremented with an operator. Two increment operators in the C# language are post-increment and pre-increment. They have different meanings.
++i;i++;
Preincrement, part 1. You should be familiar with the "++" and "minus minus" operators. This example uses the 2 pluses at the end of the variable identifier to increment the integer.
Note You can sometimes combine assignments with pre-increments. This can improve performance.
class Program
{
static int _x;
static void Main()
{
// Add one._x++;
// Read in the value again.
int count = _x;
}
}
Preincrement, part 2. We can pre-increment an integer. There are cases when accessing an integer is relatively slow. This can be the case with static variables and volatile member ints.
Here We use pre-increment to combine 2 statements into 1 statement. This is shorter code.
class Program
{
static int _x;
static void Main()
{
// Increment then assign.
int count = ++_x;
}
}
Preincrement, benchmark. We can optimize increments by loading the value in the same expression. If we use 2 statements, the static variable must be accessed twice.
Version 1 We increment, and then load the value of the static int. Memory is accessed twice.
Version 2 We increment and load the field in the same expression. Memory is only accessed once.
Result It is faster to combine the increment and read instructions. This is true with .NET 5 in 2021 (on Linux).
Important For local variables, which are faster than fields, this may not have the same performance benefit.
using System;
using System.Diagnostics;
class Program
{
static int _test;
const int _max = 100000000;
static void Main()
{
_test = 0;
var s1 = Stopwatch.StartNew();
// Version 1: increment then load.for (int i = 0; i < _max; i++)
{
_test++;
int z = _test;
if (z == 0)
{
return;
}
}
s1.Stop();
_test = 0;
// Version 2: increment and load in same expression.
var s2 = Stopwatch.StartNew();
for (int i = 0; i < _max; i++)
{
int z = ++_test;
if (z == 0)
{
return;
}
}
s2.Stop();
Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
}
}1.49 ns increment, then load
1.31 ns preincrement and load in single statement
Decrement. This reduces the value of a number. The decrement operator receives one or two operands. It is written with the characters "minus minus."
Here We start the value stored in the variable location with the integer 100. Then, the single decrement operator is applied.
And This decreases the value by one. Finally we use the "-=" operator and use several operands with it.
using System;
class Program
{
static void Main()
{
int i = 100;
// Decrement by one.i--;
Console.WriteLine(i);
// Decrement by two.i -= 2;
Console.WriteLine(i);
// Decrement by negative one (add one).i -= -1;
Console.WriteLine(i);
// Decrement by zero (do nothing).i -= 0;
Console.WriteLine(i);
// Decrement by itself (results in zero).i -= i;
Console.WriteLine(i);
}
}99
97
98
98
0
Pre, post decrement. There are 2 forms of the decrement by one operator: post-decrement and pre-decrement. These forms are unary operators—they can only receive one operand.
Detail When you use the post-decrement operator in an expression, the expression is evaluated before the decrement occurs.
And When you use the pre-decrement operator, it is evaluated after. This difference is important.
using System;
class Program
{
static void Main()
{
int i = 5;
// This evaluates to true.// ... The decrement occurs after the comparison.
if (i-- == 5)
{
Console.WriteLine(true);
}
// This evaluates to true.// ... The decrement occurs before the comparison.
if (--i == 3)
{
Console.WriteLine(true);
}
}
}True
True
For. For-loops often have an increment statement. The value of the integer is modified after each successful iteration through the loop (not before).
Notes, performance. When you use static fields, the JIT compiler may optimize the expressions less efficiently. With statics, combining an increment into an assignment may help.
A summary. Int variables (numeric value types) can be incremented using a variety of syntaxes in C#. Pre-increment and post-increment operations are evaluated in different orders.
Dot Net Perls is a collection of tested code examples. Pages are continually updated to stay current, with code correctness a top priority.
Sam Allen is passionate about computer languages. In the past, his work has been recommended by Apple and Microsoft and he has studied computers at a selective university in the United States.
