One of the improvements We wanted to make after deploying our website were to add useful error pages. You know more than the YSOD (yellow screen of death). One of the major issues for me was creating a useful and informative 404 page. We wanted the page to tell the user why they got there, offer suggestions about what page they may be looking for, and allow them to search the site. So We did the development work committed the changes and had the CI machine push to the server (in the case app harbor).

1.       <system.web>

2.           <compilationdebug=“true“targetFramework=“4.0“ />

3.           <customErrorsmode=“On“defaultRedirect=“~/error“>

4.               <errorstatusCode=“404“redirect=“~/404“ />

5.           </customErrors>

6.       </system.web>

But We were still seeing the generic IIS sever errors! We did some searching on the internet and found a helpful property of the response object.

1.       Response.TrySkipIisCustomErrors = true;

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

By default IIS will see an response with an error status code (400-500) and will automatically change the content of the response to its default error page. What this property does it tell IIS not to do that if there is already content in the body of the page. Well that was easy, right? So We made the change and pushed it to the server, and navigated to a page that didn't exist. Well the server still returned me the default 404 page, but on a 500 it would give me my custom error page. So what gives? Well here is the deal, the way routing works is that if ASP.NET cannot find a file that matches the requested URL the request is given back to IIS to handle. So in the case of a 404 ASP.NET can't find the file so its given back to IIS who uses the default static file handler to serve the request. This would be slightly different if the route had matched but then say somewhere in our code we set the status to 404. In this case it would already be in the ASP.NET pipeline and ASP.NET would server the custom 404 page.

There are two ways to solve this problem. First is the easiest which is to open up IIS Manger and go to the “Error Pages” settings under IIS and change the 404 page there to use your custom 404 page.

This is fine if you can remote into the server or you're not running in the cloud where multiple instances can be started. So how then do you make that work? Well lucky that We are using IIS8 hosting, starting with IIS7 and later these settings can be added to your web.config file under the System.WebServer node.

1.       <system.webServer>

2.           <httpErrorserrorMode=“Custom“ >

3.               <removestatusCode=“404“subStatusCode=“-1“/>

4.               <errorstatusCode=“404“path=“/404“responseMode=“ExecuteURL“ />

5.           </httpErrors>

6.       </system.webServer>

So lets dig into what some of this code means and tell you about the tricky parts that you need to know. Before you can add a custom page you need to remove the entry for the status code as there can only be one entry per status code. The tricky bit here is knowing to set SubStatusCode to –1. This basically means all the possible sub statuses. If you like you could remove only the specific one you needed and set only the specific one. Also if you are playing around with the config you might find that there is a defaultPath attribute on the httpErrors node. This defines a “default” error page should an entry not be found in the list. The problem is that by default this is “locked” and cannot be set in an applications web.config and instead needs to be set at the machine level.  Once you add these settings to your config you should be able to see your custom error page when you navigate to a page that does not exist.

A favicon is the little image displayed at the left edge of the address bar in most browsers, or on the tab. Adding a Favicon is a nice way to enhance your website and give it a finished look.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

Firefox displaying favicon:

Google Chrome displaying favicon:

Interner Explorer displaying favicon:

Adding a favicon to your website is very easy. First you need to create a 16 by 16 pixel icon and name it favicon.ico. No other file format or size will do. Save your favicon to the root directory of your ASP.Net web application:

In some older browsers (e.g., Internet Explorer 5), that's all it takes. For the latest versions of Firefox, Internet Explorer and Chrome, however, you need to add two links to your favicon to the head in your HTML. If you are using a master page, the same two links would go in the head on the master page.:

                <head runat="server">
                <title>My Website</title>
                <link runat="server" rel="shortcut icon" href="favicon.ico" type="image/x-icon"/>
                <link runat="server" rel="icon" href="favicon.ico" type="image/ico"/>
          </head>

The reason you have two links to the same favicon is to make sure your favicon works with most browsers. Some, such as Firefox, will work with either link. Internet Explorer versions 6 and 7 are especially picky. If you use both links, however, one is bound to work in almost any browser.

If you want to share your application resources(like css, javascript, images, etc) between different projects then embedded resource is a great choice. Embedded resource is also good for component/control writers because it allows component/control writers to distribute all the application resources with just a single assembly. A lot of vendors are already using this approach. It will great for component/control writers if they can leverage the ASP.NET bundling and minification for improving the performance. So, in this article we will show you how to write a very basic component(helper) which will use the ASP.NET bundling and minification feature on embedded javascript/css files.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

