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

You might need to actually put the breakpoint inside the method, as you're saying "break before this line is executed".  On function declaration, how do you break before that line? 



    Protected Sub Page_Load(sender As Object, e as System.EventArgs)

       ' Some Page load task - try setting your break point here.

    End Sub

I'm working on a [Web **Site** Project][1] as opposed to a Web **Application** Project.  As such, there is no project file to build and produce a `.dll` library file or `.pdb` debugger symbols file.

Right out of the box, if I create a brand new web site project, try to set a breakpoint anywhere, and  run with the debugger on, I get the following message:

>The breakpoint will not currently be hit. No symbols have been loaded for this document.

![Screenshot][2]

I must be overlooking something simple, because there must be a way to debug an ASP.NET Web Site. Right?

**Steps to reproduce**:

1. Open Visual Studio (confirmed in 2010 and 2008)
2. Create New Web Site Project
3. Select ASP.NET Web Site
4. Add a Load Event handler to Default.aspx.vb
5. Run with Debugger <kbd>F5</kbd>
6. This will prompt you to have `<compilation debug="true" />` in your web.config if you don't already, select yes.
7. Debugger symbols will not be loaded for the page because it is compiled on the fly

[1]: http://msdn.microsoft.com/en-us/library/dd547590(v=vs.110).aspx
[2]: http://i.imgur.com/RUSBjx4.png

Set breakpoints in an ASP.NET Web Site Project

[Pinnable Properties][1] in VS2019+ are a way to go currently, since you can pin your properties in correct order using the [![pin][2]][2] button inside the datatip.

However, in a more general, reusable approach, the `[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]` attribute can be used on an array of ordered property name and value pairs. This enables the debug view to 'flatten' the array root, listing the properties in correct order.

