In this article, we will look into a new feature of Visual Studio 2013 that helps to edit and view code present in various files without switching among the windows. This will help us to write code faster without jumping from the code that you're writing. Let's create a sample Console Application in Visual Studio 2013 and explore it further with the following piece of code:



We are calling two methods from the Main method. "MethodA()" is present in the "Program.cs" file and "MethodB()" is in the "TestPeek.cs" file. Prior to Visual Studio 2013, we use "Go to Definition" for editing "MethodB()" that will take us away from the code that you're writing to a new window. In Visual Studio 2013, we can edit the code in the same place without switching to a new window by pressing the "Alt + F12" shortcut or clicking on "Peek Definition" as shown below:



This will show the definition of MethodB() in the same window for editing as shown below:



Once we are done with editing, we can save and press the "Esc" button to close the Peek Definition window. We can press on to open the file having the definition of "MethodB()" in a new document window.

We can even nest Peek Definition windows as shown below:



Here, we opened "MethodA()" in a Peek Definition window, that opened "MethodB()" in another window and can navigate backward and forward using breadcrumb dots within the window.



This feature can also be used on classes as well to edit within the current window as shown below:



The keyboard shortcuts for this feature:

• Open Definition window: Alt+F12
• Close the window: Esc
• Navigate among definition windows: Ctrl+Alt+- and Ctrl+Alt+=
• Toggle between the code editor window and the definition window: Shift+Esc

We can use this feature to edit a class or method in the current editor without switching from the code that you're writing.

In below Logging dialog, we can configure format of the log file, it can be:

1)      IIS - IIS log file format is a fixed ASCII text-based format, so you cannot customize it [Can’t select fields] and fields are separated by comma.

2)      W3C [default format]: It is a customizable ASCII text-based format. You can use IIS Manager to select which fields to include in the log file and fields are separated by spaces.

3)      NCSA – its log file format is a fixed ASCII text-based format, so you cannot customize it and contains less information than IIS log format.

4)      Custom - ODBC logging is implemented as a custom logging module and helps to log information into ODBC-compliant database like SQL Server or MS-ACCESS.

Select W3C as log format, click on Select Fields and choose fields that need to be logged in the log file.

We can set location\directory for the log files, set options to create a new log file based on file size, daily or weekly etc.  When we check “Use local time for file naming and rollover”, will use local server time instead of UTC for log file naming and time for log file rollover. This setting will not affect the time field format of the request logged in the file and uses UTC time format.

Let’s may a request to welcome.png present in Default Web Site and analyze the log file. This log file will be under path set in Logging Feature + W3SVC<website identifier>. In my case, it is “C:\inetpub\logs\LogFiles\W3SVC1” and contains below information:

Most of the fields are self-explanatory and field prefixes have the following meanings:

s- Server actions

c- Client actions

cs- Client-to-server actions

sc- Server-to-client actions

time-taken field will show total time taken to generate the response as well as time took  to send the complete response to the client till the last byte.  This is done by taking into account the last ACK from the answer to the response. Let’s say, a request took 5000 milliseconds to generate the response and 3000 milliseconds to send complete response to the client, so it will show time-taken as 8000 milliseconds.

Most of the above logging features are also available on a FTP site as well.

In most of the cases, your log file will be very big in size and can’t be analyzed in a notepad. In that scenario, we can use Log parser (Available here). Let’s install it and open our log file as shown below:

Click on New Query from File Menu and select Log type as IISW3CLOG and hit F5. Result will be as shown below:

We can even write our own queries in SQL syntax to filter the data:

SELECT TOP 10 * FROM '[LOGFILEPATH]' where time-taken >100

As well, there are few set of built-in queries for IIS in Library tab as shown below:

By using Log Parser studio, we can analyse large log files to find out load, performance issues to page or user level. We can use IIS logs as a first step to troubleshoot performance issues. This log helps us to find out any performance issues exist or not, if exist which page taking time to respond back etc. I will end this article, by mentioning tools helpful in troubleshooting IIS issues in scenarios like crash, hang, high CPU or memory etc [We will discuss on below tools in depth in coming articles]:

