Using Multiple Worker Process with Ignite UI Upload Control - Part 1 (Web Gardens)

[Infragistics] Mihail Mateev / Friday, August 15, 2014

File upload controls are important part from many web applications. Upload components enables you to provide users with a way to send a file from their computer to the server. These controls are useful for allowing users to upload pictures, text files, or other files.

The Infragistics Ignite UI suite includes the File Upload Control (igUpload) that you can use to offer to your users all features expected from upload components. If you prefer to use C# you can use the Html helper in APS.NET MVC to get it running in no time. File Upload is available also for Infragistics ASP.Net Web Forms components as Web Upload (it an igUpload wrapper ).

In several posts you will learn how to use Ignite UI Upload Control in specific cases when you need better performance ( using igUpload in Web Garden, Web Farm, Cloud solutions / Microsoft Azure ) . Performance could be an issue when you need to backup many large files using File Upload. Reliability is another reason to use similar solutions.

We will not do an overview of the igUpload features. You can find detailed information about Ignite UI upload functionalities in Infragistics documentation or www.igniteui.com

This article is focused on how to use Ignite UI upload control in applications, configured as Web Gardens. If you have no experience with Web Gardens – don’t worry – this post also makes an overview how to configure one web application to use multiple worker processes ( Web Garden) in IIS, what is the difference between Web Garden , Web Farm, cloud applications and more…

What is IIS

IIS (Internet Information Server) from Microsoft is used to host your ASP.NET Web applications. IIS has it’s own ASP.NET Process Engine to handle the ASP.NET request. So, when a request comes from client to server, IIS takes that request and process it and send response back to clients.

Worker processes are a way of segmenting the execution of your website across multiple exe's. You do this for a couple of reasons, one if one of the workers gets clobbered by run time issues it doesn't take the others down.

Worker Process

Worker Process (w3wp.exe) runs the ASP.Net application in IIS. This process is responsible to manage all the request and response that are coming from client system. All the ASP.Net functionality runs under the scope of worker process

Application pool

Application pool is the container of worker process. Application pools is used to separate sets of IIS worker processes that share the same configuration. Application pools enables a better security, reliability, and availability for any web application. The worker process serves as the process boundary that separates each application pool so that when one worker process or application is having an issue or recycles, other applications or worker processes are not affected.

Web Farm

You may need to use multiple servers to host the application and divide the traffic among them. This is called “Web Farm”. So when you are hosting your single web site on multiple web servers over load balancer is called “Web Farm”. We will cover more details, related to the web farms in the next part of this article.

Web Garden

By default, each Application pool contains a single worker process. Application which contains the multiple worker process is called “Web Garden”. Below is the typical diagram for a web garden application.

So, a Web application hosted on multiple servers and access based on the load on servers is called Web Farms and when a single application pool contains multiple Worker processes, it is called a web garden.

Ignite UI Upload Implementation for Web Garden:

The current implementation uses Visual Studio 2013, ASP.Net MVC 5 and Ignite UI 14.1 . The igUpload control is updated to use cistom dictionary providers for Web Farm / Web Garden scenarios - It was not possible to use it in previous 13.x versions of Ignite UI of you have the latest service releases.

When application is configured to use multiple worker processes, the main issue is how to sync information about the uploading files. This functionality is supported via CustomDictionaryProvider.

CustomDictionaryProvider configures a third party dictionary provider (the structure which holds the metadata for the currently uploading files).
This setting is specifically designed for Web Farm/Web Garden scenarios where a common file metadata should be shared between multiple machines/processes.
This setting expects a name of a type which implements ISafeDictionary<string, UploadInfo> interface.

There are different possible approaches to keep your metadata independent from different processes. On of possible solutions includes implementation of the web service (WCF service) where to keep upload info metadata. It could run in separate IIS application pool, where

WPF Service (FileUploadSvc):

Implementation includes simple WCF application.

IUploadService interface ( IUploadService.cs )

using System;

using System.Collections.Generic;

using System.ServiceModel;

using Infragistics.Web.Mvc;

  

namespace FileUploadSvc

{

    [ServiceContract]

    public interface IUploadService

    {

        [OperationContract]

