http://www.example.com/ExampleSite/ExampleFile

The issue arises because URL rewriting is not enabled by default for IIS 7 or IIS 7.5. The likeliest scenario is that you do not see the problem when testing locally . . . → Read More: ASP.NET MVC 3 Hosting :: Extensionless URLs do not find .cshtml/.vbhtml files on IIS 7 or IIS 7.5]]> On IIS 7 or IIS 7.5, requests with a URL like the following are not able to find pages that have the .cshtml or .vbhtml extension:

http://www.example.com/ExampleSite/ExampleFile

The issue arises because URL rewriting is not enabled by default for IIS 7 or IIS 7.5. The likeliest scenario is that you do not see the problem when testing locally using IIS Express, but you experience it when you deploy your website to a hosting website.

Workaround

• If you have control over the server computer, on the server computer install the update that is described in A update is available that enables certain IIS 7.0 or IIS 7.5 handlers to handle requests whose URLs do not end with a period.
• If you do not have control over the server computer (for example, you are deploying to a hosting website), add the following to the website’s Web.config file:

<system.webServer>
 <modules runAllManagedModulesForAllRequests="true"/>
</system.webServer>

The Google support page for configuring a mail client gives us a good starting . . . → Read More: ASP.NET Hosting :: How to Send Email in ASP.NET with GMail SMTP Server]]> Sending email via SMTP in ASP.NET is a really painless experience.  However, there are a couple of hoops to jump through if you want to use Google’s GMail SMTP servers.  The following example shows a really simple function to get the job done.

The Google support page for configuring a mail client gives us a good starting point.  We can see that we need to use the host smtp.gmail.com on port 587.  We can also see that we must transmit over a secure connection and that we need to use our GMail username and password to authenticate with the server.

using System.Net.Mail;

public class GMailSMTP
{
    public void Send(string to, string subject, string message, bool isHtml)
    {
            // Create a new message
            var mail = new MailMessage();

            // Set the to and from addresses.
            // The from address must be your GMail account
            mail.From = new MailAddress("example@gmail.com");
            mail.To.Add(new MailAddress(to));

            // Create a new Smpt Client using Google's servers
            var mailclient = new SmtpClient();
            mailclient.Host = "smtp.gmail.com";
            mailclient.Port = 587;

            // Specify your authentication details
            mailclient.Credentials = new System.Net.NetworkCredential(
                                             "YOUR GMAIL USERNAME",
                                             "YOUR GMAIL PASSWORD");
            mailclient.Send(mail);
    }
}

These are highlighted below

Steps:

1. Open the Perfmon [ Start > Run > . . . → Read More: ASP.NET 4 Hosting :: Monitor ASP.NET Performance Using Perfmon Tool]]> For Any ASP.NET application, monitoring performance is an important job. Performance Monitor tool having some nice features that helps us to monitor ASP.NET Application performance in a better way.In this Tips I  discuss four important counter sets that are very useful in monitoring ASP.NET performance.

These are highlighted below

Steps:

1. Open the Perfmon [ Start > Run > Perfmon ].

2. Add the Counters. Specify local or remote computer.

3. The four types of sets are

• W3SVC_W3WP: Exposes HTTP request processing related counters for the worker process as displayed below

• WAS_W3WP:  Exposes Windows Process Activation Service (WAS) related counters for the worker process as displayed below

• Web Service: Includes counters specific to the World Wide Web Publishing Service as displayed below

• Web Service Cache: Includes cache counters specific to the World Wide Web Publishing Service as displayed below

Web host providers in Europe can offer all the amenities that any host in an industrialized country can offer. Web site customers can find budget, dedicated, shared, reseller, and shared hosting. Applications include all the latest languages, frameworks, and capabilities that a consumer could find at a Web host in the U.S. Domain name . . . → Read More: Cheap Europe Web Hosting Provider]]> What is it?

Web host providers in Europe can offer all the amenities that any host in an industrialized country can offer. Web site customers can find budget, dedicated, shared, reseller, and shared hosting. Applications include all the latest languages, frameworks, and capabilities that a consumer could find at a Web host in the U.S. Domain name registration also is conducted throughout Europe. Top level domains are used for different countries (such as ‘.de’ for Germany), but consumers can find an purchase a registration for any top level domain through domain registrars or hosting companies throughout Europe.

What Are the Issues?