First of all create a new Class Library project and install the Microsoft.AspNet.Mvc, WebActivator and Microsoft ASP.NET Web Optimization Framework 1.1.0-alpha1(make sure to include the -Pre parameter in Package Manager Console) nuget packages. Next, add a reference of System.Web assembly. Then, create your control/component/helper. For demonstration purpose, We will use this sample helper:

01.          public static class HtmlHelpers
02.          {
03.                          public static MvcHtmlString NewTextBox(this HtmlHelper html, string name)
04.                          {
05.                                          var js = Scripts.Render("~/Test/Embedded/Js").ToString();
06.                                          var css = Scripts.Render("~/Test/Embedded/Css").ToString();
07.                                          var textbox = html.TextBox(name).ToString();
08.                                          return MvcHtmlString.Create(textbox + js + css);
09.                          }
10.          }

In this helper, I am just using a textbox with a style and script bundle. Style bundle include 2 css files and script bundle include 2 js files. So, just create 2 css files(NewTextBox1.css and NewTextBox2.css) and 2 javascript files(NewTextBox1.js and NewTextBox2.js) and then mark these files as embedded resource. Next, add a AppStart.cs file and add the following lines inside this file:

01.          [assembly: WebActivator.PostApplicationStartMethod(typeof(AppStart), "Start")]
02.          namespace Test
03.          {
04.                          public static class AppStart
05.                          {
06.                                          public static void Start()
07.                                          {
08.                                                          ConfigureRoutes();
09.                                                          ConfigureBundles();
10.                                          }
11.                                          private static void ConfigureBundles()
12.                                          {

13.                                                          BundleTable.VirtualPathProvider = new
                                                             EmbeddedVirtualPathProvider(HostingEnvironment.VirtualPathProvider);
14.                                                          BundleTable.Bundles.Add(new ScriptBundle("~/Test/Embedded/Js")
15.                                                          .Include("~/Test/Embedded/NewTextBox1.js")
16.                                                          .Include("~/Test/Embedded/NewTextBox2.js")
17.                                                          );
18.                                                          BundleTable.Bundles.Add(new StyleBundle("~/Test/Embedded/Css")
19.                                                          .Include("~/Test/Embedded/NewTextBox1.css")
20.                                                          .Include("~/Test/Embedded/NewTextBox2.css")
21.                                                          );
22.                                          }
23.                                          private static void ConfigureRoutes()
24.                                          {
25.                                                          RouteTable.Routes.Insert(0,
26.                                                          new Route("Test/Embedded/{file}.{extension}",
27.                                                          new RouteValueDictionary(new { }),
28.                                                          new RouteValueDictionary(new { extension = "css|js" }),
29.                                                          new EmbeddedResourceRouteHandler()
30.                                                          ));
31.                                          }
32.                          }
33.          }

The above class using WebActivator's PostApplicationStartMethod, which allows your assembly to run some code after the Application_Start method of global.asax. The Start method simply register a custom virtual path provider and two bundles which are used in our NewText helper class. But ASP.NET optimization framework will only emit a bundle url when debug="false" or when BundleTable.EnableOptimizations = true. Therefore, we also need to handle the normal javascript and css requests. For this case, the above method has also register a specific route for handling embedded resource requests using EmbeddedResourceRouteHandler route handler. Here is the definition of this handler:

01.          public class EmbeddedResourceRouteHandler : IRouteHandler
02.          {
03.                          IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
04.                          {
05.                                          return new EmbeddedResourceHttpHandler(requestContext.RouteData);
06.                          }
07.          }
08.          public class EmbeddedResourceHttpHandler : IHttpHandler
09.          {
10.                          private RouteData _routeData;
11.                          public EmbeddedResourceHttpHandler(RouteData routeData)
12.                          {
13.                                          _routeData = routeData;
14.                          }
15.                          public bool IsReusable
16.                          {
17.                                          get { return false; }
18.                          }
19.                          public void ProcessRequest(HttpContext context)
20.                          {
21.                                          var routeDataValues = _routeData.Values;
22.                                          var fileName = routeDataValues["file"].ToString();
23.                                          var fileExtension = routeDataValues["extension"].ToString();
24.                                          string nameSpace = typeof(EmbeddedResourceHttpHandler)
25.                                          .Assembly
26.                                          .GetName()
27.                                          .Name;// Mostly the default namespace and assembly name are same
28.                                          string manifestResourceName = string.Format("{0}.{1}.{2}", nameSpace, fileName, fileExtension);
29.                                          var stream =
                                             typeof(EmbeddedResourceHttpHandler).Assembly.GetManifestResourceStream(manifestResourceName);
30.                                          context.Response.Clear();
31.                                          context.Response.ContentType = "text/css";// default
32.                                          if (fileExtension == "js")
33.                                          context.Response.ContentType = "text/javascript";
34.                                          stream.CopyTo(context.Response.OutputStream);
35.                          }
36.          }