        void SetData(Dictionary<string, UploadInfo> dict);

  

        [OperationContract]

        Dictionary<string, UploadInfo> GetData();

  

        [OperationContract]

        bool RemoveData(string key);

    }

}

UploadService.svc.cs

Code below shows the implementation of IUploadService , where the most important is how to manage dictionaries with upload information ( upload metadata structure is defined in UploadInfo type )

using System;

using System.Collections.Generic;

using System.Linq;

using System.ServiceModel;

using Infragistics.Web.Mvc;

  

namespace FileUploadSvc

{

  

  

    [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]

    public class UploadService : IUploadService

    {

  

        Dictionary<string, UploadInfo> _dictFiles = new Dictionary<string, UploadInfo>();

  

        public void SetData(Dictionary<string, UploadInfo> dict)

        {

            try

            {

                if (dict != null)

                {

                    this._dictFiles = Merge(new Dictionary<string, UploadInfo>[] { dict, this._dictFiles });

                }

            }

            catch (Exception ex)

            {

                Console.Write(ex.Message);

            }

        }

  

        public bool RemoveData(string key)

        {

            bool isRemoved = false;

            if (this._dictFiles != null && this._dictFiles.ContainsKey(key))

            {

                isRemoved = this._dictFiles.Remove(key);

            }

            return isRemoved;

        }

  

        public Dictionary<string, UploadInfo> Merge(Dictionary<string, UploadInfo>[] dictionaries)

        {

            return dictionaries.SelectMany(x => x)

                .ToLookup(pair => pair.Key, pair => pair.Value)

                .ToDictionary(group => group.Key, group => group.First());

        }

  

        public Dictionary<string, UploadInfo> GetData()

        {

            return this._dictFiles;

        }

  

  

    }

}

Upload implementation (ASP.Net MVC 5 Application)

ISafeDictionary interface

Below is shown ISafeDictionary interface

public interface ISafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable

{

    // Summary:

    //     Check if the key exists in the dictionary, if not adds the value

    //

    // Parameters:

    //   key:

    //

    //   value:

    bool CheckAndAdd(TKey key, TValue value);

}

CustomSafeDictionary class

Implementation of Serialization in CustomSafeDictionary (as shown below)

#region Serialization

private Dictionary<string, UploadInfo> Dictionary

{

    get

    {

        return this.Deserialize();

    }

}

  

private Dictionary<string, UploadInfo> Deserialize()

{

    UploadService.UploadServiceClient client = new UploadService.UploadServiceClient();

    return client.GetData();

}

  

private void Serialize(Dictionary<string, UploadInfo> d)

{

    UploadService.UploadServiceClient client = new UploadService.UploadServiceClient();

    client.SetData(d);

}

#endregion

The whole CustomSafeDictionary class code is available below:

[Serializable]

public class CustomSafeDictionary : ISafeDictionary<string, UploadInfo>

{

  

    #region Members

    private readonly object syncRoot = new object();

    private Dictionary<string, UploadInfo> _dictionary;

    #endregion

  

  

    public CustomSafeDictionary()

    {

        this._dictionary = new Dictionary<string, UploadInfo>();

        Serialize(this._dictionary);

    }

  

    #region Serialization

    private Dictionary<string, UploadInfo> Dictionary

    {

        get

        {

            return this.Deserialize();

        }

    }

  

    private Dictionary<string, UploadInfo> Deserialize()

    {

        UploadService.UploadServiceClient client = new UploadService.UploadServiceClient();

        return client.GetData();

    }

  

    private void Serialize(Dictionary<string, UploadInfo> d)

    {

        UploadService.UploadServiceClient client = new UploadService.UploadServiceClient();

        client.SetData(d);

    }

    #endregion

  

    #region Properties

    #region Keys

    /// <summary>

    /// Returns the collection of keys

    /// </summary>

    public ICollection<string> Keys

    {

        get

        {

            ICollection<string> keys;

            lock (syncRoot)

            {

                keys = this.Dictionary.Keys;

            }

            return keys;

        }

    }

    #endregion

  

    #region Values

    /// <summary>

    /// Gets the collection containing the values

    /// </summary>

    public ICollection<UploadInfo> Values

