I think this is a Resharper bug and I'd submit it there. There can't be a modified closure in a linq statement that's executing immediately, like `Any` does.

VB is not my 'native language', but afaik the parentheses shouldn't make any difference in VB.Net (as it did in VB6).

Resharper's [`Access to Modified Closure`](http://confluence.jetbrains.com/display/ReSharper/Access+to+modified+closure) warnings are usually quite helpful. I was just noticing that when I call the [`Any`](http://msdn.microsoft.com/en-us/library/system.linq.enumerable.any.aspx) method inside of a for each loop, I'll get a warning if I don't use the open and close parenthesis. As soon as I add `()`, the error goes away.

Does the error itself go away, or have I just accidentally tricked Resharper's static code analysis detection.



    Dim groupExists as Boolean
    
    For each oldPerson in oldData

        'access to modified closure warning on oldPerson.groupId
        groupExists = (From newPerson In newData 
                       Where newPerson.GroupId = oldPerson.groupId).Any

        'no closure problem reported
        groupExists = (From newPerson In newData 
                       Where newPerson.GroupId = oldPerson.groupId).Any()

    Next

Of course, I can fix this by putting the following code inside the `For Each` loop and comparing the `newPerson.GroupId` to the locally declared variable.  




    'declare locally to avoid access to modified closure
    Dim groupId as Integer = person.groupId

Why does Access to Modified Closure Warning Disappear When Enumerable Method called with ()

Just found it while looking into posting this question...

 It is a member of Edit > Intellisense called QuickInfo and you can access it with <kbd>Ctrl</kbd> + <kbd>I</kbd>

**Here's the Menu Function**

![Quick Info][1]

**Here's a working example**

![Working Properly][2]


  [1]: http://i.stack.imgur.com/56VpW.png
  [2]: http://i.stack.imgur.com/BIn5P.png

In Visual Studio, normally when I hover over a variable it will display the type while editting code and the value while debugging. 

**How it should look when you hover over tablename:**

![How it should look][1]

Resharper messes some of that up by overriding the tooltip whenever it has a formatting suggestion or error it thinks you ought to pay attention to.

**How it looks when the error is blocking the tooltip**

![Tool tip blocked][2]

Couple questions I can't seem to find the answer to:

*  What's the name of the pop-up that shows variable information (is tooltip correct?)
*  Is there a way to manually invoke it? (normally <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>Space</kbd> works)


  [1]: http://i.stack.imgur.com/zlzfc.png
  [2]: http://i.stack.imgur.com/oM4t0.png

Manually show VS tooltip when Resharper error prevents intellisense on hover

There is no way to enforce naming rules for backing fields in ReSharper, but you can add multiple rules for entity kind. 

![enter image description here][1]

With this settings applied, ReSharper will allow you to have fields with and without underscore prefix.


  [1]: http://i.stack.imgur.com/8laNi.png

