The Solution Explorer window that we were accustomed to in Visual Studio 2010 was good for being able to understand how files were organized into the various projects of a solution, but it didn't do much more than that. With Visual Studio 2013, Microsoft has revisited Solution Explorer and given it an overhaul. It still contains all of the functionalities you know from the old Solution Explorer, and it adds to that a range of new features intended to make navigating and searching within your solution a more powerful yet simpler experience.
Open the same VS2010_Web solution that we have been using for the other recipes in this chapter or choose a solution of your own.
We'll begin by navigating through our solution. Locate the
Default.aspxpage in theVS2010_Webproject and click on the arrow next to it so that its contents are displayed. As you would expect, there is a code-behind file and a designer file:
Look at the
Default.aspx.csfile. You can see that there is a small arrow next to it just as there was for theDefault.aspxpage. Click on the arrow:
Visual Studio 2013 expands the file to show its contents, and in the case of a code-behind file, these contents are the class definitions it contains. Classes have methods and properties in them, so click on the arrow next to the
_Defaultclass to see the methods inside it. Since theVS2010_Webproject is just a shell, there is only an emptyPage_Load()method, as shown in the following screenshot:
Now select the
IService1.csfile from theVS2010_Web.Servicesproject and expand it to see its contents. You will see that there is both an interface definition in this file (IService1) and a class definition (CompositeType), as shown in the following screenshot:
Right-click on the
IService1interface and click on the Derived Types option to see what classes implement this interface:
The Solution Explorer window will change views to show you the types that either implement this interface or inherit from it, as shown in the following screenshot. Click on the back button (showing the blue background) to return to the standard Solution Explorer view:
Right-click on the
IService1interface and choose the Is Used By option to see where the interface is currently being used. As with the Derived Types option, you will see Solution Explorer change its context to only show the interface and where that interface is used in the solution, including line and column numbers:
Return to the regular Solution Explorer view by clicking on the home button, shown in the following screenshot:
At this point, you know how to navigate using Solution Explorer, and you have already used the existing Navigate To feature in the Finding Visual Studio commands recipe while opening a file. With the enhancements to Solution Explorer, you can locate files in much the same way as with the Navigate To command, albeit with a slightly different user experience. Click on the Search Solution Explorer textbox at the top of the Solution Explorer window, or use the default shortcut key of Ctrl + ; (Ctrl + semicolon).
Enter
servin the textbox and wait a moment for the search results to display. The results should look similar to the following screenshot. You can not only see the filenames that match the search term but also any matching references, classes, and methods:
The Navigate To feature from Visual Studio 2010 was a fantastic addition to Visual Studio. It had problems in large projects with many search matches as the location of a match was embedded in the result itself, making it hard to locate the specific match you were after. The new Solution Explorer search tool provides similar results to the Navigate To feature, but having the location of a match represented in the tree view makes it very easy to quickly identify the specific match you are interested in.
It's worth mentioning a few other things about searching within your solution.
Assuming you have the Preview Tab enabled for Solution Explorer, as you navigate using Solution Explorer to various classes and methods, you may have noticed that the document preview tab was updating and showing exactly where the selected class, method, or property was declared. This makes it easy to see what the code is doing without the need to specifically open the file or scroll through a source file to see what code is actually inside a method, class, or property.