EmbeddedResourceRouteHandler returns EmbeddedResourceHttpHandler http handler which will be used to extract embedded resource file from the assembly and then write the file to the response body. Now, the only missing thing is EmbeddedVirtualPathProvider:

01.          public class EmbeddedVirtualPathProvider : VirtualPathProvider
02.          {
03.                          private VirtualPathProvider _previous;
04.                          public EmbeddedVirtualPathProvider(VirtualPathProvider previous)
05.                          {
06.                                          _previous = previous;
07.                          }
08.                          public override bool FileExists(string virtualPath)
09.                          {
10.                                          if (IsEmbeddedPath(virtualPath))
11.                                                          return true;
12.                                          else
13.                                                          return _previous.FileExists(virtualPath);
14.                          }
15.                          public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, DateTime
                             utcStart)
16.                          {
17.                                          if (IsEmbeddedPath(virtualPath))
18.                                          {
19.                                                          return null;
20.                                          }
21.                                          else
22.                                          {
23.                                                          return _previous.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
24.                                          }
25.                          }
26.                          public override VirtualDirectory GetDirectory(string virtualDir)
27.                          {
28.                                          return _previous.GetDirectory(virtualDir);
29.                          }
30.                          public override bool DirectoryExists(string virtualDir)
31.                          {
32.                                          return _previous.DirectoryExists(virtualDir);
33.                          }
34.                          public override VirtualFile GetFile(string virtualPath)
35.                          {
36.                                          if (IsEmbeddedPath(virtualPath))
37.                                          {
38.                                                          string fileNameWithExtension = virtualPath.Substring(virtualPath.LastIndexOf("/") + 1);
39.                                                          string nameSpace = typeof(EmbeddedResourceHttpHandler)
40.                                                          .Assembly
41.                                                          .GetName()
42.                                                          .Name;// Mostly the default namespace and assembly name are same
43.                                                          string manifestResourceName = string.Format("{0}.{1}", nameSpace,
                                                             fileNameWithExtension);
44.                                                          var stream =
                                                             typeof(EmbeddedVirtualPathProvider).Assembly
                                                             .GetManifestResourceStream(manifestResourceName);
45.                                                          return new EmbeddedVirtualFile(virtualPath, stream);
46.                                          }
47.                                          else
48.                                                          return _previous.GetFile(virtualPath);
49.                          }
50.                          private bool IsEmbeddedPath(string path)
51.                          {
52.                                          return path.Contains("~/Test/Embedded");
53.                          }
54.          }
55.
56.          public class EmbeddedVirtualFile : VirtualFile
57.          {
58.                          private Stream _stream;
59.                          public EmbeddedVirtualFile(string virtualPath, Stream stream)
60.                          : base(virtualPath)
61.                          {
62.                                          _stream = stream;
63.                          }
64.                          public override Stream Open()
65.                          {
66.                                          return _stream;
67.                          }
68.          }

EmbeddedVirtualPathProvider class is self explanatory. It simply maps a bundling url(used above) and return the embedded request as stream. Note, this class will be invoked by ASP.NET optimization framework during bundling and minifying process. Now, just build your component/control/helper assembly. Then, create a sample ASP.NET(MVC) application and then use this component/control/helper in your page. For example, like,

1.@using Test.Helpers
[email protected]("New")

E-commerce is a very progressive sector today. Companies have come to understood that the internet is the next big thing for selling and are concentrating hugely on building their e-commerce brand. Several e-commerce softwares are already popular with users such as Joomla, Zencart and Magento but one e-commerce platform that is fast building its reputation is nopCommerce.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

nopCommerce is ASP. NET 4.0 based open source e-commerce solution and it’s fast emerging as the preferred choice of e-commerce solution among web developers. This isn’t a mere coincidence and there are several reasons why nopCommerce is stealing a march over more established giants. In this reason, I will explain why nopCommerce is slowly emerging as the leader of the pack in the e-commerce sector.

The first reason why web developers have come to love nopCommerce is its ease of installation. Setup is extremely quick and the software is up and running within minutes. The software comes free and can be downloaded from the internet. It has mobile device support and one can add unlimited amount of products into the software. It supports both categories and manufacturers and any number of subcategories can be added.

A single product can be mapped onto multiple categories and this is great because often certain products tend to fall under 2 or more categories. It provides for anonymous checkout which is great for people who don’t wish to divulge their personal information and the checkout also comprises of just one single page which ensures that visitors aren’t heckled that in turn lead to greater conversions. It offers both multilingual and multicurrency support both of which are extremely cool add ons especially if you are looking to build a global e-commerce brand.