The coding standard in my organization is for private fields to be lowerCamelCase but backing fields used by properties to be prefixed with an underscore (`_`).  Is there a way to add a rule just for backing fields in the [Resharper Naming Style](http://www.jetbrains.com/resharper/webhelp/Reference__Options__Languages__Visual_Basic__NET__VB_Naming_Style.html) tool.

Here's the Naming Rule Editor:
![resharper](http://i.imgur.com/8nLaTeq.png)

I'd rather this error not show up for local variables
![rename](http://i.imgur.com/2WvdPyx.png)

Examples in VB and C#:

**VB:**



	Public Class Employee

		'Should be lowerCamelCase
		Private useCode As String = "NEW"
		
		'should be _lowerCamelCase
		Private _name As String
		
		Public Property Name() As String
			Get
				Return _name
			End Get
			Set(ByVal value As String)
				_name = value
			End Set
		End Property
		
	End Class

**C#:**



	public class Employee
	{

		//Should be lowerCamelCase
		private string useCode = "NEW";

		//should be _lowerCamelCase
		private string _name;

		public string Name {
			get { return _name; }
			set { _name = value; }
		}

	}

Whether you [agree or not](https://stackoverflow.com/questions/852433/naming-preference-for-class-fields-in-c) with this naming convention, is there a way to ask reshaper to enforce this?

Custom Naming Style Options in Resharper For Backing Fields

Often when starting a method, I haven't yet used a variable so Resharper quickly gives the warning:

> Local variable 'xxx' is never used

However, this frustratingly blocks the information on type declaration I might need from Visual Studio.

Even when I manually invoke the *Quick Info* tooltip with <kbd>Ctrl</kbd> + <kbd>I</kbd>  
![Quick Info](http://i.imgur.com/4yMy6je.png)

It still masks out the info:

![Hidden](http://i.imgur.com/FS3UQRe.png)

As a workaround, I've just begun immediately using the variable so the popup goes away:

![WorkAround](http://i.imgur.com/ZXHdfNQ.png)

But there has to be something better.  Is there some type of integration where I can see both?

Resharper warning hides quick info

Your problem is not that your value is null, the problem is that your object is not initialized at all. For example:

        static void Main(string[] args)
        {
	        List<int> empty;

	        if (empty != null)
	        {
				Console.WriteLine("no");
	        }
        }

**Will not compile**, because `empty` has no value. If I change the code to:

        static void Main(string[] args)
        {
	        List<int> empty = null;

	        if (empty != null)
	        {
				Console.WriteLine("no");
	        }
        }

It'll work, because my list now has a value, it's null, but it still exists.

EDIT: Sorry I used C# instead of VB, that's because that editor I have handy, but the code is correct. 
You initialize your variables every time and you'll not gonna get the error.

In the following code, if `cmd` has been initialized, then I'll make to sure to close any open connections before throwing an exception. However, even after I check that `cmd` is not null, I still get a possible null reference warning in subsequent lines of code.



    Dim cmd As SqlCommand
    Try
        'Do some Stuff
    Catch ex As Exception
        If cmd IsNot Nothing AndAlso
           cmd.Connection IsNot Nothing AndAlso              '<- null cmd warning 
           cmd.Connection.State = ConnectionState.Open Then  '<- null cmd warning 
            cmd.Connection.Close()                           '<- null cmd warning 
        End If
        Throw
    End Try

I get the two following warnings (possibly one from Resharper & one from Visual Studio):

> * Variable 'x' might not be initialized before accessing.  A null reference exception could occur at runtime.
> * BC42104: Variable 'x' is used before it has been assigned a value. A null reference exception could result at runtime.

According to the [Visual Studio Page][BC42104]:

>An application has at least one possible path through its code that reads a variable before any value is assigned to it.

But I don't think there is even one possible path through the code where the variable would be used without being initialized.

* Have I made some error or is this a bug?
* Is there a way to disable this warning from coming up?

Here's a screenshot:

![screenshot][screenshot]


This is different from many similar questions already asked here, like [Prevent Resharper “Possible Null Reference Exception” warnings][Prevent Resharper] because I'm not trying to allow for a NullableType, but instead have already guaranteed that my variable is not null.

-----

## Update:

Follow up question: Why?

Whether my object is never initialized or initialized to `Nothing`, in both cases `cmd IsNot Nothing` should resolve to `False`, so anything after the `AndAlso` should never be executed. 



    Dim cmd1 As SqlCommand
    Console.Write(cmd1 IsNot Nothing) 'False

    Dim cmd2 As SqlCommand = Nothing
    Console.Write(cmd2 IsNot Nothing) 'False

Maybe the compiler just doesn't have a good way of guaranteeing this at compile time.

[BC42104]: http://msdn.microsoft.com/en-us/library/3fdk625a.aspx
[Prevent Resharper]: https://stackoverflow.com/q/5172674/1366033

[screenshot]: http://i.imgur.com/fLZPwdb.png

Disable null reference warning when I've checked for nulls

According to [this tracking issue][1] - this doesn't appear to be currently supported by resharper.  

However, starting with VS 2017, there is a native command that will select the next matching text:

<kbd>Shift</kbd> + <kbd>Alt</kbd> + <kbd>.</kbd> - **`Edit.InsertNextMatchingCaret`**

[![select next][2]][2]

**See Also**: [What is the equivalent shortcut for CTRL + D of VSCode in Visual Studio?][3]


  [1]: https://youtrack.jetbrains.com/issue/RSRP-478461
  [2]: https://i.stack.imgur.com/bNOgU.gif
  [3]: https://stackoverflow.com/a/70379900/1366033

On Resharper's documentation I found out that this feauture can be used with "Alt + J" shortcut. But when I select the name of some variable and click foregoing shortcut nothing happens. Am I doing something wrong?