1)      IIS Logging

2)      IIS Advanced Logging

3)      FREB Tracing [Failed Request Tracing]

4)      Fiddler or IE Developer Tools

5)      Memory dumps collection ofw3wp.exe using Debug Diag or AD Plus.

6)      Memory dumps analysis using WinDbg tool.

I hope this article will be helpful for all.

      RavenDB is a transactional, open-source Document Database [NoSQL] written in .NET offering a flexible data model designed to address requirements coming from real-world systems. RavenDB allows you to build high-performance, low-latency applications quickly and efficiently. RavenDB stores data schema-less as JSON documents within the database, and can be queried using LINQ queries or using RESTful API.

Let’s take an example of storing an employee record in RDBMS vs NoSQL. In RDBMS, our database design looks like as shown below:

When it comes to NoSQL specifically Raven DB, structure looks like as shown below:

public class Employee
{
public int EmployeeId { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public DateTime DateJoined { get; set; }
public Position Position { get; set; }
public Department Department { get; set; }
}
public class Position
{
public string Name { get; set; }
public string Description { get; set; }
}
public class Department
{
public string Name { get; set; }
public string Description { get; set; }
}

// Create an instance of Employee for stroing in Raven DB
 

Employee objEmp = new Employee
 {
 FirstName = "AAA",
 LastName = "BBB",
 EmployeeId = 30,
 DateJoined = DateTime.Now.AddYears(-1),
 Department = new Department{ Description = "Software services", Name = "IT" },
 Position = new Position{ Name = "Project Lead", Description = "Project Mgmt Role" }
 };

Above structure doesn’t have any relationships as in RDBMS. This structure is simple, flexible and no need of Joins to get the Employee’s data.

Let's create a sample MVC 4 application to understand it in a better way. Create a new MVC 4 Internet application and name it as RavenDBSample. Go to References under Solution Explorer, click on "Manage NuGet Packages" and install Raven DB Client [API] & Server [to host Database] as shown below:

We can host database on Raven DB in below ways:

1) As a stand-alone process 

2) As a Windows Service

3) Embedded within the.NET  application

4) On IIS

In this example, we host the database as stand-alone process. Now, run Raven.Server.exe under ~\RavenDBSample\packages\RavenDB.Server.2.5.2700\tools as shown below:

From above console, we know that our database is listening on http://machinename:8080/. Let's insert and retrieve our Employee object from Raven DB database. Modify Global.asax.cs to create our DocumentStore:

public class MvcApplication : System.Web.HttpApplication
 {
 public static DocumentStore MyStore;
 protected void Application_Start()
 {
 AreaRegistration.RegisterAllAreas();
 
 WebApiConfig.Register(GlobalConfiguration.Configuration);
 FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
 RouteConfig.RegisterRoutes(RouteTable.Routes);
 BundleConfig.RegisterBundles(BundleTable.Bundles);
 AuthConfig.RegisterAuth();
 MyStore = new DocumentStore { Url="http://localhost:8080"};
 MyStore.Initialize();
 }
 }

Creating DocumentStore object is time consuming process, so it needs to be created only once per application.Add above class definitions of Employee, Position, Department to AccountsModel.cs and add below code to Index view under Home folder:

@model RavenDBSample.Models.Employee
 @{
 ViewBag.Title = "Employee Details";
 }
 <fieldset>
 <legend>Employee</legend>
 <table>
 <tbody>
 <tr>
 <td>
 First Name: @Model.FirstName
 </td>
 </tr>
 <tr>
 <td>
 Last Name: @Model.LastName
 </td>
 </tr>
 <tr>
 <td>
 Date of Join: @Model.DateJoined
 </td>
 </tr>
 <tr>
 <td>
 Position: @Model.Position.Name
 </td>
 </tr>
 <tr>
 <td>
 Department: @Model.Department.Name
 </td>
 </tr>
 </tbody>
 </table>
 </fieldset>
 