European Web hosts vary from country to country for services and for pricing. Depending upon the country and whether they take the country currency or Euros, the prices can vary widely. Currently, there seems little point in comparing Web hosting in Euros to the price of Web hosting in American dollars, due to the dollar value. However, a test of prices on Web hosting from various countries to American sites shows that the cost of hosting in the U.S. remains less expensive for the services offered.

Domain name registration can vary from country to country as well. Many registrars will offer all domain names, and others offer European top level domains only. Annual registration for domain names remains more expensive in Europe than it does in the U.S., and some domain names require a special set up fee depending upon the hosting service.

Where to go for European Web Hosting?

HostForLife.eu is awarded a SPOTLIGHT status on Microsoft ASP.NET website (http://www.microsoft.com/web/hosting/home) for offering the best, most affordable and features-rich ASP.NET Hosting in European Continent. Our service is ranked the highest top #1 spot in several European countries, such as: Germany, Italy, Netherlands, France, Belgium, United Kingdom, Sweden, Finland, Switzerland and many top European countries.

We are selected by Microsoft website due to the fact that we have passed several verification and validation process. A “Spotlight” status indicates offers that utilize the latest Microsoft technology, deliver 99.9% uptime, and provide 24/7 support. All offers must pre-install and pre-configure SQL Server 2008, ASP.NET 4.0, MVC 2.0, URL Rewrite, IIS Remote Management, and Web Deploy. We have also successfully completed a Web Matrix publishing test.

The following are the features of our STARTER PLAN with SPOTLIGHT status:

- Unlimited Disk Space
- Unlimited Domains
- Unlimited Bandwidth
- Support ASP.NET 4.0, ASP.NET MVC 3.0, URL Rewrite, Silverlight 4
- Support SQL Server 2008 R2 and mySQL database
- Support WebDeploy and Remote IIS Manager Access
- Price: from €3.00/month
- To register, please proceed directly to https://secure.hostforlife.eu

1. First of all we created a table in LightSwitch application.

2. Run the application.

3. Double click one customer and write an email without domain (which shows an error.) likes below image.

4. Change the  length of state (no error)->cut->ok.

5. Come back to the customer page like below image.

6. Now go . . . → Read More: Visual Studio LightSwitch Hosting :: Format Data on a Screen in a LightSwitch Application]]>

This is the steps you need to follow:

1. First of all we created a table in LightSwitch application.

2. Run the application.

3. Double click one customer and write an email without domain (which shows an error.) likes below image.

4. Change the  length of state (no error)->cut->ok.

5. Come back to the customer page like below image.

6. Now go to phone properties->change maximum length(255 replace by 25)-> then go to email properties set default domain (gmail.com) ->then go to postal code properties change maximum length(255 replace by 10)-> then go to state properties change maximum length(255 replace by 2) and click custom validation (.cs page will be open) then write coding.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.LightSwitch;
namespace LightSwitchApplication
{
    public partial class Customer
    {
        partial void State_Validate(EntityValidationResultsBuilder results)
        {
            // results.AddPropertyError("<Error-Message>");
            if (!string.IsNullOrEmpty(this.State))
            {
                this.State = this.State.ToUpper();
            }
        }
    }
}

Code Description: This code converts the lowercase letter in to uppercase letter of state name.

7. Add a new property gender->then go to properties of gender ->then click choice list and add value and display name ->ok  likes below image.

8. Go to computed property->add name (Full Name)->properties->click edit method then write code.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.LightSwitch;
namespace LightSwitchApplication
{
    public partial class Customer
    {
            partial void FullName_Compute(ref string result)
        {
            // Set result to the desired field value
            result = this.LastName + " " + this.FirstName;
        }
    }
}

Code Description: This code print the full name of customer. 

9. Save->go to customer property->choose summary property->full name looks likes below image.

10. Run the  application->open the first customer ->shows full name likes blow image

11. Click design screen and add Full Name like the below image.

12. Go to Last Name properties->uncheck show as a link->Go to Full Name properties->check show as a link->save->open any customer->change status (maximum length will be 2) and postal code (maximum length will be 10)->design screen->yes (likes below image).

13. Add gender in the customer->save likes below image.

14. Now we can choose Male or Female from gender likes below image.

15. Save. Now we can write an email without domain name then there will be no error.

If we write state name which length is more than 2, then there will be an error like in the below image.

If we write postal code which length is more  than 10, then there will be an error like below