    {

        get

        {

            ICollection<UploadInfo> values;

            lock (syncRoot)

            {

                values = this.Dictionary.Values;

            }

            return values;

        }

    }

    #endregion

  

    #region this[string key]

    /// <summary>

    /// Gets or sets the value associated with the specified key.

    /// </summary>

    /// <param name="key"></param>

    /// <returns></returns>

    public UploadInfo this[string key]

    {

        get

        {

            UploadInfo value;

            lock (syncRoot)

            {

                value = this.Dictionary[key];

            }

            return value;

        }

        set

        {

            lock (syncRoot)

            {

                this._dictionary = this.Dictionary;

                this._dictionary[key] = value;

                this.Serialize(this._dictionary);

  

            }

        }

    }

    #endregion

  

    #region Count

    /// <summary>

    /// Gets the number of key/value pairs in the dictionary

    /// </summary>

    public int Count

    {

        get

        {

            int count = 0;

            lock (syncRoot)

            {

                count = this.Dictionary.Count;

            }

            return count;

        }

    }

    #endregion

  

    #region IsReadOnly

    /// <summary>

    /// Returns whether the dictionary is read only

    /// </summary>

    public bool IsReadOnly

    {

        get { return false; }

    }

    #endregion

    #endregion

  

    #region Methods

    #region IDictionary<string,UploadInfoMembers>

    /// <summary>

    /// Adds the specified key and value to the dictionary

    /// </summary>

    /// <param name="key"></param>

    /// <param name="value"></param>

    public void Add(string key, UploadInfo value)

    {

        lock (syncRoot)

        {

            this._dictionary = this.Dictionary;

            this._dictionary.Add(key, value);

            this.Serialize(this._dictionary);

        }

    }

  

    /// <summary>

    /// Check if the key exists in the dictionary, if not adds the value

    /// </summary>

    /// <param name="key"></param>

    /// <param name="value"></param>

    /// <returns></returns>

    public bool CheckAndAdd(string key, UploadInfo value)

    {

        bool isAdded = false;

        lock (syncRoot)

        {

            if (!this.Dictionary.ContainsKey(key))

            {

                this._dictionary = this.Dictionary;

                this._dictionary.Add(key, value);

                this.Serialize(this._dictionary);

                isAdded = true;

            }

        }

  

        return isAdded;

    }

  

    /// <summary>

    /// Check if the key exists in dictionary, if not adds the value

    /// </summary>

    /// <param name="keyValuePair"></param>

    /// <returns></returns>

    public bool CheckAndAdd(KeyValuePair<string, UploadInfo> keyValuePair)

    {

        bool isAdded = false;

        lock (syncRoot)

        {

            if (!this.Dictionary.ContainsKey(keyValuePair.Key))

            {

                Add(keyValuePair);

                isAdded = true;

            }

        }

  

        return isAdded;

    }

  

    /// <summary>

    /// Check if the dictionary contains the specified key

    /// </summary>

    /// <param name="key"></param>

    /// <returns></returns>

    public bool ContainsKey(string key)

    {

        bool isContains = false;

        lock (syncRoot)

        {

            isContains = this.Dictionary.ContainsKey(key);

        }

        return isContains;

    }

  

  

    /// <summary>

    /// Removes from the dictionary item with the specified key

    /// </summary>

    /// <param name="key"></param>

    /// <returns></returns>

    public bool Remove(string key)

    {

        lock (syncRoot)

        {

            UploadService.UploadServiceClient client = new UploadService.UploadServiceClient();

  

            return client.RemoveData(key);

        }

    }

  

    public bool TryGetValue(string key, out UploadInfo value)

    {

        lock (syncRoot)

        {

            this._dictionary = this.Dictionary;

            return this._dictionary.TryGetValue(key, out value);

        }

    }

  

  

    #endregion

  

    #region ICollection<KeyValuePair<string,UploadInfo>Members

    /// <summary>

    /// Adds the item to collection

    /// </summary>

    /// <param name="item"></param>

    public void Add(KeyValuePair<string, UploadInfo> item)

    {

        lock (syncRoot)

        {

            this._dictionary = this.Dictionary;

            ((ICollection<KeyValuePair<string, UploadInfo>>)this._dictionary).Add(item);

            this.Serialize(this._dictionary);

        }

    }

  

