Found it on ScottGu’s and Erik Porter’s blogs

I’ve tested this successfully on Windows XP, Windows Vista, Windows Seven RC, Windows Server 2003 R2 and Windows Server 2008.

Here’s how to do it on the server:

1. Open the Registry Editor ( Start » Run » regedit )
2. Go to
   • HKEY_LOCAL_MACHINE
   • System
   • CurrentControlSet
   • Control
   • TerminalServer
   • WinStations
   • RDP-TCP
   • PortNumber
3. Rick Click on PortNumber
4. Select Modify
5. Change the Base from Hexadecimal to Decimal
6. Modify the value to whatever port you want (Make sure it is not a reserved port!)

And now on the client:

• Open Remote Desktop ( Start » Run » mstsc )
• Type in the address:port ( ex: 64.233.161.104:3388 )

That’s it!

There are many solutions to fix this, I’ll just explain my favorite, which is extension-less url.

So lets show IIS6 how to handle extension-less URL. For this, we’ll use the Wildcard Mapping feature.

• Open Internet Information Services (IIS) Manager. (run inetmgr)
• Right Click » Properties on your website.
  
• Open the Home Directory tab.
• Click on the Configuration button.
• Open the Mappings tab of the Application Configuration window.
• In the Wildcard application maps section, click on the Insert button.
• Browse to %windir%\Microsoft.NET\Framework\v2.0.50727\aspnet_isapi.dll.
• uncheck “Verify that file exists”.
  
• That’s it! Now try your ASP.NET MVC Application it should work nicely!

Phil Haack has a very good article about this matter and also explains other solution. You should definitly read it!

We will start this example from a blanc ASP.NET MVC Website. This will be easier for you to follow. Now that you have your new ASP.NET MVC Website, create a new class and name it SetCultureAttribute.cs in a new ActionFilter directory and paste this code inside of it.

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

namespace MvcApplication1.ActionFilter
{
    public class SetCultureAttribute : FilterAttribute, IActionFilter
    {
        public void OnActionExecuting(ActionExecutingContext
            filterContext)
        {
            string cultureCode = SetCurrentLanguage(filterContext);

            if (string.IsNullOrEmpty(cultureCode)) return;

            HttpContext.Current.Response.Cookies.Add(
                new HttpCookie("Culture", cultureCode)
                {
                    HttpOnly = true,
                    Expires = DateTime.Now.AddYears(100)
                }
            );

            filterContext.HttpContext.Session["Culture"] = cultureCode;

            CultureInfo culture = new CultureInfo(cultureCode);
            System.Threading.Thread.CurrentThread.CurrentCulture =
                culture;
            System.Threading.Thread.CurrentThread.CurrentUICulture =
                culture;
        }

        public void OnActionExecuted(ActionExecutedContext filterContext)
        {

        }

        private static string GetCookieCulture(ActionExecutingContext
            filterContext, ICollection Cultures)
        {
            /* Get the language in the cookie*/
            HttpCookie userCookie = filterContext.RequestContext
                                                .HttpContext
                                                .Request
                                                .Cookies["Culture"];

            if (userCookie != null)
            {
                if (!string.IsNullOrEmpty(userCookie.Value))
                {
                    if (Cultures.Contains(userCookie.Value))
                    {
                        return userCookie.Value;
                    }
                    return string.Empty;
                }
                return string.Empty;
            }
            return string.Empty;
        }

        private static string GetSessionCulture(ActionExecutingContext
            filterContext, ICollection Cultures)
        {
            if (filterContext.RequestContext.HttpContext
                                               .Session["Culture"]
                                                             != null)
            {
                string SessionCulture = filterContext.RequestContext
                                                .HttpContext
                                                .Session["Culture"]
                                                .ToString();

                if (!string.IsNullOrEmpty(SessionCulture))
                {
                    return Cultures.Contains(SessionCulture)
                                 ? SessionCulture
                                 : string.Empty;
                }
                return string.Empty;
            }
            return string.Empty;
        }

        private static string GetBrowserCulture(ActionExecutingContext
            filterContext, IEnumerable Cultures)
        {
            /* Gets Languages from Browser */
            IList BrowserLanguages = filterContext.RequestContext
                                                         .HttpContext
                                                         .Request
                                                         .UserLanguages;

            foreach (var thisBrowserLanguage in BrowserLanguages)
            {
                foreach (var thisCultureLanguage in Cultures)
                {
                    if (thisCultureLanguage != thisBrowserLanguage)
                        continue;

                    return thisCultureLanguage;
                }
            }
            return string.Empty;
        }