Now, add below code to Index action in HomeController to save and retrieve Employee data from Database:

 public ActionResult Index()
{
using (var session = MvcApplication.MyStore.OpenSession())
{
Employee objEmp = new Employee
{
FirstName = "AAA",
LastName = "BBB",
EmployeeId = 30,
DateJoined = DateTime.Now.AddYears(-1),
Department = new Department{ Description = "Software services", Name = "IT" },
Position = new Position{ Name = "Project Lead", Description = "Project Mgmt Role" }
};
session.Store(objEmp);
session.SaveChanges();//To Commit our changes to DB.
//Get Employee back from DB
Employee myEmp = session.Query<Employee>().Where(a => a.FirstName == "AAA").First();
return View(myEmp);
}
}

Run the application, it will show the Employee details. We haven't created any tables in Raven DB and those are created on the fly to store Employee object. I attached source code of this application. We will look into more details of Raven DB with MVC 4 and Web API in coming articles. I hope this article will be helpful for all.

RavenDBSample.rar

We will create a Helper method to strip\remove the HTML tags from a string. Modify the Index view with code as shown below:

@{
ViewBag.Title = "Home Page";
}
@helper StripHTML(string input)
{
<b>
@System.Text.RegularExpressions.Regex.Replace(input, "<.*?>", string.Empty)
</b>
}
<div>
HTML Content: @HttpUtility.HtmlDecode("<div><p>Test</p><br/></div>")
<br />
Plain Content:@StripHTML("<div><p>Test</p></div>")
</div>

Above Helper will strip the HTML from any parameter passed to it and renders on the View. Syntax is for defining a helper is similar to defining a Method without return type. This way, we can create Helper method with our logic & markup needed. One problem here is, we can't reuse it in other Views. To solve this, we can move the Index.cshtml having custom Helper to App_code folder [Create it, if not exist] and access the helper in any View by mentioning ViewName.HelperName as shown in below code:

@Index.StripHTML("<div><p>Test</p></div>")

Another approach to create custom HTML helper is using Extension methods. Add a new class named MyHelper.cs with below code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MyCustomHelper.Helpers
{
public static class MyHelper
{
public static MvcHtmlString StripHTML(this HtmlHelper html, string input)
{
return new MvcHtmlString(System.Text.RegularExpressions.Regex.Replace(input, "<.*?>", string.Empty));
}
}
}

Build the project and include below code in the view, where you need to access the Helper Method as shown below:

@using MyCustomHelper.Helpers

@Html.StripHTML("<div><p>Test</p></div>")

I am attaching source code for reference. By following above two approaches, we can create our own HTML helpers for using in the Views. I hope this article will be helpful for all.

MyCustomHelper.zip

New templates in MVC 4 are

1)      Mobile Application  - It is used to create web application targeting mobile devices with Forms Authentication

2)      Web API – It is used to develop HTTP services that targets broad range of clients like browsers, mobile devices, any applications that can understand HTTP protocol and it’s a platform for building RESTful applications.

Select Internet Application as Project type and click Ok. Open Solution Explorer and it is as shown below:

First noticeable change in project structure is in App_Start folder. Let’s look into it one by one:

1)      AuthConfig.cs – This file contains code to register clients for external authentication providers like Facebook, Twitter etc. By default, this code is commented out, so none of the external providers are enabled.

2)      BundleConfig.cs – This file contains code for configuring Bundling and minification features. Refer here for getting an idea on this feature.

3)      FilterConfig.cs – This file contains code for registering filters. A filter is a method that contains logic need to be executed before or after an action method call.

4)      RoutConfig.cs – This file contains code for registering the routes. A route defines mapping of incoming browser requests to particular MVC controller actions.

5)      WebApiConfig.cs – This file contains code for configuring Web API like routes.