Real time currency exchange rates also ensure that consumers know exactly how much they are paying for in their own currency. The database can also be exported or import in an XML or Excel which at times can be really useful. PDF order receipts, live chat integration and W3C compliance, Open ID, Facebook and Twitter authentication are yet other powerful features that this e-commerce platform provides.

As far as navigation is concerned, it has a very good breadcrumb structure and you can also define your products better with the product tags and product attribute features. Your site is thus made SEO friendly making it more appealing to search engines to crawl and index. It also the product feed feature which automatically uploads new products into product search engines such as Google’s Froogle, Yahoo shopping, etc

The company has stayed true to its consumers and every new update is being made with even better customizations. nopCommerce is a platform here to stay and if you are keen in building your e-commerce website, then this a platform that you should definitely explore.

The performance of your web application has a great impact on the end user experience. If your web application is slow, obviously users are going to be turned away from using it. There are many factors that contribute to the performance of a web site. A couple of important ones are - the number of requests sent from the browser to the server and the response size of each request. The newly added optimization features of ASP.NET 4.5 provide a neat way to bundle and minify JavaScript and CSS files thus taking care of the issues mentioned earlier. This article shows how these bundling and minification features of ASP.NET can be utilized in your web application.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

What is Bundling and Minification

Consider an ASP.NET MVC web application that consists of a view named Index.aspx and makes use of the following JavaScript files:

• jquery-1.6.2.js
• jquery-ui-1.8.11.js
• modernizr-2.0.6-development-only.js

By default these files are located in the Scripts folder and you refer them in your views as follows:

1. <script src="../../Scripts/jquery-1.6.2.js"></script>
2. <script src="../../Scripts/jquery-ui-1.8.11.js"></script>
3. <script src="../../Scripts/modernizr-2.0.6-development-only.js"></script>

Now, when the view is loaded in the browser, the browser makes three independent requests to the respective files. If you observe the requests using Chrome Developer Tools you will see something like this:

Notice a couple of things:

• The browser has sent three separate requests to respective .js files.
• The total response size will be the sum of the file sizes of the individual files.

Also, notice the time taken to download these files.

The overall performance of the view can be improved if you bundle all three requests as a single request. This way instead of making three separate requests the browser will send a single request and still download the content of all three files. Performance will be further improved if you minimize the size of each file being downloaded by minification techniques such as removing white spaces and comments.

Default Bundling and Minification

Luckily, ASP.NET 4.5 provides inbuilt support for bundling and minification of files. The core functionality of bundling and minification is found in System.Web.Optimization namespace. If you create a new ASP.NET project you will find the following line of code in the Global.aspx file:

1. protected void Application_Start()
2. {
3. ...
4. BundleTable.Bundles.RegisterTemplateBundles();
5. }

As you can see, the Application_Start event handler contains a call to the RegisterTemplateBundles() method that does the default bundling and minification for you. For default bundling and minification to work you need to specify the URLs of the JavaScript and CSS files a bit differently.

1. <script src="../../Scripts/js"></script>

Notice the above <script> tag carefully. Instead of specifying a <script> tag per file there is only one <script> tag and the src attribute is of the form <script_folder_path>/js. This naming convention tells ASP.NET that all the *.js files from the Scripts folder are to be bundled together and minified. If you observe the request in Chrome Developer Tools you will find just a single entry for JavaScript files like this:

Notice the size of the downloaded content and compare it with the combined size of individual files.

For CSS files you would have used <css_folder_path>/css in the <link> tag.

1. <link rel="stylesheet" type="text/css" href="../../Content/css" />

Though the syntax shown above works as expected, there is a small drawback. Let's say you refer JavaScript and CSS files in your views using the above syntax and your web application starts serving the requests. Sometime later you update some of these JavaScript and CSS files. Naturally, you expect the new script and styles to come into effect. However, the earlier files might have been cached by the browser or proxy server. Since the URL to the files is the same (src="../../Scripts/js" and href="../../Content/css") there is no way for the browser to detect whether the files have been changed or not. To rectify the problem it is advisable to use the following syntax :

1. <script src="<%= BundleTable.Bundles.ResolveBundleUrl("~/Scripts/js") %>"></script>
2. <script src="<%= BundleTable.Bundles.ResolveBundleUrl("~/Content/css") %>"></script>

The ResolveBundleUrl() method accepts the virtual path of the folder containing the script or CSS files. The ResolveBundleUrl() method not only generates a URL for src and href attributes but also appends a unique string token in the query string. This token is changed when a file changes, thus ensuring a unique URL for the changed files. The following figure shows how the string token is added in the query string:

Customizing Bundling and Minification