        private static string SetCurrentLanguage(ActionExecutingContext
             filterContext)
        {
            IList Cultures = new List
            {
                "en-CA",
                "fr-CA"
            };

            string CookieValue = GetCookieCulture(
                                            filterContext,
                                            Cultures);

            if (string.IsNullOrEmpty(CookieValue))
            {
                string SessionValue = GetSessionCulture(
                                                  filterContext,
                                                  Cultures);

                if (string.IsNullOrEmpty(SessionValue))
                {
                    string BrowserCulture = GetBrowserCulture(
                                                         filterContext,
                                                         Cultures);
                    return string.IsNullOrEmpty(BrowserCulture)
                             ? "en-CA"
                             : BrowserCulture;
                }
                return SessionValue;
            }
            return CookieValue;
        }
    }
}

Once this is done, we need to tell our controllers to use this attribute, to do this we could simply go on top of every controller and decorate it with [SetCulture] attribute. The down side with this is that we want the complete site multicultural, not just a few controllers or actions. To fix this problem we’ll make a BaseController which will inherit Controller and will be inherited from all our controllers.

To do this, create a new directory and name it Infrastructure and then add a new class called BaseController.cs in it. This class should contain the following code:

using System.Web.Mvc;
using MvcApplication1.ActionFilter;

namespace MvcApplication1.Infrastructure
{
    [SetCulture]
    public class BaseController : Controller
    {
         // Anything you put here will be accessible
         // in every controllers
    }
}

As I said before, we need to tell every controllers to use BaseController, so open every controllers and change the inheritance from Controller to BaseController. As of now, your website knows how to handle localization!!!

What we need now, is a way to switch between french and english… To do this I simply created a new ASP.NET MVC View User Controller (CultureUserControl.ascx) in Views/Shared with the following code.

<% if (Session["Culture"].ToString() == "en-CA") {%>
    [ Français ]
<% } else if (Session["Culture"].ToString() == "fr-CA") { %>
    [ English ]
<% } %>

Then I added it to the masterpage, right next to the Log On link.

    <% Html.RenderPartial("LogOnUserControl"); %>
    <% Html.RenderPartial("CultureUserControl"); %>

Last, but not least, add a new Global.resx and Global.fr.rex in the App_GlobalResources folder. You can start with the welcome message in About – Index and call it using Resources.Global.Welcome

You can find a working example of this tutorial here.

But before you can use this properly you will need to setup your database, which will be very easy because Microsoft shipped .NET 2.0 with a nice utility to do it! You can find this on your computer, at this path C:\Windows\Microsoft.NET\Framework\v2.0.50727\aspnet_regsql.exe

Your database should have these tables:

Now lets tell our ASP.NET MVC Website’s configuration where to find this database. Open the web.config and change the ApplicationServices connection string to point to your SQL Server. You should now rebuild your solution to avoid any problems in the next step!

<connectionStrings>
    <add name="ApplicationServices"
         connectionString="Data Source=localhost;
                           Initial Catalog=database;
                           Persist Security Info=True;
                           User ID=user;
                           Password=password"
         providerName="System.Data.SqlClient"
    />
</connectionStrings>

It’s all good and nice but now we need Users in this database otherwise it’s completly useless! So open up your ASP.NET MVC Solution in Visual Studio and go to Project » ASP.NET Configuration. This will open the ASP.NET Web Application Administration website. In the Security tab you can Add/Manage Users and Roles. For the moment, add a user so we can try the login. I’ve added user Mike.

You can now run your application and click on [ Log On ] at the top right corner of the page, this will redirect you the the logon form.

If you entered the correct credential you should be redirected to the home page of the site and you will see your name and a Log Off button instead of the Log On button.

Well congraticulations! You now have SqlMembershipProvider working on your website, wasn’t so hard, was it? Not a single line of code required! I’ll be posting again soon to show you how to use Roles in your applications.

1. Open the Command Prompt
2. Go To: C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322 (Or whatever version you need to register)
3. aspnet_regiis –u
   • The above commend uninstalls this version of ASP.NET.  Existing scriptmaps to this version are remapped to highest remaining version of ASP.NET installed on the machine.
4. aspnet_regiis –i
   • The above command installs this version of ASP.NET and updates scriptmaps at the Microsoft IIS metabase root and all scriptmaps below the root.  Existing scriptmaps of lower version are upgraded to this version.
5. aspnet_regiis –c
   • The above command installs the client side scripts for this version to the aspnet_client subdirectory of each Microsoft IIS site directory.

The error should go away now.

Saving changes is not permitted. The changes you have made require the following tables to be dropped and re-created. You have either made changes to a table that can’t be re-created or enabled the option Prevent saving changes that require the table to be re-created.

This is really annoying because you cannot add relationship to your tables once your created them! Luckily all we need to do to correct this error is change an option in SQL Management Studio.

Go to Tools » Options » Designers and Uncheck “Prevent saving changes that require table re-creation”

That should do the trick!