# V3219. The variable was changed after it was captured in a LINQ method with deferred execution. The original value will not be used when the method is executed.

The analyzer has detected that a captured variable used in the LINQ method with deferred execution has been changed. In this case, the original variable value is not considered.

Take a look at an example:

    private static List<string> _names = new() { "Tucker", "Bob", "David" };

    public static void ProcessNames()
    {
      string startLetter = "T";
      var names = _names.Where(c => !c.StartsWith(startLetter));

      startLetter = "B";
      names = names.Where(c => !c.StartsWith(startLetter))
                   .ToList();
    }

In the `ProcessNames` method, names are filtered by the first letter. The expected result is that the `names` variable will contain names that do not start with `T` and `B`. However, the program behaves differently. After executing this method, `names` will have a collection with `Tucker` and `David`.

This behavior occurs because when `Where` is called, the filtering is not executed immediately, but is deferred. Since `B` is assigned to the `startLetter` variable between the two calls to `Where`, the `T` value is not considered in the final evaluation.

This happens because `startLetter` is captured during the first call to `Where`, and its value has changed before the second call to `Where`. As a result, the final collection will be filtered only by `B`.

You can learn more about deferred execution here.

To ensure the method operates correctly, either immediately execute the first `Where` query and work with its result or use a different variable in the lambda expression of the second `Where`.

Let's look at the first scenario:

    private static List<string> _names = new() { "Tucker", "Bob", "David" };

    public static void ProcessNames()
    {
      string startLetter = "T";
      var names = _names.Where(c => !c.StartsWith(startLetter))
                        .ToList();

      startLetter = "B";
      names = names.Where(c => !c.StartsWith(startLetter))
                   .ToList();
    }

After the first `Where` method, `ToList` is called, creating a collection filtered by the first `Where`. By the time the captured variable changes, the collection has already been formed, so the filtering behaves correctly.

The second fix option:

    private static List<string> _names = new() { "Tucker", "Bob", "David" };

    public static void ProcessNames()
    {
      string startLetter1 = "T";
      var names = _names.Where(c => !c.StartsWith(startLetter1));

      string startLetter2 = "B";
      names = names.Where(c => !c.StartsWith(startLetter2))
                   .ToList();
    }

In this case, a new value between `Where` calls is not assigned to the captured variable, the `startLetter2` variable is used instead. As a result, the filtering will operate correctly.

You can look at examples of errors detected by the V3219 diagnostic.