# V3080\. Possible null dereference\.

The analyzer detected a code fragment that may cause a null\-dereference issue\.

Consider the following examples, which trigger the V3080 diagnostic message:

```cpp
if (obj != null || obj.Func()) { ... }
if (obj == null && obj.Func()) { ... }
if (list == null && list[3].Func()) { ... }
```

All the conditions contain a logical mistake that results in null dereference\. This mistake appears as the result of bad code refactoring or a typo\.

The following are the fixed versions of the samples above:

```cpp
if (obj == null || obj.Func()) { .... }
if (obj != null && obj.Func()) { .... }
if (list != null && list[3].Func()) { .... }
```

These are very simple situations, of course\. In real\-life code, an object may be tested for null and used in different lines\. If you see the V3080 warning, examine the code above the line that triggered it and try to find out why the reference is null\.

Here's an example where an object is checked and used in different lines:

```cpp
if (player == null) {
  ....
  var identity = CreateNewIdentity(player.DisplayName);
  ....
}
```

The analyzer will warn you about the issue in the line inside the 'if' block\. There is either an incorrect condition or some other variable should have been used instead of 'player'\.

Sometimes programmers forget that when testing two objects for null, one of them may appear null and the other non\-null\. It will result in evaluating the entire condition, and null dereference\. For example:

```cpp
if ((text == null && newText == null) || text.Equals(newText)) {
  ....
}
```

This condition can be rewritten in the following way:

```cpp
if ((text == null && newText == null) ||
    (text != null && newText != null && text.Equals(newText))) {
  ....
}
```

Another way to make this mistake is to use the logical AND operator \(&\) instead of conditional AND \(&&\)\. One must remember that, firstly, both parts of the expression are always evaluated when using logical AND, and, secondly, the priority of logical AND is higher than that of conditional AND\.

For example:

```cpp
public static bool HasCookies {
  get {
    var context = HttpContext;
    return context != null
      && context.Request != null & context.Request.Cookies != null
      && context.Response != null && context.Response.Cookies != null;
  }
}
```

In this code, 'context\.Request\.Cookies' will be referenced even if 'context\.Request' is null\.

Dereferencing a parameter that has a default value of 'null' is also dangerous\. Here is an example:

```cpp
public NamedBucket(string name, List<object> items = null)
{
  _name = name;
 
  foreach (var item in items)
  {
    ....
  }
}
```

The constructor takes the 'items' collection as an optional parameter\. However, if the value for 'items' is not passed while calling the constructor, 'NullReferenceException' will be thrown when trying to traverse the collection in 'foreach'\. 

The issue may be resolved differently depending on the situation\. For example, we can traverse a collection only if it is not equal to 'null'\.