Ytdyklly

Here is the example:

if(value != ageValue) {

  ageValue = value;

}

I mean, if we assign the value of a variable to another one, why would we need to check if they have anyway the same value?

That confuses me. Here is the broader context:

private double ageValue;

public double Age {

  get {

    return ageValue;

  }



  set {

    if(value != ageValue) {

      ageValue = value;

    }

  }

}

Here is a code sample when the check is quite useful:

 public class MyClass {

    ...

    int ageValue = 0;



    public int AgeValue {

      get {

        return ageValue

      }

      protected set {

        ... // value validation here



        // your code starts

        if (value != ageValue) { 

          ageValue = value; 

        }

        // your code ends

        else

          return; // do nothing since value == ageValue



        // ageValue has been changed

        // Time (or / and memory) consuming process

        SaveToRDBMS();

        InvalidateCache(); 

        ...

      } 

    } 



 ... 

More natural implementation, however, is to check in the very beginning in order to avoid unnecessary computation.

    protected set {

      if (ageValue == value)

        return;



      ... // value validation here

      ageValue = value; 



      // ageValue has been changed

      // Time (or / and memory) consuming process

      SaveToRDBMS();

      InvalidateCache();  

      ...

    }

In a winforms control we had set the BackgroundColor to a specific color:

myControl.BackgroundColor = Color.White

Under specific circumstances this could happen in a tight loop and lead to a frozen UI. After some performance analysis we found that this call was the reason for the frozen UI and so we simply changed it to:

if (myControl.BackgroundColor != Color.White)

    myControl.BackgroundColor = Color.White

And the performance of our tool was back on track (and then we eliminated the reason of the tight loop).

So this check is not always redundant. Especially if the target is a property which does more within the setter then simply applying the value to a backing store.

The if is, on inspection, not redundant. It depends on the remaining implementation. Note that in C#, != can be overloaded, which means that evaluation can have side effects. Futhermore, the checked variables could be implemented as properties, which also can have side effects on evaluation.

This question has gained quite some comments but so far all answers try to reframe the question to address issues with operator overloading or side effects of the setter.

If the setter is using by multiple threads it can really make a difference. The check before set pattern can (you should measure) be useful if you are iterating over the same data with multiple threads which alter the data. The text book name for this phenomena is called false sharing. If you read the data and did verify that it already matches the target value you can omit the write.

If you omit the write the CPU does not need to flush the cache line (a 64 byte block on Intel CPUs) to ensure that other cores see the changed value. If the other core was about to read some other data from that 64 byte block then you just have slowed down your core and increased cross core traffic to synchronize memory contents between CPU caches.

The following sample application shows this effect which also contains the check before write condition:

 if (tmp1 != checkValue)  // set only if not equal to checkvalue

 {

    values[i] = checkValue;

 }

Here is the full code:

   class Program

    {

        static void Main(string args)

        {

            SetArray(1, 10);

            SetArray(2, 10);

        }



        private static void SetArray(int checkValue, int nTimes)

        {

            const int N = 500_000_000;

            int values = new int[N]; // 4 GB



            for (int k = 0; k < nTimes; k++)  // set array values to 1

            {

                for (int i = 0; i < values.Length; i++)

                {

                    values[i] = 1;

                }



                var sw = Stopwatch.StartNew();

                Action acc = () =>

                {

                    int tmp1 = 0;

                    for (int i = 0; i < values.Length; i++)

                    {

                        tmp1 = values[i];

                        if (tmp1 != checkValue)  // set only if not equal to checkvalue

                        {

                            values[i] = checkValue;

                        }

                    }

                };



                Parallel.Invoke(acc, acc, acc);  // Let this run on 3 cores



                sw.Stop();

                Console.WriteLine($"Set {N * 4 / (1_000_000_000.0f):F1} GB of Memory in {sw.Elapsed.TotalMilliseconds:F0} ms. Initial Value 1. Set Value {checkValue}");

            }

        }

    }

If you let that run you get values like:

// Value not set

Set 2.0 GB of Memory in 439 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 420 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 429 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 393 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 404 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 395 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 419 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 421 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 442 ms. Initial Value 1. Set Value 1

Set 2.0 GB of Memory in 422 ms. Initial Value 1. Set Value 1

// Value written

Set 2.0 GB of Memory in 519 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 582 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 543 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 484 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 523 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 540 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 552 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 527 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 535 ms. Initial Value 1. Set Value 2

Set 2.0 GB of Memory in 581 ms. Initial Value 1. Set Value 2

That results in a 22% faster performance which can be significant in high performance number crunching scenarios.

To answer the question as it was written:

You can remove the if statement if access to the memory is only single threaded. If multiple threads are working on the same or nearby data false sharing can happen which can cost you up to ca. 20% of memory access performance.