1. Right-Click on any webform ( such as default.aspx ).
2. Select “Browse With…”
3. In the dialog box you will be shown the currently installed browsers. Highlight the browser you wish to use and click the Set as Default button.

1. Start Visual Studio and then create a new SQL Server project (File > New > Project > Database Projects)
2. In the dialog box, select the database (in this example the NORTHWIND database) and click Yes to create the project.
3. Add a  new Stored procedure named SampleSproc to the project (this will also add a SampleSproc.cs file to the project.)
4. Enter some code into the stored procedure, for example:

   public partial class StoredProcedures
   {
   [Microsoft.SqlServer.Server.SqlProcedure]
   public static void SimpleStoredProcedure(SqlString name)
   
   {
   using (SqlConnection sqlConn = new SqlConnection("context connection=true"))
   
   {
   String sqlStr = string.Format("Insert into [TableName] (FieldName, ...) values ('{0}', ...)", name);
   SqlCommand cmdObj = new SqlCommand(sqlStr, sqlConn);
   
   try
   {
   sqlConn.Open();
   cmdObj.ExecuteNonQuery();
   }
   
   catch (Exception ex)
   {
   }
   }
   }
   };

5. Enter a test script in the Test.sql file, eg:

   exec SimpleStoredProcedure 'testname1'
   
   select * from [TableName] where [FieldName] = 'testname1'

6. Right click the project,and then select to build and deploy it
7. Look in the Server Explorer to check and the stored procedure has been created
8. Right click the stored procedure and then select “Step into Stored Procedure” and Visual Studio will start the debugging.

For more info on SQL/CLR debugging: http://msdn.microsoft.com/en-us/library/ms165051(VS.80).aspx

Method 1

1. Start the application without debugging it (press Ctrl + F5)
2. Attach the Visual Studio Debugger to WebDev.WebServer.exe process

Method 2

1. Right click the app to debug and select Properties
2. Hit the Web tab on the left and select “Don’t open page” on the left panel
3. Start Debugging the app (press F5)
4. Open your browser and then navigate to the URL.

Method 3

1. Open the application Property page and select the Web tab
2. Select “Start External Program” and set the path to iexplorer.exe
3. Enter the URL in the Command line argument option
4. Hit F5 to commence debugging.

For more on how to disable  JavaScript debugging, please see http://blogs.msdn.com/greggm/archive/2009/04/06/disabling-script-debugging-in-vs-2008-ie8.aspx

1. Log on the remote machine  with the account and password as your local machine.
2. Run the remote debugger monitor on the remote machine (this is located at C:Program FilesMicrosoft Visual Studio 9.0Common7IDERemote Debuggerx86). To ensure that you will be running the correct remote debugger monitor, it is a good idea to copy the  local machine’s one to the remote machine.
3. Run the application to be debugged on the remote machine
4. Open Visual Studio on the local machine
5. Go to Tools -> Attach to Process which will open the Attach to process dialog .
6. Locate the Server name in the remote debugger monitor on the remote machine and enter the server’s name in the Qualifier box on the local machine
7. Locate the application’s process in the Available process section, specifying the correct code type, and then click the Attach button
8. Set your breakpoints and then run the app on the remote machine and a breakpoint will be hit.

Debugging can be commenced by clicking the green arrow button in the VS toolbar, selecting Debug-Strart Debugging from the menu, or hitting F5. Before commencing debugging you will need to select what exactly you are debugging, just starting debugging will commence the project from the default point. For a Web Forms app, if you want to start from another page other the default start page right click the page and select Set As Start Page. For a Win Forms app set the start Form in the application properties window first.

Prior to debugging, it will almost always be necessary to to set some breakpoints. Breakpoints pause the execution of the code and allow developers to examine controls and variables before allowing the program to continue to execute. Set a breakpoint by clicking in the margin of the code editor to and a red ball with code highlighted will appear (as shown below). The program’s execution will now be halted immediately before the highlighted line of code is hit.

So if we now hit F5 and start debugging there should be a delay as the project is built and the code will then be highlighted in yellow with a yellow arrow at the left:

At this point we can view variable values by hovering over them. Hovering over the vsTutor variable shows a value of 0 , hovering over the i variable does not work as the highlighted line as not been executed and the i variable not instantiated.

There are a number of important windows to monitor objects as the code executes, these are located in the bottom left by default but if not visible they can be opened from Debug>Windows.
The Watch window allow monitoring of any object which can simply be highlighted in the code window and dragged to the Watch window. The Watch window monitor objects regardless of whether they are in scope or now.
The Locals window cannot have objects dragged into it and shows all objects that are currently in scope. A powerful feature of the locals window is that it allow the objects to by modified. In this example, the value of the vsTutor variable can be modified by clicking and changing the number in the Value column.
The Autos window shows the objects used in the execution of the current statement.
The Immediate window allows for statements to be written and executed as the program’s execution is paused.
The Breakpoints window allows the breakpoints for the project to be managed by enabling, disabling or deleting them.

At all times the yellow arrow shows the line of code that will be executed next. This arrow can be dragged down to execute subsequent lines of code without executing the code that it is dragged over.

When in debug mode the Debug toolbar will either appear in the main tool bar of Visual Studio or a floating toolbar as show below.

The three buttons to the right of the yellow arrow are crucial to the debug process:
Step Into executes the next line of code that the program would normally execute.
Step Over proceeds to the next line of code in the current procedure, this means that other routines (such as functions) are called it will not proceed into those routines but simply execute them and continue to the next line of the current code block.
Step Out will move to the line of code which called the current process or the next breakpoint if that comes first.
In the next Debugging Tutorial we will proceed to examine more advanced Visual Studio debugging topics.

Note : The new WebMatrix web development tool has been released by Microsoft which features a well integrated suite of dev tools, check out WebMatrix Tutorial for more info