Prior to MVC 4, all the above settings can be defined in Global.asax file. For maintainability, It got split into different files.

In Filters folder, we can define filters for the application and separate folder for Images, which is not part of Content folder in this release.

Next major addition is packages.config. This file is managed by NuGet infrastructure for tracking\updating packages like jQuery, jQuery UI, EntityFramework, Modernizr etc and their version used in the application. It looks like as shown below:

For example, your application is using jQuery package 1.7 and you want to point it to 1.8. Prior to this release, we need to manually download the 1.8 version separately and include it in the project. In MVC 4, we can do it easily by just clicking on Manage NuGet Packages as shown below:

It will show up below window, where we can install\update the packages with its latest version:

The above project structure will also apply to Web API project. In Web API project, a controller is inherited from ApiController and won’t return a view in the action method as shown below:

This article covers changes included in MVC 4 project template.  In coming articles, we will discuss more about MVC 4 features. I hope this article will be helpful for all.

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Presentation;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Drawing.Charts;

Modify Index view under Home Controller to generate jqPlot chart as shown below:

@using (Html.BeginForm())
 {
 <div>
 <div id="divChart" style="width:350px;height:400px;"></div>
 Graph's Image:
 <div id="divChartImg"></div>
 <br />
 <input type="button" name="ExportGraph" id="ExportGraph" value="Export Chart" />
 <input type="hidden" name="imgData" id="imgData" value="hidden text" />
 </div>
 }
 
 <script type="text/javascript">
 $(document).ready(function () {
 
 //Draw a Sample jqPlot chart
 var data = [['Heavy Industry', 12], ['Retail', 9], ['Light Industry', 14], ['Out of home', 16], ['Commuting', 7], ['Orientation', 9]];
 var plot1 = jQuery.jqplot('divChart', [data], { seriesDefaults: { renderer: jQuery.jqplot.PieRenderer, rendererOptions: { showDataLabels: true} }, legend: { show: true, location: 'e'} }); // Save Image's data embedded in src attribute in a hidden variable 
 $("#ExportGraph").click(function () //Convert Graph to Image
 var j = $("#divChart").jqplotToImageElem();
 $("#divChartImg").append(j);
 $('#divChart').hide();
 $("#imgData").val($("#divChartImg img").attr('src'));
 $('form').submit();
 });
 });
 </script>

On click of Export Chart button, we converted Pie chart to a image using jqplotToImageElem() . Than, the Graph's image content embedded in src attribute of divChartImg is stored in a hidden variable to access in our action after form submission.
Create a PowerPoint file having a sample image named as Template.pptx under Content folde as shown below:

Add below POST action for saving the Graph's image and returning the PowerPoint.

 [HttpPost]
 public ActionResult Index(FormCollection form)
 {
 try
 {
 //Save Image of jqPlot Chart to a file
 string fileName = Guid.NewGuid().ToString()+".jpg";
 var data = form["imgData"].Replace("data:image/png;base64,", "");
 Byte[] bitmapData = new Byte[data.Length];
 bitmapData = Convert.FromBase64String(FixBase64ForImage(data));
 System.IO.MemoryStream streamBitmap = new System.IO.MemoryStream(bitmapData);
 Bitmap bitImage = new Bitmap((Bitmap)Image.FromStream(streamBitmap));
 //bitImage.Save(Server.MapPath("~/content/") + fileName);// This statement will save file locally as an Image.
 
 //Insert the jqPlot Chart's Image into PowerPoint
 using (PresentationDocument prstDoc = PresentationDocument.Open(Server.MapPath("~/content/") + "Template.pptx", true))
 {
 string imgId = "rId" + new Random().Next(2000).ToString();
 ImagePart imagePart = prstDoc.PresentationPart.SlideParts.FirstOrDefault().AddImagePart(ImagePartType.Jpeg, imgId);
 imagePart.FeedData(new MemoryStream(bitmapData.ToArray()));
 DocumentFormat.OpenXml.Drawing.Blip blip = prstDoc.PresentationPart.SlideParts.FirstOrDefault().Slide.Descendants<DocumentFormat.OpenXml.Drawing.Blip>().First();
 blip.Embed = imgId;
 prstDoc.PresentationPart.SlideParts.FirstOrDefault().Slide.Save();
 prstDoc.PresentationPart.Presentation.Save();
 prstDoc.Close();
 }
 return File(Server.MapPath("~/content/") + "Template.pptx", "application/mspowerpoint", "Graph.pptx");
 }
 catch (Exception ex)
 {
 
 return Content(ex.Message);
 }
 }
 public string FixBase64ForImage(string Image)
 {
 System.Text.StringBuilder sbText = new System.Text.StringBuilder(Image, Image.Length);
 
 sbText.Replace("\r\n", String.Empty);
 
 sbText.Replace(" ", String.Empty);
 
 return sbText.ToString();
 }
 
 }