At times the default bundling mechanism may not meet your requirements. For example, you might have ten JavaScript files in a folder but depending on the usage pattern you may want to bundle them in two separate bundles of five files each rather than a single bundle. Also, you may want to bundle the files in a specific sequence based on their dependencies. Such a customization is possible through Bundle class. The following code added to the Application_Start event handler shows how the Bundle class can be used:

1. protected void Application_Start()
2. {
3. ...
4. var bundle = new Bundle("~/MyScripts");
5. bundle.AddFile("~/Scripts/jquery-1.6.2.js");
6. bundle.AddFile("~/Scripts/jquery-ui-1.8.11.js");
7. bundle.AddFile("~/Scripts/modernizr-2.0.6-development-only.js");
8. BundleTable.Bundles.Add(bundle);
9. ...
10. }

The above code creates a new bundle for virtual path ~/MyScripts. It then calls the AddFile() method to add specific script files. Finally, the newly created bundle is added to the Bundles collection. To refer the newly created bundle in views you will use the following syntax:

1. <script
2. src="<%= BundleTable.Bundles.ResolveBundleUrl("~/MyScripts")
3. %>"></script>

In addition to creating a custom bundle as shown above you can also customize the overall bundling and minification process. To do so, you need to create a custom class that implements the IBundleTransform interface. You then need to implement the Process() method of the IBundleTransform interface and write a custom processing logic. The following code shows a simple implementation of the IBundleTransform interface that adds a copyright notice to the bundled content.

1. public class MyBundleTransform:IBundleTransform
2. {
3. public void Process(BundleContext context, BundleResponse response)
4. {
5. StringBuilder sb = new StringBuilder();
6. sb.AppendLine("// Copyright (C) 2012. All rights reserved.");
7. sb.Append(response.Content);
8. response.Content = sb.ToString();
9. }
10. }

The above code creates the  MyBundleTransform class, which implements the IBundleTransform interface. The Process() method receives two parameters viz. a BundleContext and BundleResponse. The Process() method then adds a copyright notice at the top of the bundled content and then reassigns the Content property. You can also get ahold of the individual files of a bundle using the response.Files property.

To use the MyBundleTransform class you modify the Application_Start event handler as follows:

1. protected void Application_Start()
2. {
3. ...
4. var bundle = new Bundle("~/MyScripts", new MyBundleTransform()); bundle.AddFile("~/Scripts/jquery-1.6.2.js");
5. bundle.AddFile("~/Scripts/jquery-ui-1.8.11.js");
6. bundle.AddFile("~/Scripts/modernizr-2.0.6-development-only.js");
7. BundleTable.Bundles.Add(bundle);
8. ...
9. }

As you can see a new bundle has been created as before but this time an instance of the MyBundleTransform class is passed as the second parameter of the constructor. If you observe the resultant script in the Chrome Developer Tools, you will find the copyright line added at the top:

Summary

The newly added bundling and minification features of ASP.NET 4.5 make it easy to bundle your JavaScript and CSS files thus boosting the overall performance of your web applications. In order to avail the bundling and minification features you need to specify URLs to script and CSS files in a certain way. Following this naming convention automatically bundles all of the JavaScript and CSS files from a folder and serves them as a single request. You can also customize the bundling process using the Bundle class and IBundleTransform interface.

Web Forms in 4.5 allows you to build dynamic web sites quickly and easily. Web Forms generates much cleaner code on client-side with Unobtrusive Validation in this version. You can also build data-centric applications easily with data-binding features.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

Typical Web Form which contains more fields and validation controls can generate more code on client-side. When you run this typical form in browser then you can see the page size as below

The reason for this size is because client-side validation is enabled. If you change Unobtrusive validation mode in page load to web forms then you can see the difference.

Now re-compile your application and run the page the result is as shown below, Now page size is much smaller than before

Strongly typed Data Controls

Take a typical Search Form which shows the results in list view. Inside list view you have item template which is having multiple calls to the EVAL expression as shown below

The above method is the standard way of doing data-binding in web forms. You optimize the above using strongly typed data controls.

You can set the Item Type property of List View to the type that you actually data-binding to as shown below

Now you can member variables in place of Eval expressions, member variables are now typed and you will get an intellisense on item class.

Model Binding

You may be familiar with Model Binding in ASP.NET MVC, The typical code which you might write in web forms to bind the results in web forms as below

The above code talking to the data base by building a query which does a case insensitive search then it coverts into list binds the results to list view. Let us re-write the above code using Model-Binding

Now there is no page load and click-handler, The above code is not directly interacting with the page. You can populate the formTerm and qsTerm variables using attributes Control and QueryString in model-binding.