Cookies are also known by many names, HTTP Cookie, Web Cookie, Browser Cookie, Session Cookie, etc. Cookies are one of several ways to store data about web site visitors during the time when web server and browser are not connected. Common use of cookies is to remember users between visits. Practically, cookie is a small text . . . → Read More: ASP.NET Hosting :: Working with ASP.NET Cookies]]> Introduction

Cookies are also known by many names, HTTP Cookie, Web Cookie, Browser Cookie, Session Cookie, etc. Cookies are one of several ways to store data about web site visitors during the time when web server and browser are not connected. Common use of cookies is to remember users between visits. Practically, cookie is a small text file sent by web server and saved by web browser on client machine.

Use of Cookies?

Cookies may be used for authentication, identification of a user session, user’s preferences, shopping cart contents, or anything else that can be accomplished through storing text data. Cookies can also be used for travelling of data from one page to another.

Is Cookies Secured?

Well, this question has no specific answers in YES or NO. Cookies could be stolen by hackers to gain access to a victim’s web account. Even cookies are not software and they cannot be programmed like normal executable applications. Cookies cannot carry viruses and cannot install malware on the host computer. However, they can be used by spyware to track user’s browsing activities.

Using Cookies

Creating/Writing Cookies

There are many ways to create cookies, I am going to outline some of them below:

Way 1 (by using HttpCookies class)
//First Way
HttpCookie StudentCookies = new HttpCookie(“StudentCookies”);
StudentCookies.Value = TextBox1.Text;
StudentCookies.Expires = DateTime.Now.AddHours(1);
Response.Cookies.Add(StudentCookies);

Way 2 (by using Response directly)
//Second Way
Response.Cookies["StudentCookies"].Value = TextBox1.Text;
Response.Cookies["StudentCookies"].Expires = DateTime.Now.AddDays(1);

Way 3 (multiple values in same cookie)
//Writing Multiple values in single cookie
Response.Cookies["StudentCookies"]["RollNumber"] = TextBox1.Text;
Response.Cookies["StudentCookies"]["FirstName"] = “Abhimanyu”;
Response.Cookies["StudentCookies"]["MiddleName"] = “Kumar”;
Response.Cookies["StudentCookies"]["LastName"] = “Vatsa”;
Response.Cookies["StudentCookies"]["TotalMarks"] = “499″;
Response.Cookies["StudentCookies"].Expires = DateTime.Now.AddDays(1);

Reading/Getting Cookies

In the above code, I have used many ways to write or create cookies so I need to write here using all the above ways separately.

For Way 1
string roll = Request.Cookies["StudentCookies"].Value; //For First Way

For Way 2
string roll = Request.Cookies["StudentCookies"].Value;  //For Second Way

For Way 3
//For Multiple values in single cookie
string roll;
roll = Request.Cookies["StudentCookies"]["RollNumber"];
roll = roll + ” ” + Request.Cookies["StudentCookies"]["FirstName"];
roll = roll + ” ” + Request.Cookies["StudentCookies"]["MiddleName"];
roll = roll + ” ” + Request.Cookies["StudentCookies"]["LastName"];
roll = roll + ” ” + Request.Cookies["StudentCookies"]["TotalMarks"];
Label1.Text = roll;

Deleting Cookies

In the above code, I have used many ways to create or read cookies. Now look at the code given below which will delete cookies.

if (Request.Cookies["StudentCookies"] != null)
{
    Response.Cookies["StudentCookies"].Expires = DateTime.Now.AddDays(-1);    Response.Redirect(“Result.aspx”);  //to refresh the page
}

Understanding HttpCookie Class It contains a collection of all cookie values.

We do not need to use any extra namespaces for HttpCookies class (we already have used this in Way 1 above), because this class is derived from System.Web namespaces. HttpCookies class lets us work with cookies without using Response and Request objects (we have already used this in Way 2 and Way 3 above).

HttpCookie class has a list of some properties, let us outline them.

    * Domain: It contains the domain of the cookie.
    * Expires: It contains the expiration time of the cookie.
    * HasKeys: It contains True if the cookie has subkeys.
    * Name: It contains the name of the cookie.
    * Path: It contains the virtual path to submit with the cookie.
    * Secure: It contains True if the cookie is to be passed in a secure connection only.
    * Value: It contains the value of the cookie.
    * Values:

Limitations of Cookies