We read the byte stream of Chart's image and added as an Imagepart to PPT. Finally, PPT image is replaced with Graph's image and returned to client as a File Result. I will outline the steps followed for exporting jqPlot chart to PowerPoint:

1) Created a sample jqPlot Pie chart
2) Converted it to image using jqplotToImageElem().
3) Image content in bytes is submitted to the action as a hidden variable.
4) This image's bytes are passed as a Memory stream in PowerPoint and replaced the actual image by mapping it to new ImgId.

I am attaching the source code reference. By tweaking the above code, we can export any jqPlot graph to an image and than into PowerPoint.  I hope this article might be helpful to all.

ExportjqPlotChart.zip

 In this article, we will be looking into customization of a Bar chart in PowerPoint using Open XML library within ASP.NET MVC application. Create a new MVC 3 Internet application on VS 2010 and name it as PPTBarChart. Add a reference to DocumentFormat.OpenXml.dll, WindowsBase.dll [Download from here]. Create a PowerPoint 2007/2010 with bar chart having two categories under Content folder as shown below:

Modify Index view as shown below to enter values for customizing the bar chart’s values, Maximum, Direction & Grouping etc:

Include below namespaces in the HomeController:

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Presentation;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Drawing.Charts;

Create below POST action to read the PowerPoint, replace the chart’s value and send it to client for download as shown below:

[HttpPost]
public ActionResult Index(FormCollection form)
{
//Read PPT in-memory for inline editing
byte[] byteArrayPPT = System.IO.File.ReadAllBytes(Server.MapPath(@"~\content\BarGraphPPT.pptx"));
MemoryStream FPmem = new MemoryStream();
FPmem.Write(byteArrayPPT, 0, (int)byteArrayPPT.Length);
PresentationDocument barPPT = PresentationDocument.Open(FPmem, true);
// Get the chart in the first slide
ChartPart chartPart = barPPT.PresentationPart.SlideParts.First().ChartParts.First();
ChartSpace chartSpace = chartPart.ChartSpace;
List<int> indexOfUsedItems = new List<int>();
BarChart barChart = chartSpace.Descendants<BarChart>().FirstOrDefault();
//Set Max Value for Y Axis:
if (((DocumentFormat.OpenXml.Drawing.Charts.MaxAxisValue)chartPart.ChartSpace.Descendants<DocumentFormat.OpenXml.Drawing.Charts.MaxAxisValue>().FirstOrDefault()) != null)
{
((DocumentFormat.OpenXml.Drawing.Charts.MaxAxisValue)chartPart.ChartSpace.Descendants<DocumentFormat.OpenXml.Drawing.Charts.MaxAxisValue>().FirstOrDefault()).Val.Value = Convert.ToInt32(Request.Form["MaxValue"]);
}
//Set Bar Direction:
if (form["BarDirection"] == "Column")
{
barChart.BarDirection = new BarDirection() { Val = BarDirectionValues.Column };
}
else if (form["BarDirection"] == "Bar")
{
barChart.BarDirection = new BarDirection() { Val = BarDirectionValues.Bar };
}

//Set Bar Grouping:
if (form["BarGroup"] == "Clustered")
{
barChart.BarGrouping = new BarGrouping() { Val = BarGroupingValues.Clustered };
}
else if (form["BarGroup"] == "Stacked")
{
barChart.BarGrouping = new BarGrouping() { Val = BarGroupingValues.Stacked };
}
else if (form["BarGroup"] == "PercentStacked")
{
barChart.BarGrouping = new BarGrouping() { Val = BarGroupingValues.PercentStacked };
}
else if (form["BarGroup"] == "Standard")
{
barChart.BarGrouping = new BarGrouping() { Val = BarGroupingValues.Standard };
}
//Set Bar's Value:
if(!String.IsNullOrEmpty(form["Series11Value"].ToString()))
barChart.Descendants<NumericPoint>().ElementAt(0).NumericValue = new NumericValue(form["Series11Value"].ToString());
if (!String.IsNullOrEmpty(form["Series21Value"].ToString()))
barChart.Descendants<NumericPoint>().ElementAt(1).NumericValue = new NumericValue(form["Series21Value"].ToString());
if (!String.IsNullOrEmpty(form["Series12Value"].ToString()))
barChart.Descendants<NumericPoint>().ElementAt(2).NumericValue = new NumericValue(form["Series12Value"].ToString());
if (!String.IsNullOrEmpty(form["Series22Value"].ToString()))
barChart.Descendants<NumericPoint>().ElementAt(3).NumericValue = new NumericValue(form["Series22Value"].ToString());
if (!String.IsNullOrEmpty(form["Series31Value"].ToString()))
barChart.Descendants<NumericPoint>().ElementAt(4).NumericValue = new NumericValue(form["Series31Value"].ToString());
if (!String.IsNullOrEmpty(form["Series32Value"].ToString()))
barChart.Descendants<NumericPoint>().ElementAt(5).NumericValue = new NumericValue(form["Series32Value"].ToString());


barPPT.PresentationPart.Presentation.Save();

barPPT.Close();

string fileName = Server.MapPath(@"~\content\"+Guid.NewGuid().ToString()+".pptx");
using (FileStream fileStream = new FileStream(fileName, System.IO.FileMode.Create))
{
FPmem.WriteTo(fileStream);
FPmem.Flush();
FPmem.Close();

}
return File(fileName, "application/mspowerpoint", "BarGraphPPT.pptx");
}


Let’s dig into above code:

1)       We read the PPT content into Memory for in-line editing. This will avoid the changes to be written onto original file [BarGraphPPT.pptx].

2)       Find the first chart on the first slide and set its Maximum Y Axis value.

3)       Similar way, we are setting other values retrieved from the view like bar direction, Group and Category’s values.

4)       We are saving all the changes of the in-memory PPT and written to a file.

5)       Finally, we are returning the file back to client for download.

 We can run the application and customize the properties of the Bar chart and click on "Download Graph" to download the PowerPoint. By tweaking the above code, we can customize any kind & number of graphs within a PowerPoint. I hope this article will be helpful.

PPTBarChart.zip

Syntax:

lm Options [a Address] [m Pattern | M Pattern]

Output:

start    end        module name
00600000 00602600   2xcxcnk7   (deferred)            
00800000 00ac5000   xpsp2res   (no symbols)          
01000000 01005000   w3wp       (private pdb symbols)  c:\symsrv\w3wp.pdb\35B93EEEB1524E2C8368E5DAB78748A51\w3wp.pdb
02050000 02052600   jf7rcnjd   (deferred) 

Unloaded modules:
5e320000 5e329000   perfdisk.dll
5e310000 5e318000   perfnet.dll

First Column [start] in the output shows the base/start address at which the module loaded.

Second Column [End] shows the address upto which the module loaded.

Third Column [Module Name] typically shows file name of the module without extension.