The return result of GetResults method is IQueryable. Because the result is of type IQueryable the control has the ability to modify this before it is rendering it to the page. You can use this in sorting and paging. You can specify the same in markup.

Advantage of using Model Binding As the code is not directly interacting with the page, you can fairly easily unit test the method or even move it to the completely different class.

Support for OpenID in OAuth Logins

The AuthConfig.cs file is standard in all new projects that created in ASP.NET 4.5 in Visual Studio 2012. You can see there are number of external services code is commented out and it is ready to use by putting your custom application credentials.

Now you can use external services to login to the application.

These are the features which you can try out in Visual Studio 2012.

This tutorial does not require Visual Studio and does not need any type of recompile of the nopCommerce code. You can do everything in this tutorial with notepad and access to the file system nopCommerce is installed in (FTP, network, SCP, etc).

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

This tutorial applies to:

nopCommerce 2.0, nopCommerce 2.1, nopCommerce 2.2, nopCommerce 2.3

To get started you are going to copy one of the pre-existing themes and use it as the base of your new theme. So go to the root of your nopCommerce store and drill down to the theme section.

[root]/NopCommerceStore/Themes/

Step 1 – Copy the Directory

Here you should see a couple of themes, which themes exactly depend on the version of nopCommerce you are using. I recommend selecting “NopClassic” or “darkOrange”, and copy either one in the theme directory as a copy. Then rename that directory.

Step 2 – Edit “theme.config”

Update “theme.config” (\Themes\YourThemeName\theme.config) and update the title, the rest of the XML doesn’t impact the display of the theme. This just effects the title on the theme drop down in the admin section. If you leave it the same you will not able to tell which theme is which. So the file should now look something like this after you have edited it.

Step 3 – Edit “head.cshtml”

Now updated the “head.cshtml” file (\Themes\YourThemeName\Views\Shared\Head.cshtml). This is the real gotcha for me, missing this step will make your new theme directory appear as if it is stuck using the theme you copied it from. Change both of the “link href” values to reflect the directory of your new theme. In my case it looked like this.

Step 4 – Select Theme in nopCommerce Admin

Once you have completed this step update the nopCommerce Admin to reflect the fact that you wish to use your new theme. If you don’t see your theme listed, restart IIS. NopCommerce has its own internal caching algorithium and it can take some time to notice an updated to the backend like this one.

Any changes you want to make to your copied theme can now be done. The important directories and files for the designers in the audience are…

Main CSS File

[root]/NopCommerceStore/Themes/YourThemeName/Content/styles.css

Images and Media

[root]/NopCommerceStore/Themes/YourThemeName/Content/images

DotNetNuke 7 provides support for active directory authentication and includes a SharePoint connector which enables fast and secure publishing of SharePoint documents to websites, intranets and extranets. It also includes a brand new intuitive control panel and now provides support for SharePoint Lists.

The DotNetNuke 7 professional and enterprise editions now ships with an auto save feature which provides the ability to automatically save the content in the background. This will enable users to recover the content in the event of a browser crash.

DotNetNuke 7 includes drag and drop modules, cross site module sharing, actions menu instead of manage button as in previous version, a new data access layer named DAL2 which includes micro-ORM and support for ASP.NET Razor in addition to a brand new simplified installer.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

The difference can DotNetNuke 7 make in the development of websites

There are a number of features that differentiate DotNetNuke 7.0 for website development which ultimately enable a broad range of users to be more productive:

Web content editors

A rich text editor with a new auto-save and recover feature prevents editors from losing their work. It also enables them to easily track content changes and compare versions of both rich text and HTML content. DNN 7.0 allows modules to be shared between multiple DotNetNuke websites for greater consistency and ease of maintenance.

Enterprises

DNN 7.0 makes it easier for enterprise users to log in to their DotNetNuke sites with new support for Active Directory authentication. It also now enables bi-directional support for popular Microsoft SharePoint Lists, which are used widely by businesses to improve operations, promote team project collaborations, keep employees up to date on current business projects and tasks, manage employees more effectively, and improve business productivity.

Developers

Web developers can build and expose secure web services through the DNN Services Framework, which is now based on Microsoft’s web API. Data access has been simplified through the introduction of a micro-ORM, allowing simpler and more elegant database interactions with less code.

ASP.NET Razor is now optimized for developing dynamic extensions, combining code and content in a fluid and expressive manner. The included jQuery, jQueryUI and Knockout.js libraries make it even easier for developers to consume Web services and create modern, interactive client-side applications.

The newest release has graduated to ASP.NET 4.0 as its baseline platform requirement but is also fully compatible with latest generation Microsoft technology including Windows 8, Windows Server 2012, IIS8, ASP.NET 4.5, Visual Studio 2012 and SQL Server 2012.