There are following limitations for cookies:
   1. Size of cookies is limited to 4096 bytes.
   2. Total 20 cookies can be used on a single website; if you exceed this browser will delete older cookies.
   3. End user can stop accepting cookies by browsers, so it is recommended to check the users’ state and prompt the user to enable cookies.

Sometimes, the end user disables the cookies on browser and sometimes browser has no such feature to accept cookies. In such cases, you need to check the users’ browser at the home page of website and display the appropriate message or redirect on appropriate page having such message to enable it first. The following code will check whether the users’ browser supports cookies or not. It will also detect if it is disabled too.

protected void Page_Load(object sender, EventArgs e)
{
    if (Request.Browser.Cookies)
    {
        //supports the cookies
    }
    else
    {
        //not supports the cookies
        //redirect user on specific page
        //for this or show messages
    }
}

It is always recommended not to store sensitive information in cookies

I decided to see if I could create an HTML Helper that takes a collection of model objects and renders a table. I spent some time looking at how Telerik implements their GridBuilder using Telerik JustDecompile (Telerik’s FREE decompiler) and got . . . → Read More: ASP.NET MVC 3 Hosting :: Creating a Custom HTML Helper to Render List of Models as a Table]]> I write this article based on the question on stackoverflow, MVC3 HtmlHelpers using Generics and LINQ.

I decided to see if I could create an HTML Helper that takes a collection of model objects and renders a table. I spent some time looking at how Telerik implements their GridBuilder using Telerik JustDecompile (Telerik’s FREE decompiler) and got some ideas of how I could do this. I created an HtmlHelper extension method called TableFor that creates an instance of a TableBuilder class. The TableBuilder class contains an enumerable list of model objects to be rendered as a table and a list of lambda expressions, managed in the TableBuilder class as TableColumn objects, that identify which model properties are rendered in the table. The TableColumn objects get created from the ColumnBuilder class which creates the TableColumn objects and adds them to the TableBuilder class. The TableBuilder.ToHtml method renders the enumerable list of model objects as a table.

In the end, I was able to render a table from an enumerable list of model objects with the following code:

Html.TableFor<MvcRazorApp.Models.Person>()
    .Columns(column =>
    {
        column.Expression(p => p.FirstName).Title("Given Name");
        column.Expression(p => p.LastName);
        column.Expression(p => p.Title);
        column.Expression(p => p.Episodes);
    })
    .DataSource(this.Model)
    .ToHtml()

Creating the TableColumn Class

The table column class contains the information about a column in the table. Each lambda expression that is passed in gets compiled and stored in an instance of a TableColumn class. The constructor also creates the default title for the column using a regular expression to add a space in between lowercase and uppercase letters. So, for example, FirstName becomes First Name. TableColumn has a Title method that allows the title to be set to something other than the default title defined in the constructor. The TableColumn class has an Evaluate method. This method evaluates the compiled lambda expression against an instance of a model and returns the property value. If the property value has not been set, an empty string is returned.

Here is the code:

/// <summary>
/// Represents a column in a table.
/// </summary>
/// <typeparam>Class that is rendered in a table.</typeparam>
/// <typeparam>Class property that is rendered in the column.</typeparam>
public class TableColumn<TModel, TProperty> : ITableColumn,
ITableColumnInternal<TModel> where TModel : class
{
    /// <summary>
    /// Column title to display in the table.
    /// </summary>
    public string ColumnTitle { get; set; }

    /// <summary>
    /// Get the property value from a model object.
    /// </summary>
    /// <param>Model to get the property value from.</param>
    /// <returns>Property value from the model.</returns>
    public string Evaluate(TModel model)
    {
        var result = this.CompiledExpression(model);
        return result == null ? string.Empty : result.ToString();
    }
}

Creating the ITableColumn Interface

The TableColumn class implements the ITableColumn interface. This interface defines the properties and methods used by the developer to configure the TableColumn.

Here is the code:

/// <summary>
/// Properties and methods used by the consumer to configure the TableColumn.
/// </summary>
public interface ItableColumn
{
    ITableColumn Title(string title);
}

Creating the ITableColumnInternal Interface

The TableColumn class also implements the ITableColumnInternal interface. The reason for this is to allow the TableBuilder class to maintain an IList of TableColumn objects. Since the TableBuilder doesn’t know anything about the TProperty type, an error occurs. I therefore created an interface called ITableColumnInternal that only defines the TModel type (since it is used by the Evaluate method).

Here is the code:

/// <summary>
/// Properties and methods used within the TableBuilder class.
/// </summary>
public interface ITableColumnInternal<TModel> where TModel : class
{
    string ColumnTitle { get; set; }
    string Evaluate(TModel model);
}

Creating the TableBuilder Class

The TableBuilder class contains a Columns method that creates an instance of the ColumnBuilder class. The ColumnBuilder class creates instances of the TableColumn class and adds them to the TableBuilder class by calling the TableBuilder.AddColumn method. The DataSource property is the enumerable list of models to be rendered as a table. The TableBuilder.ToHtml method renders the TableBuilder as HTML. I found it easy to simply build the table HTML code using an XmlDocument. I loop through the TableBuilder.TableColumns and render the column headings in the table header. I then loop though the enumerable list of model objects in TableBuilder.Data and for each model, I loop though the TableBuilder.TableColumns and call TableColumn.Evaluate for the model object to get the property value. When I am all done, I return a new instance of MvcHtmlString that contains the XmlDocument.OuterXml.

Here is the code:

/// <summary>
/// Build a table based on an enumerable list of model objects.
/// </summary>
/// <typeparam>Type of model to render in the table.</typeparam>
public class TableBuilder<TModel> : ITableBuilder<TModel> where TModel : class
{
    private HtmlHelper HtmlHelper { get; set; }
    private IEnumerable<TModel> Data { get; set; }

        return new MvcHtmlString(html.OuterXml);
    }
}

Creating the ColumnBuilder Class

The ColumnBuilder class contains a single method called Expression that creates instances of the TableColumn class for the lambda expression passed in and returns an instance of the TableColumn class so that additional properties in the TableColumn class can be set.

Here is the code:

/// <summary>
/// Create instances of TableColumns.
/// </summary>
/// <typeparam>Type of model to render in the table.</typeparam>
public class ColumnBuilder<TModel> where TModel : class
{
    public TableBuilder<TModel> TableBuilder { get; set; }

    /// <summary>
    /// Add lambda expressions to the TableBuilder.
    /// </summary>
    /// <typeparam>Class property that is rendered in the column.</typeparam>
    /// <param>Lambda expression identifying a property to be rendered.</param>
    /// <returns>An instance of TableColumn.</returns>
    public ITableColumn Expression<TProperty>(Expression<Func<TModel, TProperty>> expression)
    {
        return TableBuilder.AddColumn(expression);
    }
}

Creating the ITableBuilder Interface

The TableBuilder class implements the ITableBuilder interface. This interface defines the properties and methods used by the developer to configure the TableBuilder. The TableFor HTML extension method returns an instance of the TableBuilder class as an ITableBuilder interface.

Here is the code:

/// <summary>
/// Properties and methods used by the consumer to configure the TableBuilder.
/// </summary>
public interface ITableBuilder<TModel> where TModel : class
{
    TableBuilder<TModel> DataSource(IEnumerable<TModel> dataSource);
    TableBuilder<TModel> Columns(Action<ColumnBuilder<TModel>> columnBuilder);
}

Creating the TableFor HtmlHelper Extension Method

The TableFor HtmlHelper extension returns an instance of a TableBuilder class an ITableBuilder interface.

Here is the code:

public static class MvcHtmlTableExtensions
{
    /// <summary>
    /// Return an instance of a TableBuilder.
    /// </summary>
    /// <typeparam>Type of model to render in the table.</typeparam>
    /// <returns>Instance of a TableBuilder.</returns>
    public static ITableBuilder<TModel> TableFor<TModel>(this HtmlHelper helper) where TModel : class
    {
        return new TableBuilder<TModel>(helper);
    }
}

Implementing HTML Helper in a View

The Person Model

I created a model class called Person and gave it four properties, FirstName, LastName, Title and Episodes. Here is the code:

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Title { get; set; }
    public int Episodes { get; set; }
}

The Controller

I created a controller and defined a method called TableBuilderSample that creates a list of Person objects and return a ViewResult with the Person list. Here is the code:

public ActionResult TableBuilderSample()
{
    IList<Person> list = new List<Person>();
    list.Add(new Person { FirstName = "William", LastName = "Adama", Title
="Commander", Episodes = 73 });
    list.Add(new Person { FirstName = "Laura", LastName = "Roslin", Title = "President", Episodes = 73 });
    list.Add(new Person { FirstName = "Gaius", LastName = "Baltar", Episodes = 73 });
    list.Add(new Person { FirstName = "Lee", LastName = "Adama", Episodes = 73 });
    list.Add(new Person { FirstName = "Kara", LastName = "Thrace", Episodes = 71 });

    return View(list);
}

