# 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:

```cpp
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](https://learn.microsoft.com/en-us/dotnet/csharp/linq/get-started/introduction-to-linq-queries)\.

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:

```cpp
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: 

```cpp
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\.