Designers

An overhauled Cascading Style Sheets (CSS) foundation makes it easier for designers to create beautiful and engaging websites, enabling improved cross-browser compatibility, extending standards compliance and increasing site performance. Additionally, DNN 7.0 includes standard form patterns that designers can reuse or extend to build frequently used user interface elements.

The DNN 7 different from previous versions

DotNetNuke 7.0 provides a revamped UI/UX that makes it easier for content editors to build and manage websites. It also provides a suite of new features that improve productivity through a drag and drop and an updated rich text editor that includes auto-save and version comparison features.

It  improves enterprise integration with an active directory authentication provider and by adding support for SharePoint List to our SharePoint Connector. This latest version provides our most advanced development framework with a web serves framework built on Microsoft's Web API.

The opportunity that DotNetNuke provide to ASP.NET developers

DotNetNuke provides a robust and powerful web development framework for ASP.NET developers. DNN7 provide support for the most recent versions of ASP.NET, and enable developers to embrace both Web Forms and WebAPI development methods.

The development framework greatly reduces the amount of code required to build applications by providing support for tasks like Security, Authentication, Installation and Upgrades. Developers can also distribute applications commercially on the DotNetNuke store where thousands of modules and skins are for sale.

The different of DotNetNuke with open source platforms like DotNetBlogEngine, Joomla and WordPress

DotNetNuke (DNN) is the most widely deployed content management platform and web development framework for Microsoft .NET. Organizations that have standardized on Microsoft technologies and have Microsoft development skills often prefer DNN over open source CMS offerings like Joomla and Wordpress which are built on the LAMP technology stack. These organizations also need a full featured Web CMS that provides features beyond blogging.

Can DotNetNuke run on MySQL backend?

DNN support Microsoft SQL Server out of the box. Third party providers for other databases are available and developers can create their own providers.

New versions of Visual Studio usually coincide with updates to the .NET Framework, and this continues with the release of .NET 4.5 (.NET Framework 4.5). Here’s a quick review of what Visual Studio 2012 and .NET 4.5.

.NET Framework 4.5

The .NET Framework has exploded to include so many technologies (WCF, WPF, ASP.NET, etc.), features, and options. With .NET 4.5, there have been many updates to the core languages, with the asynchronous programming receiving lots of coverage.

If you plan to build Windows 8 applications, then you want .NET 4.5, because it has a subset called .NET for Windows Store. Building Windows 8 applications means you will be using HTML5 and CSS3, which are embraced by ASP.NET 4.5 and Visual Studio 2012. Web Sockets support has been added, as well as the ability to bundle JavaScript libraries/code and minimize the size of its download. ASP.NET Web Pages 2 provides more features for building pages on the fly, and improvements have been made to Web Forms and MVC. These features and more can be used to build powerful applications via the Visual Studio 2012 IDE. However, you can still target any version of the framework — that’s right, you are not forced to upgrade to .NET 4.5.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

The IDE

Figure A shows the welcome screen of Visual Studio Ultimate 2012 installation. Microsoft stated performance improvements are a key goal of Visual Studio 2012; this includes reducing the clutter of the developer’s workspace, which theoretically allows them to better focus on their work. The IDE now loads solutions asynchronously with key parts loaded first. Visual Studio 2012 does start up faster than Visual Studio 2010, but I’m not sure Microsoft succeeded in its goal to reduce clutter. The IDE opens with fewer windows like errors, classes, server explorer, and so forth, but these can easily be opened via the View menu, which was an option in previous versions of Visual Studio. There are indeed useful features that are designed to make things like previewing files without opening them easier.

Figure A

The Visual Studio Ultimate 2012 welcome page

Another interesting feature of Visual Studio 2012 is the inclusion of LightSwitch, Silverlight, and Expression Blend. The first two are project types within the IDE as shown in Figure B (among the many other project options). Expression Blend is installed as a separate application in the Visual Studio 2012 directory, but it is available only for Windows Store app development on Windows 8.

Figure B

Options for creating a new Web application in Visual Studio 2012

Figure C shows an ASP.NET Web Pages project opened in Visual Studio 2012. It is not a major shift from Visual Studio 2010, but you may notice the browser and DocType options just below the main menu. For this project, Google Chrome is selected as the target browser, but this drop-down list is populated with the browsers installed on the development machine so you can test with a variety of browsers. The DocType allows you to choose the target standard; HTML5 is the default for new projects, but you can target others depending on the project. In the IDE, you might also notice the menu options along the top — Website, Build, Debug, Team, SQL, Tools, and more; these options may change depending on the version of Visual Studio installed, but they do give a glimpse of the many things you can do within Visual Studio 2012.