Last Column [without Header] shows the path of symbol file, if symbols loaded for that module.

In above output, for module 2xcxcnk7  start is "00600000" and end is "00602600". It means this module extends from "0X00600000" to "0X00602600", inclusive.

We can sort the output based on module name instead of start address using "lmsm". Use "lm 1m" to list only module names and "lm m *s*" to list modules having letter s in its module name.

In order to extract all modules/dlls from your memory dump to a folder, use "!sam c:\myModules" (or) !SaveAllModules c:\myModules.

To extract a specify module, use "!SaveModule startaddress path" as shown below:

!SaveModule 00600000 c:\test.dll

Use "!lmi start-address/Module-Name" command to get detailed information about a module.

!lmi 00600000

!lmi 2xcxcnk7

Output:

Loaded Module Info: [00600000]
         Module: 2xcxcnk7
   Base Address: 00600000
     Image Name: 2xcxcnk7.dll
   Machine Type: 332 (I386)
     Time Stamp: 4f3194b6 Wed Feb 08 02:46:38 2012
           Size: 8000
       CheckSum: 0
Characteristics: 2102 
Debug Directories not present
    Symbol Type: DEFERRED - No error - symbol load deferred
    Load Report: no symbols loaded

In this Blog, We will look into Developer Tools for Internet Explorer 9 that helps Web developer to debug/troubleshoot issues. Our focus will be mainly on network tab in it, which will help to see request & response headers, cookies, body Initiator and Timings etc. To analyze request/response headers & body or capture a network trace in previous versions of Internet Explorer, We need external tools like Fiddler. But, in IE 9 we have built-in component inside Developer Tools to capture a trace and analyze it. We can show/hide Developer Tools from Tools menu -> F12 Developer Tools or using F12 key. By default, Network capture is disabled as shown below:

Click on Start Capturing and open a website like bing.com. It will capture network traffic as shown below:

Initiator for a request shows who initiated that request. In above capture, it shows download/request for homepageFD_c.css is initiated by link tag referring it.

We can double-click on any of the request to see more details of it like header, body and cookies as shown below:

We can save the network trace in xml or csv format for further analysis.

Some other cool features are:

1) We can use logging API instead of alert() for debugging using console.log() method as shown below:

2) We can debug client side javascript, add conditional breakpoints similar to Visual Studio breakpoints.

3) Profiler shows the amount of time scripts took to execute functions. This data can be viewed either in Function view or Call tree view.

There are lot more features apart from the ones covered here.

Let’s have a look at it with a live example. Open your VS 11 and create a simple class library Testlib with the below code:

Build it and then create three new web applications with name as MyApp1, MyApp2 & MyApp3 with a reference to Testlib as shown below:

Then, run each web application. Now, open command prompt and point to VS 11 SDK [similar to C:\Program Files (x86)\Microsoft SDKs\Windows\v8.0A\bin\NETFX 4.0 Tools] and run below command to intern the common assemblies present under ASP.NET Temporary Files folder to CommonAssemblies folder [in our case it’s testlib]:

aspnet_intern -mode exec -sourcedir "C:\Windows\Microsoft.NET\Framework\v4.0.30319\Temporary ASP.NET Files" -interndir C:\CommonAssemblies

By doing this, we can have only one copy of the assembly in RAM for use by multiple sites.  An assembly will be interned, if it was found in more than 3 different locations by default. We can change this value by using minrefcount switch.

We can get detail report [verbose] without interning the assemblies by running below command:

aspnet_intern -mode analyze -sourcedir C:\Windows\Microsoft.NET\Framework\v4.0.30319\Temporary ASP.NET Files" -interndir C:\ASPNETCommonAssemblies  -v

For more options on this tool, run aspnet_intern /?

We can make sure all eligible assemblies have been interned by running aspnet_intern.exe periodically using a scheduled task.

Note: This blog is based on features of preview only, and is subject to change in later releases.