# V4003. Unity Engine. Avoid capturing variable in performance-sensitive context. This can lead to decreased performance.

The analyzer has detected a variable capture in a lambda expression inside a frequently executed method. The variable capture can lead to decreased performance due to additional memory allocation.

Let's look at the example:

    void Update()
    {
      ....
      List<int> numbers = GetNumbers();
      int divisor = GetDivisor();
      var result = numbers.Select(x => x / divisor);
      ....
    }

'Update' is a Unity method that performs a frame-by-frame update. The 'Update' method is often called, so it is not recommended to overload it with unnecessary operations.

The given example uses a lambda expression with capturing the 'divisor' variable. As mentioned earlier, capturing a variable from an external context leads to an additional creation of an object.

Thus, the demonstrated code fragment creates an additional load on the GC.

The optimal method implementation may look like this:

    void Update()
    {
      ....
      List<int> numbers = GetNumbers();
      int divisor = GetDivisor();

      var result = new List<int>(numbers.Count);
      for (int i = 0; i < numbers.Count; i++)
      {
        result.Add(numbers[i]/divisor);
      }
      ....
    }

Using a custom implementation similar to 'Select', you can get rid of additional memory allocation and thus reduce the load on the GC.

Take a look at another example:

    void Update()
    {
      ....
      List<int> numbers = GetNumbers();
      int divisor = GetDivisor();

      if (AreAllMultipleOf(numbers, divisor))
        ....
    }

    bool AreAllMultipleOf(List<int> lst, int divisor)
    {
      return lst.All(elem => elem % divisor == 0);
    }

The 'AreAllMultipleOf' method is called from the 'Update' method. 'AreAllMultipleOf' determines whether all the received numbers are multiples of the 'divisor' value. Just as before: 'Update' is a frequently called method that performs frame-by-frame update in Unity.

In this case, the 'AreAllMultipleOf' method is regularly executed within 'Update', which means it is also often called.

The 'AreAllMultipleOf' method uses a lambda expression with variable capture to perform the check. This leads to additional memory allocation, which can negatively affect the performance of the application.

The optimal method implementation may look like this:

    void Update()
    {
      ....
      List<int> numbers = GetNumbers();
      int divisor = GetDivisor();

      if (AreAllMultipleOf(numbers, divisor))
        ....
    }

    bool AreAllMultipleOf(List<int> lst, int divisor)
    {
      foreach (int num in lst)
      {
        if (num % divisor != 0)
          return false;
      }
      return true;
    }

Here we once again use our custom implementation, which helps avoid additional memory allocation and reduce the load on the garbage collector.