Figure C

Working with an ASP.NET Web Pages 2 project within Visual Studio 2012

Integration with other Microsoft products

A key aspect of developing with Microsoft technologies is the tight integration with other Microsoft products. Visual Studio 2012 simplifies this by providing the environment to build applications that use these products. The following list provides a sampling of the possibilities:

PowerPoint: Use PowerPoint to begin the development process according to Agile methods with storyboarding (Microsoft has wholeheartedly embraced Agile). PowerPoint Storyboarding is a selection in the Visual Studio 2012 installation folder. In addition to PowerPoint, the complete Microsoft Office suite is available programmatically to use as needed in your code.

- Windows 8: Build applications for the new version of Windows.
- Windows Phone: Visual Studio 2012 allows you to target multiple platforms such as Windows Phone.
- SharePoint: Visual Studio 2012 allows you to build and test SharePoint applications.
- Team Foundation Server (TFS) 2012: Large scale projects require teamwork and source code control, both of which are readily provided in TFS 2012, which seamlessly integrates with Visual Studio 2012.
- System Center 2012: This can be used with TFS 2012 to automate the identification of production errors/bugs and to create tasks to fix these issues.

Visual Studio LightSwitch is Microsoft's flexible development tool used for building business applications. Visual Studio LightSwitch is a new member of the Visual Studio family. It is a stand alone application. According to Microsoft, Visual Studio LightSwitch is "the simplest way to create business applications for the desktop or the cloud". Visual Studio LightSwitch is a rapid application development (RAD) tool which is used to help write data-centric line of business (LOB) applications.

About ASPHostPortal.com

ASPHostPortal.com is Microsoft No #1 Recommended Windows and ASP.NET Spotlight Hosting Partner in United States. Microsoft presents this award to ASPHostPortal.com for ability to support the latest Microsoft and ASP.NET technology, such as: WebMatrix, WebDeploy, Visual Studio 2012, ASP.NET 4.5, ASP.NET MVC 4.0, Silverlight 5 and Visual Studio Lightswitch. Click here for more information

Feature Of LightSwitch

There are many features of LightSwitch. Visual Studio LightSwitch supports Windows Azure, SQL Azure, automatic data input validation etc. You can use the Visual Basic or Visual C# language in your LightSwitch application. The feature table of Lightswitch is shown below.

Benefits Of LightSwitch

There are many benefits of LightSwitch. The main benefits of LightSwitch are as follows:

• Simplify development
• Build a better application faster
• Customize using extensions
• Quickly add user-friendly features
• Speed Deployment and Updates
• Create a custom application for the way you do business
• Build business applications like they were created by a professional designer
• Easily add powerful authentication features
• Evolve your application as business needs change

Simplify development

The nonrational Visual Studio LightSwitch 2011 development environment simplifies the development implementation and provides assistance when you need it. Lightswitch allows users to create applications with a modern multi-tier design that support both cloud and desktop clients, but with less coding, though you can add Visual Basic or C# code.

Build a better application faster

Visual Studio LightSwitch 2011 includes many screens for the most common types of business applications. It also contains predefined data types like date, datetime, phone numbers and e-mail addresses etc.

Customize using extensions

Using custom extensions like Picture and Text layout extensions you can present your data on screen. Custom extensions like  Money and Phone Number are also included in LightSwitch. Using the custom extensions you can change the appearance and behavior of your application.

Quickly add user-friendly features

Visual Studio LightSwitch 2011 have a user friendly feature i.e. export data to Ms-Office Excel for easy sharing and reporting. You can also create a table in Lightswitch from from SQL Server.

Speed Deployment and Updates

Using Visual Studio LightSwitch 2011, you can create one application that can be deployed to desktop clients and web clients. You can choose the best deployment method for deploy the LightSwitch application.

Create a custom application for the way you do business

Using Visual Studio LightSwitch you can create custom business application. In the Visual Studio LightSwitch you can apply custom validation or custom rules.

Build business applications like they were created by a professional designer

Visual Studio LightSwitch 2011 comes with an extensible set of pre-built Application Shells that can give your application the familiar feel of popular Microsoft software.

Easily add powerful authentication features

Visual Studio LightSwitch has an authentication feature. This feature is the most powerful feature of LightSwitch. The Authentication feature provides security to your LightSwitch application. In the Visual Studio LightSwitch you can generate many users with their authorization. Using the authentication feature of LightSwitch you can set user roles and permissions.

Evolve your application as business needs change

The pre-built screens and components in Visual Studio LightSwitch are fully extensible, so using additional features for your application is fast and easy.

Summary

So Visual Studio LightSwitch has many features and benefits. Visual Studio LightSwitch is used to build business applications.