    /// <summary>

    /// Removes all keys and values from the dictionary

    /// </summary>

    public void Clear()

    {

        lock (syncRoot)

        {

            this._dictionary = this.Dictionary;

            this._dictionary.Clear();

            this.Serialize(this._dictionary);

        }

    }

  

    /// <summary>

    /// Check whether the dictionary contains the specific item

    /// </summary>

    /// <param name="item"></param>

    /// <returns></returns>

    public bool Contains(KeyValuePair<string, UploadInfo> item)

    {

        return ((ICollection<KeyValuePair<string,

        UploadInfo>>)this.Dictionary).Contains(item);

    }

  

    /// <summary>

    /// Copies the dictionary KeyCollection

    /// elements to an existing one-dimensional System.Array, starting at the specified array index.

    /// </summary>

    /// <param name="array"></param>

    /// <param name="arrayIndex"></param>

    public void CopyTo(KeyValuePair<string, UploadInfo>[] array, int arrayIndex)

    {

        lock (syncRoot)

        {

            this._dictionary = this.Dictionary;

            ((ICollection<KeyValuePair<string, UploadInfo>>)this._dictionary).CopyTo(array,

            arrayIndex);

            this.Serialize(this._dictionary);

        }

    }

  

    /// <summary>

    /// Removes the value with the specified key from the dictionary.

    /// </summary>

    /// <param name="item"></param>

    /// <returns></returns>

    public bool Remove(KeyValuePair<string, UploadInfo> item)

    {

        lock (syncRoot)

        {

            this._dictionary = this.Dictionary;

            return ((ICollection<KeyValuePair<string,

            UploadInfo>>)this._dictionary).Remove(item);

            this.Serialize(this._dictionary);

        }

    }

  

    #endregion

  

    #region IEnumerable<KeyValuePair<string,UploadInfo>Members

    /// <summary>

    /// Returns an enumerator that iterates through the collection.

    /// </summary>

    /// <returns></returns>

    public IEnumerator<KeyValuePair<string, UploadInfo>> GetEnumerator()

    {

        return ((ICollection<KeyValuePair<string, UploadInfo>>)this.Dictionary).GetEnumerator();

    }

  

    #endregion

  

    #region IEnumerable Members

    /// <summary>

    /// Returns an enumerator that iterates through a collection.

    /// </summary>

    /// <returns>An System.Collections.IEnumerator object that can be used to iterate through the collection</returns>

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

    {

        return ((System.Collections.IEnumerable)this.Dictionary).GetEnumerator();

    }

  

    #endregion

    #endregion

}

Configuration:

Web.config file

The appSettings section

<appSettings>

    ....

    <add key="fileUploadPath" value="~/Uploads" />

    <add key="maxFileSizeLimit" value="5194304" />

    <add key="bufferSize" value="56384" />

    <add key="CustomDictionaryProvider" value="IgUploadMvc03.CustomSafeDictionary, IgUploadMvc03" />

 </appSettings>

The webServer section

<system.webServer>

    <modules runAllManagedModulesForAllRequests="true">

      <add name="IGUploadModule" type="Infragistics.Web.Mvc.UploadModule"

                                 preCondition="managedHandler" />

    </modules>

    <handlers>

      <add name="IGUploadStatusHandler" path="IGUploadStatusHandler.ashx" verb="*"

           type="Infragistics.Web.Mvc.UploadStatusHandler" preCondition="integratedMode" />

    </handlers>

    ....

</system.webServer>

RouteConfig class

public class RouteConfig

{

    public static void RegisterRoutes(RouteCollection routes)

    {

        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        routes.IgnoreRoute("IGUploadStatusHandler.ashx");

        routes.MapRoute(

            name: "Default",

            url: "{controller}/{action}/{id}",

            defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }

        );

    }

}

Controllers ( MVC project)

public ActionResult Upload()

{

    ViewBag.Message = "Your upload page.";

  

    return View();

}

  

  

public ActionResult UploadMvc()

{

    ViewBag.Message = "Your upload MVC page.";

  

    return View();

}

Views:
HTML5 / jQuery implementation (Upload view )