The View

I then created a strongly typed view that took an IEnumerable list of Person objects. I implemented my Html.TableFor extension method where I defined the table using the TableBuilder class. Here is the code:

Razor:

@(Html.TableFor<MvcRazorApp.Models.Person>()
    .Columns(column =>
    {
        column.Expression(p => p.FirstName).Title("Given Name");
        column.Expression(p => p.LastName);
        column.Expression(p => p.Title);
        column.Expression(p => p.Episodes);
    })
    .DataSource(this.Model)
    .ToHtml()
)

ASPX:

<%@ Page Title="" Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<IEnumerable<MvcAspxApp.Models.Person>>" %>

<asp:Content ID="Content1" ContentPlaceHolderID="TitleContent" runat="server">
    TableBuilderSample
</asp:Content>

<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">

<h2>TableBuilderSample</h2>

<%=Html.TableFor<MvcAspxApp.Models.Person>()
    .Columns(column =>
    {
        column.Expression(p => p.FirstName).Title("Given Name");
        column.Expression(p => p.LastName);
        column.Expression(p => p.Title);
        column.Expression(p => p.Episodes);
    })
    .DataSource(this.Model)
    .ToHtml()
%>

</asp:Content>

I personally think having a variety of tools is good, especially if they can focus on different verticals, and are optimized for different scenarios/tasks. There is a saying – use the right tool for the job. And the reality is there is a wide spectrum of developers and correspondingly a breadth of requirements . . . → Read More: WebMatrix Hosting :: Explore Experience wih WebMatrix]]>

Vertical and Scenario-Focused Tooling

I personally think having a variety of tools is good, especially if they can focus on different verticals, and are optimized for different scenarios/tasks. There is a saying – use the right tool for the job. And the reality is there is a wide spectrum of developers and correspondingly a breadth of requirements and expectations. Lots of professional/enterprise developers will find Visual Studio and its rich set of features + ecosystem a must-have for their work. At the same time, there is a huge number of Web developers, designers and scripters that primarily use Notepad, Textmate or a simple text editor to quickly build and manage their web sites and applications. For those folks, the simplicity that comes from the minimal set of options is a feature in itself. WebMatrix caters to that huge audience. This is true today, and was true back then.

Experimentation and New Ideas

The other aspect of “WebMatrix” that really resonates with me is that it provides an avenue for experimentation of new ideas/approaches, and learning, as well as innovation. You need speed boats and the agility they offer to explore the new, and then figure out where you want to go. We tried a number of things in the original WebMatrix – light-weight, free and web-focused tooling (I worked on Visual InterDev and missed the concept of a Web-focused SKU when the features got merged into Visual Studio). These characteristics also resonated well with the community, and I like to think the spirit of WebMatrix lived on in the form of the Express SKUs. The current generation of WebMatrix brings together a nice combination of simplified development model along with an embedded database solution (SQLCE), and a renewed focus on addressing server-side rendering (Razor). Personally, I think even more important than these building block technologies, is the notion of starting from applications and focusing on customizing them rather than building new applications from scratch. The concept of a rich ecosystem of working applications as a starting point is critical in fueling further growth of the platform as the underlying frameworks mature, and for competing.

A Social IDE – More Ideas to Explore

There were many ideas left unfinished in the original WebMatrix. For example, the online component gallery, and messenger/chat integration. Perhaps they were a little early back then. However, in this day and age of twitter, and social development (stack overflow, github etc.), it would be interesting to further that vision, and explore what an IDE can do to incorporate identity and facilitate collaborative development.

Fresh User Interface

The original WebMatrix was one of the big early fully managed applications, and was written using Windows Forms. It is nice to see the prettier user interface behind the simplified and streamlined development experience. Of course, this version is built on WPF.

I do wonder – what about a Silverlight-based implementation?

What I’d really also like to see is a richer set of IDE building blocks that can be composed together more readily to build specific vertical tools and experiences, without starting from scratch each time. This is what I realized even back then – code editor, intellisense, project system, debugger, source control, are some of the obvious components, that would be interesting to share across the different tools, Visual Studio, Expression, WebMatrix and other future efforts.

It will be interesting to see how WebMatrix matures, to say the least.