Further expanding on [KyleMit's answer][3], and using reflection to load the list of members and fields, makes such a debug view reusable:

    [DebuggerDisplay("{Name}")]
    [DebuggerTypeProxy(typeof(OrderedPropertiesView))]
    public class Rule
    {
        public string Name;
        public int MaxAge;
        public DateTime StartDate;
        public DateTime EndDate;        
    }

    public class OrderedPropertiesView
    {
        [DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
        public SimpleProperty[] Properties { get; }

        public OrderedPropertiesView(object input)
        {
            this.Properties = input.GetType()
                .GetFields(BindingFlags.Public | BindingFlags.Instance)
                .Select(prop => new SimpleProperty(prop, input))
                .ToArray();
        }

        [DebuggerDisplay("{Value}", Name = "{PropertyName,nq}")]
        public class SimpleProperty
        {
            public SimpleProperty(MemberInfo member, object input)
            {
                this.Value = GetValue(member, input);
                this.PropertyName = member.Name;
            }

            private object GetValue(MemberInfo member, object input)
            {
                switch (member)
                {
                    case FieldInfo fi: return fi.GetValue(input);
                    case PropertyInfo pi: return pi.GetValue(input);
                    default: return null;
                }
            }

            public object Value { get; internal set; }
            public string PropertyName { get; internal set; }
        }
    }

Which looks like this in the debugger:

[![datatip with ordered 'properties'][4]][4]

The order of properties and fields might not be guaranteed with reflection, but since the view is only for debugging purposes, it should be enough. If not, `Properties` array can be constructed manually, limiting the reusability. In either case, `Properties` are not really properties, therefore expanding the `SimpleProperty` datatip looks like this:

[![expanded datatip showing PropertyName and Value properties of SimpleProperty][5]][5]

Notice that the property inspector [![magnifyng glass][6]][6] can only be used in the expanded `SimpleProperty.Value`, which might be an inconvenience.


  [1]: https://devblogs.microsoft.com/visualstudio/pinnable-properties-debug-display-managed-objects-your-way/
  [2]: https://i.stack.imgur.com/SRQVz.png
  [3]: https://stackoverflow.com/a/28506057/1945988
  [4]: https://i.stack.imgur.com/1JSUa.png
  [5]: https://i.stack.imgur.com/WcMP6.png
  [6]: https://i.stack.imgur.com/u2Urb.png

In Visual Studio, is it possible to customize the order in which properties are displayed when inspected in the debugger?

Here's an example of a class where I'd really like StartDate and EndDate to appear next to each other, even though they are separated alphabetically .

![example][1]


Other debugger options are customizable through attributes like the [`DebuggerDisplayAttribute`][2], so I was hopeful that another such attribute would exist for DisplayOrder.




    [DebuggerDisplay("{Name}")]
    public class Rule
    {
        public string Name;
        public int MaxAge;
        public DateTime StartDate;
        public DateTime EndDate;
    }




In an *ideal world*, I'd like the ability to order the properties in the inspector in the order that I have defined on the class (even if that requires setting an debugger order attribute incrementally on each property) so the display would look like this:

![ideal debugger][3]


[1]: http://i.imgur.com/srpTyOf.png
[2]: https://msdn.microsoft.com/en-us/library/system.diagnostics.debuggerdisplayattribute.aspx
[3]: http://i.imgur.com/zzm2hm0.png

Display Properties in Custom Order in Visual Studio Debugger

You're currently loading the following JavaScript files in the following order:

1. jQuery 2.1.0
2. Bootstrap 3.2.0
3. Bootstrap-Select 1.6.5
4. Bootstrap 3.3.4

The second call to a different version of bootstrap is what's causing issues.  Get rid of it and you should be fine.

### Demo in Stack Snippets





    $('.selectpicker').selectpicker({
        style: 'btn-default',
        size: 4
    });



    <link href="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.2/css/bootstrap.css" rel="stylesheet"/>
    <link href="//cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.7.1/css/bootstrap-select.css" rel="stylesheet"/>

    <script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.2/js/bootstrap.js"></script>
    <script src="//cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.7.1/js/bootstrap-select.js"></script>

    <select class="form-control deptId selectpicker" name="depId" placeholder="Department Name">
      <option selected="selected">Select department name</option>
      <option>Depart 1</option>
      <option>Depart 2</option>
      <option>Depart 3</option>
      <option>Depart 4</option>
      <option>Depart 5</option>
    </select>




Also, here's an [updated Demo in Fiddle][1]

[1]: https://jsfiddle.net/KyleMit/uscj19zL/4/

I found that bootstrap selectpicker does not work with bootstrap.js file. If bootstrap.js and selectpicker files are in same location listpicker does not open.

    <select class="form-control deptId selectpicker" name="depId" placeholder="Department Name">
        <option selected="selected">Select department name</option>
        <option>Depart 1</option>
        <option>Depart 2</option>
        <option>Depart 3</option>
        <option>Depart 4</option>
        <option>Depart 5</option>
    </select>

[Fiddle Sample][1]


  [1]: https://jsfiddle.net/uscj19zL/3/

https://jsfiddle.net/uscj19zL/3/

Conflicting between bootstrap selectpicker and bootstrap.js file

What you probably want to do is:  

>**Step *Into* Code** with <kbd>F11</kbd>

Instead of:  

> **Step *Over* Code** with <kbd>F10</kbd>

Stepping into code will move into the next method being called.  Often times this is located in another file but it doesn't have to be by definition.

[![Screenshot][1]][1]


**Further Reading**: 

* [First look at the Visual Studio Debugger][2]
* [Navigate through code with the Visual Studio debugger][3]


  [1]: https://i.stack.imgur.com/Xf4ad.png
  [2]: https://learn.microsoft.com/en-us/visualstudio/debugger/debugger-feature-tour?view=vs-2019
  [3]: https://learn.microsoft.com/en-us/visualstudio/debugger/navigating-through-code-with-the-debugger?view=vs-2019

I'm trying to understand the workflow of a project, and want to instrument on each file that is called. 

I've tried to use definition/reference to set breakpoint manually, but it's a huge project that it might miss something this way.

I've also used the step forward button in Visual Studio but it just jumps to the very next line, which makes it impossible to trace the entire project.

Is there something that you can jump to the next file, instead of the next line? Or is there some other tools that could help me understand the flow of the codes?