<!DOCTYPE html>

  

<html>

<head>

    <title></title>

    <link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/themes/infragistics/infragistics.theme.css" rel="stylesheet" />

    <link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/structure/infragistics.css" rel="stylesheet" />

  

    <script src="http://modernizr.com/downloads/modernizr-latest.js"></script>
  

    <script src="http://code.jquery.com/jquery-1.9.1.min.js">

</script>

    <script src="http://code.jquery.com/ui/1.10.3/jquery-ui.min.js">

</script>

  

    <!-- Ignite UI Required Combined JavaScript Files -->

    <script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.core.js">

</script>

    <script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.lob.js">

</script>

  

</head>

<body>

    <link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/themes/infragistics/infragistics.theme.css" rel="stylesheet" />

    <link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/structure/infragistics.css" rel="stylesheet" />

  

    <style type="text/css">

        .container-info, .error-info {

            margin: 10px 0;

            font-weight: bold;

        }

  

        .error-info {

            color: #FF0000;

        }

    </style>

  

    <script src="http://modernizr.com/downloads/modernizr-latest.js">

</script>

    <script src="http://code.jquery.com/jquery-1.9.1.min.js">

</script>

    <script src="http://code.jquery.com/ui/1.10.3/jquery-ui.min.js">

</script>

  

    <!-- Ignite UI Required Combined JavaScript Files -->

    <script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.core.js">

</script>

    <script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.lob.js">

</script>

  

</head>

<body>

  

    <div id="igUpload1"></div>

    <div id="error-message" style="color: #FF0000; font-weight: bold;"></div>

    <script>

  

        $(function () {

            $("#igUpload1").igUpload({

                mode: 'multiple',

                maxUploadedFiles: 4,

                maxSimultaneousFilesUploads: 2,

                autostartupload: true,

                progressUrl: "/IGUploadStatusHandler.ashx",

                onError: function (e, args) {

                    showAlert(args);

                }

            });

        });

  

        function showAlert(args) {

            $("#error-message").html(args.errorMessage).stop(true, true).fadeIn(500).delay(3000).fadeOut(500);

        }

  

        //more optional code

    
</script>

    

</body>

</html>

Razor implementation (UploadMvc view )

@using Infragistics.Web.Mvc

  

@{

    Layout = null;

}

  

<!DOCTYPE html>

  

<html>

<head>

    <meta name="viewport" content="width=device-width" />

    <title>IgUpload MVC Helper</title>

    <!-- Ignite UI Required Combined CSS Files -->

    <link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/themes/infragistics/infragistics.theme.css" rel="stylesheet" />

    <link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/structure/infragistics.css" rel="stylesheet" />

  

    <script src="http://modernizr.com/downloads/modernizr-latest.js"></script>

    <script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>

    <script src="http://code.jquery.com/ui/1.10.3/jquery-ui.min.js"></script>

  

    <!-- Ignite UI Required Combined JavaScript Files -->

    <script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.core.js"></script>

    <script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.lob.js"></script>

  

</head>

<body>

    <div>

@(

 Html.Infragistics().Upload()

        .ID("igUpload1")

        .Mode(UploadMode.Single)

        .AutoStartUpload(true)

        .ProgressUrl(Url.Content("~/IGUploadStatusHandler.ashx"))

        .ControlId("serverID1")

        .Render()

)

  

        <div id="error-message" style="color: #FF0000; font-weight: bold;"></div>

  

        <script type="text/javascript">

            $(function () {

                $("#igUpload1").bind({

                    iguploadonerror: function (e, args) {

                        $("#error-message").html(args.errorMessage).stop(true, true).fadeIn(500).delay(3000).fadeOut(500);

                    }

                });

            });

        </script>   

    </div>

</body>

</html>

ASP.Net Web Forms solution:

If you need to use ASP.Net Web Forms application, the only one difference is *aspx file, where you should add a WebUpload ASP.Net control

*.aspx file:

<div>

    <div id="main" style="margin: 50px;">

        <div id="error-message" style="color: #FF0000; font-weight: bold;">

        </div>

        <ig:WebUpload AutoStartUpload="true" ID="IGUpload" runat="server" ClientIDMode="Static"

            LabelUploadButton="Browse PDF" LabelAddButton="Browse PDF" FileSizeMetric="KBytes" ProgressUrl="IGUploadStatusHandler.ashx" Style="width: auto;">

            <AllowedExtensions>

                    <ig:FileUploadExtension Extension="pdf" />     

                    <ig:FileUploadExtension Extension="PDF" /> 

                    <ig:FileUploadExtension Extension="Pdf" /> 

                    <ig:FileUploadExtension Extension="PDf" /> 

                    <ig:FileUploadExtension Extension="pDF" /> 

                    <ig:FileUploadExtension Extension="pDf" /> 

                    <ig:FileUploadExtension Extension="pdF" /> 

                    <ig:FileUploadExtension Extension="PdF" /> 

                    <ig:FileUploadExtension Extension="PDf" />                   

                </AllowedExtensions>

                <FileExtensionIcons>

                    <ig:FileUploadExtensionIcon Default="True">

                        <Extensions>

                            <ig:FileUploadExtension Extension="pdf" />

                        </Extensions>

                    </ig:FileUploadExtensionIcon>

                </FileExtensionIcons>

                <ClientEvents FileUploaded="fileUploaded" />

                <ClientEvents FileSelecting="fileSelecting" />

                <ClientEvents FileSelected="fileSelected" />

                <ClientEvents OnError="onErrorHandler" />

        </ig:WebUpload>

        <asp:HiddenField ID="filePath" ClientIDMode="Static" runat="server" />   

    </div>   

    <a href="#" id="btnImportDocsAdd" class="ui-button ui-state-default ui-corner-all"  style="display:none;"

            runat="server" clientidmode="static"><span class="ui-icon ui-icon-plus"></span>Move Documents</a> 

</div>

Configuation in web.config is identical with this one for ASP.Net MVC project

IIS configuration ( IIS 7.x and IIS 8.x)

Create /set application pools

IIS Management Console –> Application Pools –> Add Application Pool

Select the pool and choose “Advanced Settings”.

Add a new application pool ( IgUploadMvc) .

Select the created new application pool and choose “Advanced Settings”

Check the setting for our ASP.Net MVC project (IgUploadMVC03)

Manage Application –> Advanced Settimgs->Application Pool

Check the setting for WCF application project (FIleUploadSvc)

It is important when we need multiple worker processes for Ignite UI Upload component to have different application pools for the MVC application, including upload control and your WCF service.
WCF service is used to keep upload information for each file

Ensure that the application pool is different (even if it is a default application pool / DefaultAppPool ) and its Maximum Worker Processes is set to 1

Application pool default settings:

Sample application: ASP.Net MVC 5 project.

If you want to test your application in debug mode you need to set in Web properties to use Local IIS or External Host ( IIS Express cannot allow you to test multiple worker processes )

Sample application , available for download here , has two views to demonstrate Ignite UI file upload , one with pure jQuery implementation (Upload view) and another one with MVC helper (UploadMvc view)

Screens below demonstrate how to upload file using jQuery implementation ( view with MVC helper provides identical functionalities)

Initial state of the upload

Choose files

Upload progress

Final screen state

Uploaded files

We would be able to summarize that you need to use igUpload with multiple worker roles you need to:

Implement a CustomDuctionaryProvider
1.1 This provider should maintain upload metadata out of the same application pool where works your application.
1.2 One simple implementation is via WCF service that works in separate application pool (This pool should have maximum worker processes per application set to 1. Otherwise you can have metadata for each worker process that is not consistent with the metadata for other worker processes)
Set your CustomDictionaryProvider in the Web.config of your ASP.Net MVC / Web Forms application

This implementation is mainly for Web Gardens , but it could work for Web Farms / Cloud solutions as you will see in the next parts of this article.

Sample project, used for this blog could be downloaded here:

Click on this image to get a fully support trial version of Infragistics Ignite UI controls:

To view all the samples and code for HTML, MVC & ASP.NET, click here:

http://www.igniteui.com/

Follow news from Infragistics for more information about new Infragistics products.

As always, you can follow us on Twitter @mihailmateev and @Infragistics and stay in touch on Facebook,Google+andLinkedIn!