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 )

   1:using System;

   2:using System.Collections.Generic;

   3:using System.ServiceModel;

   4:using Infragistics.Web.Mvc;

   5:  

   6:namespace FileUploadSvc

   7: {

   8:     [ServiceContract]

   9:publicinterface IUploadService

  10:     {

  11:         [OperationContract]

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

  13:  

  14:         [OperationContract]

  15:         Dictionary<string, UploadInfo> GetData();

  16:  

  17:         [OperationContract]

  18:bool RemoveData(string key);

  19:     }

  20: }

• 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 )

   1:using System;

   2:using System.Collections.Generic;

   3:using System.Linq;

   4:using System.ServiceModel;

   5:using Infragistics.Web.Mvc;

   6:  

   7:namespace FileUploadSvc

   8: {

   9:  

  10:  

  11:     [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]

  12:publicclass UploadService : IUploadService

  13:     {

  14:  

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

  16:  

  17:publicvoid SetData(Dictionary<string, UploadInfo> dict)

  18:         {

  19:try

  20:             {

  21:if (dict != null)

  22:                 {

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

  24:                 }

  25:             }

  26:catch (Exception ex)

  27:             {

  28:                 Console.Write(ex.Message);

  29:             }

  30:         }

  31:  

  32:publicbool RemoveData(string key)

  33:         {

  34:bool isRemoved = false;

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

  36:             {

  37:                 isRemoved = this._dictFiles.Remove(key);

  38:             }

  39:return isRemoved;

  40:         }

  41:  

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

  43:         {

  44:return dictionaries.SelectMany(x => x)

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

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

  47:         }

  48:  

  49:public Dictionary<string, UploadInfo> GetData()

  50:         {

  51:returnthis._dictFiles;

  52:         }

  53:  

  54:  

  55:     }

  56: }

Upload implementation (ASP.Net MVC 5 Application)

• ISafeDictionary interface

Below is shown ISafeDictionary interface

   1:publicinterface ISafeDictionary<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable

   2: {

   3:// Summary:

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

   5://

   6:// Parameters:

   7://   key:

   8://

   9://   value:

  10:bool CheckAndAdd(TKey key, TValue value);

  11: }

• CustomSafeDictionary class

Implementation of Serialization in CustomSafeDictionary (as shown below)

   1:#region Serialization

   2:private Dictionary<string, UploadInfo> Dictionary

   3: {

   4:     get

   5:     {

   6:returnthis.Deserialize();

   7:     }

   8: }

   9:  

  10:private Dictionary<string, UploadInfo> Deserialize()

  11: {

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

  13:return client.GetData();

  14: }

  15:  

  16:privatevoid Serialize(Dictionary<string, UploadInfo> d)

  17: {

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

  19:     client.SetData(d);

  20: }

  21:#endregion

The whole CustomSafeDictionary  class code is available below:

   1: [Serializable]

   2:publicclass CustomSafeDictionary : ISafeDictionary<string, UploadInfo>

   3: {

   4:  

   5:#region Members

   6:privatereadonlyobject syncRoot = newobject();

   7:private Dictionary<string, UploadInfo> _dictionary;

   8:#endregion

   9:  

  10:  

  11:public CustomSafeDictionary()

  12:     {

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

  14:         Serialize(this._dictionary);

  15:     }

  16:  

  17:#region Serialization

  18:private Dictionary<string, UploadInfo> Dictionary

  19:     {

  20:         get

  21:         {

  22:returnthis.Deserialize();

  23:         }

  24:     }

  25:  

  26:private Dictionary<string, UploadInfo> Deserialize()

  27:     {

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

  29:return client.GetData();

  30:     }

  31:  

  32:privatevoid Serialize(Dictionary<string, UploadInfo> d)

  33:     {

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

  35:         client.SetData(d);

  36:     }

  37:#endregion

  38:  

  39:#region Properties

  40:#region Keys

  41:/// <summary>

  42:/// Returns the collection of keys

  43:/// </summary>

  44:public ICollection<string> Keys

  45:     {

  46:         get

  47:         {

  48:             ICollection<string> keys;

  49:lock (syncRoot)

  50:             {

  51:                 keys = this.Dictionary.Keys;

  52:             }

  53:return keys;

  54:         }

  55:     }

  56:#endregion

  57:  

  58:#region Values

  59:/// <summary>

  60:/// Gets the collection containing the values

  61:/// </summary>

  62:public ICollection<UploadInfo> Values

  63:     {

  64:         get

  65:         {

  66:             ICollection<UploadInfo> values;

  67:lock (syncRoot)

  68:             {

  69:                 values = this.Dictionary.Values;

  70:             }

  71:return values;

  72:         }

  73:     }

  74:#endregion

  75:  

  76:#regionthis[string key]

  77:/// <summary>

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

  79:/// </summary>

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

  81:/// <returns></returns>

  82:public UploadInfo this[string key]

  83:     {

  84:         get

  85:         {

  86:             UploadInfo value;

  87:lock (syncRoot)

  88:             {

  89:value = this.Dictionary[key];

  90:             }

  91:returnvalue;

  92:         }

  93:         set

  94:         {

  95:lock (syncRoot)

  96:             {

  97:this._dictionary = this.Dictionary;

  98:this._dictionary[key] = value;

  99:this.Serialize(this._dictionary);

 100:  

 101:             }

 102:         }

 103:     }

 104:#endregion

 105:  

 106:#region Count

 107:/// <summary>

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

 109:/// </summary>

 110:publicint Count

 111:     {

 112:         get

 113:         {

 114:int count = 0;

 115:lock (syncRoot)

 116:             {

 117:                 count = this.Dictionary.Count;

 118:             }

 119:return count;

 120:         }

 121:     }

 122:#endregion

 123:  

 124:#region IsReadOnly

 125:/// <summary>

 126:/// Returns whether the dictionary is read only

 127:/// </summary>

 128:publicbool IsReadOnly

 129:     {

 130:         get { returnfalse; }

 131:     }

 132:#endregion

 133:#endregion

 134:  

 135:#region Methods

 136:#region IDictionary<string,UploadInfoMembers>

 137:/// <summary>

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

 139:/// </summary>

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

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

 142:publicvoid Add(string key, UploadInfo value)

 143:     {

 144:lock (syncRoot)

 145:         {

 146:this._dictionary = this.Dictionary;

 147:this._dictionary.Add(key, value);

 148:this.Serialize(this._dictionary);

 149:         }

 150:     }

 151:  

 152:/// <summary>

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

 154:/// </summary>

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

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

 157:/// <returns></returns>

 158:publicbool CheckAndAdd(string key, UploadInfo value)

 159:     {

 160:bool isAdded = false;

 161:lock (syncRoot)

 162:         {

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

 164:             {

 165:this._dictionary = this.Dictionary;

 166:this._dictionary.Add(key, value);

 167:this.Serialize(this._dictionary);

 168:                 isAdded = true;

 169:             }

 170:         }

 171:  

 172:return isAdded;

 173:     }

 174:  

 175:/// <summary>

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

 177:/// </summary>

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

 179:/// <returns></returns>

 180:publicbool CheckAndAdd(KeyValuePair<string, UploadInfo> keyValuePair)

 181:     {

 182:bool isAdded = false;

 183:lock (syncRoot)

 184:         {

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

 186:             {

 187:                 Add(keyValuePair);

 188:                 isAdded = true;

 189:             }

 190:         }

 191:  

 192:return isAdded;

 193:     }

 194:  

 195:/// <summary>

 196:/// Check if the dictionary contains the specified key

 197:/// </summary>

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

 199:/// <returns></returns>

 200:publicbool ContainsKey(string key)

 201:     {

 202:bool isContains = false;

 203:lock (syncRoot)

 204:         {

 205:             isContains = this.Dictionary.ContainsKey(key);

 206:         }

 207:return isContains;

 208:     }

 209:  

 210:  

 211:/// <summary>

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

 213:/// </summary>

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

 215:/// <returns></returns>

 216:publicbool Remove(string key)

 217:     {

 218:lock (syncRoot)

 219:         {

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

 221:  

 222:return client.RemoveData(key);

 223:         }

 224:     }

 225:  

 226:publicbool TryGetValue(string key, out UploadInfo value)

 227:     {

 228:lock (syncRoot)

 229:         {

 230:this._dictionary = this.Dictionary;

 231:returnthis._dictionary.TryGetValue(key, outvalue);

 232:         }

 233:     }

 234:  

 235:  

 236:#endregion

 237:  

 238:#region ICollection<KeyValuePair<string,UploadInfo>Members

 239:/// <summary>

 240:/// Adds the item to collection

 241:/// </summary>

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

 243:publicvoid Add(KeyValuePair<string, UploadInfo> item)

 244:     {

 245:lock (syncRoot)

 246:         {

 247:this._dictionary = this.Dictionary;

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

 249:this.Serialize(this._dictionary);

 250:         }

 251:     }

 252:  

 253:/// <summary>

 254:/// Removes all keys and values from the dictionary

 255:/// </summary>

 256:publicvoid Clear()

 257:     {

 258:lock (syncRoot)

 259:         {

 260:this._dictionary = this.Dictionary;

 261:this._dictionary.Clear();

 262:this.Serialize(this._dictionary);

 263:         }

 264:     }

 265:  

 266:/// <summary>

 267:/// Check whether the dictionary contains the specific item

 268:/// </summary>

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

 270:/// <returns></returns>

 271:publicbool Contains(KeyValuePair<string, UploadInfo> item)

 272:     {

 273:return ((ICollection<KeyValuePair<string,

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

 275:     }

 276:  

 277:/// <summary>

 278:/// Copies the dictionary KeyCollection

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

 280:/// </summary>

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

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

 283:publicvoid CopyTo(KeyValuePair<string, UploadInfo>[] array, int arrayIndex)

 284:     {

 285:lock (syncRoot)

 286:         {

 287:this._dictionary = this.Dictionary;

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

 289:             arrayIndex);

 290:this.Serialize(this._dictionary);

 291:         }

 292:     }

 293:  

 294:/// <summary>

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

 296:/// </summary>

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

 298:/// <returns></returns>

 299:publicbool Remove(KeyValuePair<string, UploadInfo> item)

 300:     {

 301:lock (syncRoot)

 302:         {

 303:this._dictionary = this.Dictionary;

 304:return ((ICollection<KeyValuePair<string,

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

 306:this.Serialize(this._dictionary);

 307:         }

 308:     }

 309:  

 310:#endregion

 311:  

 312:#region IEnumerable<KeyValuePair<string,UploadInfo>Members

 313:/// <summary>

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

 315:/// </summary>

 316:/// <returns></returns>

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

 318:     {

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

 320:     }

 321:  

 322:#endregion

 323:  

 324:#region IEnumerable Members

 325:/// <summary>

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

 327:/// </summary>

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

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

 330:     {

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

 332:     }

 333:  

 334:#endregion

 335:#endregion

 336: }

• Configuration:

• Web.config file

The appSettings section

   1:<appSettings>

   2:     ....

   3:<addkey="fileUploadPath"value="~/Uploads"/>

   4:<addkey="maxFileSizeLimit"value="5194304"/>

   5:<addkey="bufferSize"value="56384"/>

   6:<addkey="CustomDictionaryProvider"value="IgUploadMvc03.CustomSafeDictionary, IgUploadMvc03"/>

   7:</appSettings>

The webServer section

   1:<system.webServer>

   2:<modulesrunAllManagedModulesForAllRequests="true">

   3:<addname="IGUploadModule"type="Infragistics.Web.Mvc.UploadModule"

   4:preCondition="managedHandler"/>

   5:</modules>

   6:<handlers>

   7:<addname="IGUploadStatusHandler"path="IGUploadStatusHandler.ashx"verb="*"

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

   9:</handlers>

  10:     ....

  11:</system.webServer>

• RouteConfig class

   1:publicclass RouteConfig

   2: {

   3:publicstaticvoid RegisterRoutes(RouteCollection routes)

   4:     {

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

   6:         routes.IgnoreRoute("IGUploadStatusHandler.ashx");

   7:         routes.MapRoute(

   8:             name: "Default",

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

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

  11:         );

  12:     }

  13: }

• Controllers ( MVC project)

   1:public ActionResult Upload()

   2: {

   3:     ViewBag.Message = "Your upload page.";

   4:  

   5:return View();

   6: }

   7:  

   8:  

   9:public ActionResult UploadMvc()

  10: {

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

  12:  

  13:return View();

  14: }

• Views:
• HTML5 /  jQuery implementation (Upload view )

   1:<!DOCTYPEhtml>

   2:  

   3:<html>

   4:<head>

   5:<title></title>

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

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

   8:  

   9:<scriptsrc="http://modernizr.com/downloads/modernizr-latest.js"></script>
   1:  
   2:<script src="http://code.jquery.com/jquery-1.9.1.min.js">
   1:</script>
   2:<script src="http://code.jquery.com/ui/1.10.3/jquery-ui.min.js">
   1:</script>
   2:  
   3:<!-- Ignite UI Required Combined JavaScript Files -->
   4:<script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.core.js">
   1:</script>
   2:<script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.lob.js">
   1:</script>
   2:  
   3:</head>
   4:<body>
   5:<link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/themes/infragistics/infragistics.theme.css" rel="stylesheet" />
   6:<link href="http://cdn-na.infragistics.com/jquery/20141/latest/css/structure/infragistics.css" rel="stylesheet" />
   7:  
   8:<style type="text/css">
   9:         .container-info, .error-info {
  10:             margin: 10px 0;
  11:             font-weight: bold;
  12:         }
  13:  
  14:         .error-info {
  15:             color: #FF0000;
  16:         }
  17:</style>
  18:  
  19:<script src="http://modernizr.com/downloads/modernizr-latest.js">
   1:</script>
   2:<script src="http://code.jquery.com/jquery-1.9.1.min.js">
   1:</script>
   2:<script src="http://code.jquery.com/ui/1.10.3/jquery-ui.min.js">
   1:</script>
   2:  
   3:<!-- Ignite UI Required Combined JavaScript Files -->
   4:<script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.core.js">
   1:</script>
   2:<script src="http://cdn-na.infragistics.com/jquery/20141/latest/js/infragistics.lob.js">
   1:</script>
   2:  
   3:</head>
   4:<body>
   5:  
   6:<div id="igUpload1"></div>
   7:<div id="error-message" style="color: #FF0000; font-weight: bold;"></div>
   8:<script>
   9:  
  10:         $(function () {
  11:             $("#igUpload1").igUpload({
  12:                 mode: 'multiple',
  13:                 maxUploadedFiles: 4,
  14:                 maxSimultaneousFilesUploads: 2,
  15:                 autostartupload: true,
  16:                 progressUrl: "/IGUploadStatusHandler.ashx",
  17:                 onError: function (e, args) {
  18:                     showAlert(args);
  19:                 }
  20:             });
  21:         });
  22:  
  23:function showAlert(args) {
  24:             $("#error-message").html(args.errorMessage).stop(true, true).fadeIn(500).delay(3000).fadeOut(500);
  25:         }
  26:  
  27://more optional code
  28:
</script>

  10:

  11:</body>

  12:</html>

• Razor implementation (UploadMvc view )

   1:@using Infragistics.Web.Mvc

   2:  

   3: @{

   4:     Layout = null;

   5: }

   6:  

   7:<!DOCTYPE html>

   8:  

   9:<html>

  10:<head>

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

  12:<title>IgUpload MVC Helper</title>

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

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

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

  16:  

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

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

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

  20:  

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

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

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

  24:  

  25:</head>

  26:<body>

  27:<div>

  28: @(

  29:  Html.Infragistics().Upload()

  30:         .ID("igUpload1")

  31:         .Mode(UploadMode.Single)

  32:         .AutoStartUpload(true)

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

  34:         .ControlId("serverID1")

  35:         .Render()

  36: )

  37:  

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

  39:  

  40:<script type="text/javascript">

  41:             $(function () {

  42:                 $("#igUpload1").bind({

  43:                     iguploadonerror: function (e, args) {

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

  45:                     }

  46:                 });

  47:             });

  48:</script>   

  49:</div>

  50:</body>

  51:</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:

   1:<div>

   2:<divid="main"style="margin: 50px;">

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

   4:</div>

   5:<ig:WebUploadAutoStartUpload="true"ID="IGUpload"runat="server"ClientIDMode="Static"

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

   7:<AllowedExtensions>

   8:<ig:FileUploadExtensionExtension="pdf"/>

   9:<ig:FileUploadExtensionExtension="PDF"/>

  10:<ig:FileUploadExtensionExtension="Pdf"/>

  11:<ig:FileUploadExtensionExtension="PDf"/>

  12:<ig:FileUploadExtensionExtension="pDF"/>

  13:<ig:FileUploadExtensionExtension="pDf"/>

  14:<ig:FileUploadExtensionExtension="pdF"/>

  15:<ig:FileUploadExtensionExtension="PdF"/>

  16:<ig:FileUploadExtensionExtension="PDf"/>

  17:</AllowedExtensions>

  18:<FileExtensionIcons>

  19:<ig:FileUploadExtensionIconDefault="True">

  20:<Extensions>

  21:<ig:FileUploadExtensionExtension="pdf"/>

  22:</Extensions>

  23:</ig:FileUploadExtensionIcon>

  24:</FileExtensionIcons>

  25:<ClientEventsFileUploaded="fileUploaded"/>

  26:<ClientEventsFileSelecting="fileSelecting"/>

  27:<ClientEventsFileSelected="fileSelected"/>

  28:<ClientEventsOnError="onErrorHandler"/>

  29:</ig:WebUpload>

  30:<asp:HiddenFieldID="filePath"ClientIDMode="Static"runat="server"/>

  31:</div>

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

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

  34:</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:

1. 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)
2. 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!

As Infragistics celebrates its 25th Anniversary, we asked employees around the world:

Why do you love doing what you do with Infragistics? 

Here's what they had to say:

"I love working for Infragistics because after 7.5 years I still look forward to coming to work." - Alan, Developer Support Manager

"I love doing what I do which is paying the company’s bills, but I also love that Infragistics is a modern company and has many amenities that other companies do not offer.  The atmosphere is so calm and our very casual dress code just makes it a complete place to work." - Lillian, Accounts Payable Clerk, Accounting

"Before coming to work at Infragistics, I didn’t think I would ever find a work culture that I could thrive in.  Boy, was I wrong!  Infragistics is the first place I’ve ever worked where I actually look forward to coming to work each day ready for challenges and collaborating with some of the nicest and most genuine people I’ve ever had the pleasure of working with." - Michael, Senior Buyer, Operations

"I love working with the world's top companies – helping them mobilize their workforce with SharePlus feels like making a huge impact. I'm proud of the support I give." - Javier, Supervisor, SharePlus & ReportPlus, Enterprise Mobility

"I love the supportive management here." - Heshy, Consultant, Services

"I love working at Infragistics because there are so many amazing people here who are knowledgeable and passionate about a variety of different areas and they have taught me a lot over the years. It’s also great being a developer designing and building products for other developers because we have a great perspective on what would make customers’ lives easier." - Mike, Principal Software Engineer, Product Development/LOB

"I love the friendly people!  Even out of college, I continue to learn here." - Elizabeth, Principal Localization Engineer, Localization

"For me, it’s working with some of the smartest and most talented developers in the world. I consider myself a pretty smart guy, and yet everyone I work with is smarter than me." - Michael, Manager, Windows Forms Development

"At Infragistics, I get to help clients understand the process of design and create truly innovative software products. And it doesn’t hurt that I get to race motorcycles for the Infragistics/D3 Racing Team." - Kevin, Senior User Experience Architect, Services

"What I like in Infragistics is this relaxing working environment. Also, working with highly skilled people from many regions is also fortunate." - Yuki, Developer Support Engineer II

"I love working at Infragistics because it’s a cool work environment and the people are diverse and fun! I enjoy starting the work day going down to the cafeteria to be greeted by a friendly kitchen staff... The building has a creative, collaborative and colorful feel to it and we are encouraged to enjoy it. It motivates me to work hard and to do my part in making Infragistics the best it can be." - Monique, Staff Accounting

So now that you've heard why we love working here, tell us: why do YOU like working with Infragistics? What do you love best about our controls? How does Infragistics make it possible for you to build amazing apps? Share your story in the comments below!

Friends and colleagues,

I’ve submitted a presentation proposal to the 2015 SXSW Interactive Conference. If you like my proposal, please take a moment to visit the SXSW PanelPicker (http://panelpicker.sxsw.com/vote/32599) and vote for me. Thank you very much!

Kent

Software maintains the design traditions developed for print media. Mastheads, columns, and photo blocks are layout components carried over from the earliest printed documents. Even today’s interactive elements fall into these traditions. Print design was optimized for paper. Must software follow these principles?

Architecture found itself in a similar rut until Frank Lloyd Wright freed it from the boxed-in, Victorian layouts of the early 1900s. He removed rigid wall partitions, letting rooms flow together, which created more seamless layouts.

The traditions of print design create unnatural partitions in electronic content. This places an artificially created burden on the information architecture. Like rooms in a Wright house, content can be arranged into forms that allow it to flow in natural ways and become immediately accessible. The content, its form and the UI ultimately become one. Users will enjoy a more natural experience and have a deeper understanding of the content. I will show examples that bring this principle to life.

Please vote*

Interaction Design Needs a Frank Lloyd Wright

http://panelpicker.sxsw.com/vote/32599

SXSW 2015 will require that you create an account with them in order to vote. Please don’t let that slow you down! It’s easy.

Have you ever wondered what it takes to turn a small technology startup into a successful, long-lasting company? On the cusp of Infragistics’ 25th anniversary, we sat down with visionary President and CEO, Dean Guida, to find out how he built a solid foundation for a company that is still going strong a quarter of a century later. Where do you find good investors? How do you choose the right location? When do you need to think about policy and procedures? Start small or think big from the beginning? We cover all this and more –jump right in and see how you can create a startup that endures!

[youtube] width="640" height="360" src="http://www.youtube.com/embed/dQAeIemzcgE" [/youtube]

Infragistics team members Kent Eisenhuth and Kevin Richardson have each prepared in-depth presentations about interaction design and innovation, but they need your help to get them to SXSW in March.

Click on the entry titles below to give each entry the Green Thumbs Up!

Here's how to vote:

1. Visit the SXSW Panel Picker here.
2. Click on the orange "Sign In" in the upper right hand side of the page. If you don't already have an account, click "Create Account" below the blue Sign In bar on the page that pops up.
3. Here you'll be prompted to create an account, which only takes a few simple steps. *Note: you'll have to confirm your account by clicking the link in the email that SXSW will send to you.
4. Once you've confirmed your account and logged in, click on the links in this blog once again to view each entry and click the thumbs up in the left hand side of your screen to Vote for each presentation. Note: You can vote for multiple videos, so be sure to check out both presentations and give them the Green Thumbs Up!

Vote for Kevin:Ensuring Innovation in a Mediocre (Business) World

[youtube] width="640" height="360" src="http://www.youtube.com/embed/nKR-Xb--EDs" [/youtube]

Vote for Kent: Interaction Design Needs a Frank Lloyd Wright

[youtube] width="640" height="360" src="http://www.youtube.com/embed/9L-TrwEV-jg" [/youtube]

Every vote brings Infragistics closer to SXSW, so be sure to stop by the Panel Picker today to cast your vote - and we hope to see you at the event this spring!

Missed the Infragistics Tech News last week? Here's your roundup of the top articles!

5. When Developers Design (The Real Adam)

4. Why is Software So Hard to Develop? (Dr. Dobbs)

3. What I Tell All New Programmers (Seph)

2. If Programmers Were Cats (SD Times)

1. 5 Best Practices for Single-Page UX Design (Designmodo)

If you’re interested in learning more about Twitter Bootstrap, a great place to start is the book store.  Below are three of the best Twitter Bootstrap print resources I’ve found so far. And before you ask, yes, they have information for beginners, intermediates, and experienced users. 

• Twitter Bootstrap Web Development How-To
  • Written in 2012 by David Cochran, Associate Professor of Communication at Oklahoma, is an introduction to building sites using Twitter Bootstrap. Beginners and intermediate developers will find this particularly helpful. 

• Bootstrap Site Blueprints
  • This book is written by the same author above, but is geared towards those who come in with a firm grasp on the fundamentals.  Cochran takes his first introduction book to the next level for advanced users. 

• Extending Bootstrap
  • This book is targeted for intermediate front end developers and designers.  Christoffer Niska, web developer from Finland published this in March 2014 to help you build, customize, and utilize third party plugins. 

I hope you found this list useful.  If you know any other great Twitter Bootstrap books please let me know at jhaddad@infragistics.com.

For the first time in Sofia an event dedicated only  to Unity Game Engine ( Creating Cross Platform Games with Unity ) will be held on Tuesday, August 26, 2014, 7:00 PM. This presentation is supported from Infragistics Inc, Microsoft Bulgaria and Infragistics Friends User Group (BI & .Net Geeks). Initially the event is arranged to be held at Microsoft Bulgaria office, but because of the  great interest from developers in Bulgaria we considering to move the event in a larger space outside of Microsoft Bulgaria venue.

There are over 120 people registered for the event now next wishing to register need to add themselves in a waiting list here before they will receive tickets. The number of the tickets depends of the venue space.

What is Unity Game Engine?

Unity is a cross-platform game creation system developed by Unity Technologies, including a game engine and integrated development environment (IDE). It is used to develop video games for web sites, desktop platforms, consoles, and mobile devices.

With an emphasis on portability, the graphics engine targets the following APIs: Direct3D on Windows and Xbox 360; OpenGL on Mac, Windows, and Linux; OpenGL ES on Android and iOS; and proprietary APIs on video game consoles.

If you're looking for fun and exciting apps to start writing, you should consider games. Not a game developer? No problem! In this session I'll cover all the basics of using the Unity game engine, along with your current C# or JavaScript skills, to get started writing cross-platform games. We'll look at how to navigate the Unity IDE, as well as how to create scenes, add objects to scenes, and add animations to game characters. Join me for this fun and interactive session where your cross-platform games are limited only by your imagination.

For now the event venue is Microsoft Bulgaria office (below) :

Obviously one of the reasons for the great interest is the name of the speaker - Brian Lagunas.

Brian Lagunas is a Microsoft MVP, a Microsoft Patterns & Practices Champion, Director of Technology for INETA, co-leader of the Boise .Net Developers User Group (NETDUG), board member of Boise Code Camp, speaker, trainer, author, and original creator of the Extended WPF Toolkit. He is a multi-recipient of the Microsoft Community Contributor Award and can be found speaking at a variety of user groups and code camps around USA. 

Brian currently works at Infragistics as a Product Manager for WPF and Silverlight components, and the new NetAdvantage for Windows UI control suite.

In his spare time he authors courses for Pluralsight, blogs about XAML technologies, and hosts XAML TV.  The easiest way to find Brian is on twitter at @BrianLagunas. You can find more info about Brian here.

We opened the waitlist for those who want to visit a presentation entitled "Creating Cross Platform Games with Unity", but failed to get tickets. Check it here: https://unitygames.eventbrite.com . If there are more people in this list Microsoft Bulgaria will try to ensure larger room for this event. For now only people with tickets will have access to attend the event.

If you have any questions feel free to contact the Event Admins at mmateev@infragistics.com

You can learn more about “Creating Cross Platform Games with Unity” event in Sofia if you follow us on Twitter @mihailmateev  and @Infragistics and stay in touch on Facebook, Google+, LinkedIn and Infragistics Friends User Group !

Warm Regards,
Team  Infragistics Friends

This week's hot topics include lots of tutorial style articles. Check 'em out!

5. 20 Resources for New Computer Programmers (Vancouver Gadgets)

4. Learn AngularJS: 1 Hour (Debug Mode)

3. Stunning Posters about the Principles of Design (Designer Daily)

2. Why Software Engineers Should Maintain a Blog (Server Zone)

1. Developing a Large Scale Application with a Single Page Application Using AngularJS (CodeProject)

Infragistics Friends group( Bulgarian BI & .NET Chapter) with the help of Infragistics Inc.  and Microsoft organized a presentation on “Creating Cross Platform Games with Unity”

The event was held on Tuesday , August 26th, 2014  at Betahaus  Sofia, 56-58 Krum Popov Str. 1407 Sofia, Bulgaria. This was the first public community  event about Unity Game Engine in the region.

This presentation was a practical session about how to create multiplatform games using Unity – almost 2 hours code samples in walkthrough demo, demonstrating how to create a 3D action game from scratch . 

Unity is a game development ecosystem: a powerful rendering engine fully integrated with a complete set of intuitive tools and rapid workflows to create interactive 3D and 2D content; easy multiplatform publishing; thousands of quality, ready-made Store and a knowledge-sharing community.

Unity is based on Mono which allow to have multi platform support for the most of mobile and desktop platforms – WIndows Phone, iOS, Android, WIndows UI, Mac, etc..  It is one of the most popular 3D engines last years.

Speaker was  Brian Lagunas.

Brian Lagunas is a Microsoft MVP, a Microsoft Patterns & Practices Champion, Director of Technology for INETA, co-leader of the Boise .Net Developers User Group (NETDUG), board member of Boise Code Camp, speaker, trainer, author, and original creator of the Extended WPF Toolkit. He is a multi-recipient of the Microsoft Community Contributor Award and can be found speaking at a variety of user groups and code camps around USA. 

Brian currently works at Infragistics as a Product Manager for WPF and Silverlight components, and the new NetAdvantage for Windows UI control suite.

In his spare time he authors courses for Pluralsight, blogs about XAML technologies, and hosts XAML TV.  The easiest way to find Brian is on twitter at @BrianLagunas. You can find more info about Brian here.

Summary:

• There was more than 155 registrations.
• 130 attendees in place
• 2 hours presentation
• The first community event about Unity Game Engine.

Brian is talking with attendees minutes before the presentation

Brian Lagunas in action!

It is time for demos:

Final announces

Unity Game Engine Event Team members from Infragistics

More pictures from this event are available here.

You can learn more about “Creating Cross Platform Games with Unity” event in Sofia if you follow us on Twitter @mihailmateev  and @Infragistics and stay in touch on Facebook, Google+, LinkedIn and Infragistics Friends User Group !

Warm Regards,
Team  Infragistics Friends

Infragistics Friends group and jQuery Sofia with the help of Infragistics Inc.  organized a presentation on the following topic:  AngularJs Tips and Tricks .

The event was held on Wednesday, August 27th, 2014 at Infragistics Bulgaria Office, 110B, Simeonovsko Shosse Bul., Sofia, Bulgaria.

Team  AngularJS Sofia do much to be done the first AngularJS event in this region. The event was of interest to all specialists, using JS / JavaScript frameworks – developers, visual designers, UX, managers. The meeting was supported by Infragistics Inc., Infragistics Friends and jQuery Sofia user groups .

This was a presentation of  two parts for nearly two hours. First part was a deep dive into Angular’s injector object, explaining how dependency injection is working. In the second part, the lecturer shared tips and tricks that he learn by working with AngularJs for more than an year.

The speaker was Radoslav Stankov ( rstankov.com, github.com/rstankov, @rstankov ) .

Radoslav is a web developer for more than a decade. He believes that frontend and backend are equally important. After several years working with Backbone.js, he is sure that AngularJs is the next big step in the evolution of web development.

Summary:

• There was 140 registrations + 39 people in the wait list.
• more than 100 attendees in place
• 2 hours presentation
• The first community event focused only on  AngularJS in Sofia.

Registration:

A minute before the start of the presentation

Radoslav is talking about Angular’s injector object

Tips and Tricks

Some guests…

It is time for demo:

More pictures from this event are available here.

You can find slides here: https://speakerdeck.com/rstankov/angular-tips-and-tricks
Code samples are available in GitHub here: https://github.com/RStankov/talk-angular-tips-tricks

Follow this event and other JS related events on Twitter with hashtag #jssaturday.

You can learn more about AngularJS event in Sofia if you follow us on Twitter @mihailmateev  and @Infragistics and stay in touch on Facebook, Google+, LinkedIn and Infragistics Friends User Group !

Warm Regards,
Team  AngularJS Sofia

Here’s a cool data viz story. A large weekly magazine in Europe has recently published some statistics about Ebola cases in four African countries. It’s in German, but bear with me here.

Per country, the outer bubble depicts the number of Ebola cases and the inner bubble shows how many of those have died.

If you read the other parts of this blog series about user-centered data visualization, you’ll recall the reasons why using the size of bubbles to convey numbers is not a good idea. We’re just not wired to estimate and compare areas well.

When I tried to replicate this visualization I found that the size of the inner bubbles (representing the number of people that died) is incorrect. They’re too large. But even without that, using the bubbles in bubbles leads to something that I find alarmist. You look at those bubbles and you see that the inner bubbles are almost the same size than the outer bubbles. Consequently, you get the sense that most people who got infected also died. Ebola is deadly and currently no vaccination is available to the public. However, based on just these numbers, it’s not the case that almost everybody has died.

Here’s a visualization that shows the percentage of people who died vs. those who have not died. For the purists out there who hate pie charts, only look to the right! It shows that for the two countries on top (Liberia and Sierra Leone) most people have not died (sadly, I have to add “at the point of assessing the numbers”).

I wrote an email to the magazine who forwarded it to their graphic designers. After some praise for their magazine (which I’ve been reading for a long time) I provided them the reasons why bubble charts don’t work well, showed them the pie chart/bar chart above and humbly suggested to use pie or bar charts to show that kind of data.

I didn’t hear back from them, but two issues later, they published an update on the situation for those four countries.

They did use bar charts and these convey the situation much better. It’s much easier to estimate the length of these bars than the size of the bubbles. I believe that people oftentimes shy away from using the classic and established chart types because they fear they look boring and non-sexy. From a viewpoint of a magazine with a circulation of 900,000 copies a week, I could understand that. Yet, they were open to make changes and looking at this new chart, I don’t think there’s an issue with attractiveness (probably should mention that the red, black and white are their three brand colors). 

So let’s heal the world of data visualization one chart at a time! More importantly, let’s hope that an effective vaccination is made available to those who need it soon.

For the third time in Bulgaria SQLSaturday will be held on 11 of October, 2014  at Infragistics Bulgaria office: 110 B, Simeonovsko Shosse Bul., Office Floors II and III, 1700 Sofia, Bulgaria.

The event will be of interest to all specialists, using any version of SQL server and/or other Data / BI related technologies from Microsoft  - developers, administrators, analysts, managers. The conference is supported by Infragistics, Microsoft Bulgaria and all Microsoft user groups in this region.

After the successful SQLSaturday #152 Bulgaria 2012 and  SQLSaturday #199 Bulgaria 2013 we are proud to announce that PASS entrusted Infragistics to host SQLSaturday #311 Bulgaria 2014

What is SQL Saturday:

• SQL Saturday is a conference of PASS (Professional Association for SQL Server) www.sqlpass.org,www.sqlsaturday.com
• The event was announced officially on PASS SQLSaturday site :
• The conference shall be held on Saturday of pre-selected location.

Some statistics about SQLSaturday Bulgaria 2014:

• 83 suggested topics ( 32 speakers from 17 countries )
• 276 registrations until now

Our goals:

• Up to 400 registrations
• 250 to 300 attendees in place
• 5 tracks and up to 35 sessions
• The biggest event for Microsoft SQLServer, organized in Bulgaria and in the region

You can take a look a pictures from previous events below:

SQLSaturday #152 Bulgaria 2012

SQLSaturday #199 Bulgaria 2013

The conference will be interesting for those of you who wish to learn more about SQL Server,BI, Data Mining, Windows Azure,  Data Visualization , Open source Solutions with SQL Server and Microsoft Azure,  NoSQL databases and data visualization in the mentioned above areas.  You can register here. The number of registrations is limited

The preliminary schedule will be announced around 10 of September on the schedule page.

Sponsors who are interested in the event can register here.

To see all news about SQLSaturday Bulgaria 2014  follow #SQLSatBulgaria on Twitter and SQLSaturday Bulgaria Facebook page .

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

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

Warm Regards,
SQLSaturday Bulgaria Team

For the first time in JSNext Bulgaria js.next("Bulgaria"); was held on November 23, 2014.  The conference was hosted at the Sofia Event Center.  JSNext is the biggest event in Bulgaria and the whole region for JS / JavaScript technologies. The event includes various levels of sessions with different target groups and featuring some of the experts in the field on developing and designing great WEB , Node.js , hybrid mobile and other applications.

What is JSNext Bulgaria ?

js.next(“Bulgaria”) is an one day event with sessions dedicated to all that is JavaScript. It is a chance for the local community to immerse in their favorite web technologies.

Following the successful events from the past two years, js.next(); will inherit the jQuery Bulgaria conference. Now with much broader topic coverage on the bleeding edge of Web technologies!

Why JSNext?

We will try to cover all cutting-edge and future JS-related technologies ( the JavaScript vNext related technologies). In this context name jQuery is not reasonable, because this event will cover all new JavaScript related frameworks and platforms. 

Who is organizing the event?

After being part of the organization of the first ever JavaScript Saturday in Bulgaria and organizing the first conference in Bulgaria dedicated to jQuery, with the extremely positive feedback from all of you, The jQuery Sofia group is back for yet another event this year!

&

Our goals for 2014:

• Format : 1 days, training day and main event with 4 parallel tracks, 20 sessions, more than 15 speakers
• Language : English/Bulgarian
• Entrance : 20 EU / free for sponsors and community leads
• Up to 900 attendees
• The biggest event for developers in Bulgaria for 2014
• The biggest event for JS and WEB developers in the region for 2014

You can visit JSNext Bulgaria website – www.jsnext.net

Stay in touch with the latest news - social links and contacts are below. Follow the buzz using #jsnextconf.

If you want more information about the event feel free to contact the Event Admins at mmateev@infragistics.com

Additional information also can be found at JSNext Bulgaria website (www.jsnext.net ) , Facebook page JSNext  ( https://www.facebook.com/jsnext) and  on Twitter @jsnextconf

Call for speaker is open and if you are an experienced JS specialist and a speaker – you can submit your suggestions for topics here:  http://www.jsnext.net/sessions/submit

Tickets will be on sale on September 10. You can by tickets here: https://jsnext.eventbrite.com

If you are company and want to meet possible partners, clients and employees, or to position your brand in the region – you can become a sponsor. Sponsorship offer is available here: http://www.jsnext.net/info/jsNext-Bulgaria-2014-Sponsorship-package.pdf

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

Warm Regards,
Team JSNext Bulgaria

With the holiday weekend behind us, I'm sure it's taking a little extra motivation to get you back into the swing of work. Here are last week's top articles from the Infragistics Community to get you inspired!

5. Why Are PC Sales Up and Tablet Sales Down? (TechCrunch)

4. Typographic Programming Language (Josh on Design)

3. Fluentx: A Special .NET Library (CodeProject)

2. Which Programming Languages Are Most Popular Right Now? (New Relic)

1. Apple Doesn't Want You Posting Your Messy iOS Screenshots on the Web Anymore (Cult of Mac)

Developing software solutions does not only involve writing code. A significant amount of time is spent on debugging - finding and fixing errors and problems. Initially a developer needs to test and debug his own code. Then when feedback arrives from dedicated testers, they need to debug the code to find any defects highlighted there.

It is fair to say that approximately 50% of the time a developer spends working on a project is spent on debugging code. As a result, it is really important to have good debugging tools to help speed up project work.

The most widely used tool for developing C# applications is Visual Studio. There are some open-source alternatives, but Visual Studio is the best tool available. Supported by the community, it comes with a wealth of help and support information for those that need it.

Visual Studio started out as a pure development tool. Over the years new versions have been released which added a host of project analysis, test, and management features. It is now used by software designers, testers, and project managers alike. At its core, however, Visual Studio is still very much a developer tool, so here are our top tips for debugging applications in C#.

1. Step through code and add breakpoints. See what code is executed, which variable values are assigned, and which break only at certain points when a condition is true. What is the stacktrace for any exceptions?
2. Use Intellitrace to record code execution. Stepping through code can be time consuming. Using Intellitrace, certain actions can be recorded to get a better understanding of the history of events. See here for more information about Intellitrace.
3. Attach to a process. It is possible to attach to every process running on the system to see what’s happening e.g. If a third-party tool is used and an error occurs, some information about the exception will be shown if Visual Studio is attached to that process.
4. Depending on the application, extra logging can be enabled:

• If debugging WCF services, extra tracing can be enabled, see here for a walkthrough.
• If debugging SharePoint applications, Verbose logging can be enabled in Central Administration.
• When debugging websites hosted in IIS, logging in IIS can also be used to debug the application.

• A tester transforms a paper test case into a Coded UI test in Visual Studio. When it fails, this test case can be shared easily with the developer. This makes it a lot easier to debug for the developer.
• If ‘performance testing’ has raised defects, a load can be simulated by using load tests.
• A big advantage of this ‘automated testing’ approach is that by doing so, test cases can be used for automated regression tests.
• To explore some automated testing tools for yourself, check out the ones that Infragistics offers, free for 30 days.

Useful add-ons to Visual Studio

A number of add-on tools exist that make Visual Studio even more useful:

• Resharper is the most commonly used add-on for Visual Studio. It extends Visual Studio in many ways, e.g. automated code refactoring, code templates, easier browsing through a solution, etc. When debugging applications that rely on third party components, like applications built on SharePoint, Resharper offers the possibility to step through those third party DLL’s. It will decompile the code on-the-fly and let the developer debug the code as if it was his own code.
• Instead of Resharper, Reflector can also be used to decompile and debug third party DLL’s.
• DevPartner Studio extends the debugging features of Visual Studio. See here for a full list of features.
• OzCode adds some nice features while debugging code. It improves the way values in variables are shown, and also makes it easier to see what a function returns.

NuGet is a powerful ecosystem of tools and services. It was introduced in 2010 as an open source package manager for the Microsoft development platform including .NET.  NuGet is the easiest way to improve and automate your development practices.

When you install a package via NuGet, it copies the library files to your solution and automatically updates your project. That means adding references, changing config files, replacing old version script files, etc.

NuGet is available for Visual Studio 2010, Visual Studio 2012 and Visual Studio 2013, through the Visual Studio Extension Manager. In fact, since Visual Studio 2012, NuGet is included by default. On more information on how to install NuGet and how to get going with it, read the official Nuget documentation.

Ignite UI Trial is available to explore as a NuGet package since its introduction with version 12.2. After installing the package, you will have a project with a preconfigured sample application that you can explore and play with. You will also get a 30 day free trial of Ignite UI jQuery controls so you can create your own hybrid apps that look native on every mobile device and the desktop.

You can see the Ignite UI Trial`s page on nuget.org, where you can check the current dependencies and the version history of the package.

There are two ways to install the Ignite UI NuGet package to your project, using the GUI or using the console, and we will follow both procedures below.  All the steps and screenshots are taken in Visual Studio 2013 but if you are using Visual Studio 2010 or Visual Studio 2012, the differences are negligible. Don`t worry if you haven`t used NuGet before as this example will guide you step-by-step through the procedure.

First create a new ASP.NET Web Application project. You can name it IgniteUIProject

Select Empty project.

After your project is created, your Solution Explorer will look like this:

At the moment, your project contains only the three default nodes: Properties, References and Web.config.

Installing Ignite UI Trial via GUI

To install the Ignite UI NuGet package using the GUI, you should right-click on the project name and select Manage NuGet Packages… from the context menu.

This will open the Manage NuGet Packages dialog window. In this dialog you can see all the packages that are available for you to use in your project.

Now enter “Ignite UI” in the search field that is placed in the top right corner of the dialog window.

When you select Ignite UI Trial, you will see more information for the package in the right panel. By installing Ignite UI Trial, you guarantee that you will get the latest version of Ignite UI as this package is updated with every Service Release. In the right panel, you can also see the libraries that this package depends on. You should not worry about those – they will be automatically installed to your project with the package itself.

Click the Install button to install Ignite UI Trial. You will see a new dialog popping up, showing you the progress of the installation and what exactly is installed by the package to your project. This installation takes only a few seconds and after Ignite UI Trial is installed, you can click the Close button to close the Manage NuGet packages dialog window and return to your project.

Installing Ignite UI Trial via Package Manager Console

Here we will describe how you can add Ignite UI Trial package using the Package Manager Console. Using the Console may be a bit faster as you do not need to search for the package that you want to install.

To show the Console, navigate to Tools in the Visual Studio`s menu and after hovering NuGet Package Manager, select Package Manager Console.

The Package Manager Console will be shown at the bottom of the screen and you just need to enter “Install-Package IgniteUI.Trial” to initiate the installation.

When the installation is finished, you will see a message in the Console that Ignite UI Trial is successfully added to the project.

What Ignite UI Trial package is installing

As you can see, some new files and folders are added to your project.

Inside the Content folder are placed the css files that the framework provides and four different themes that are at your disposal. By default, the selected theme for the sample application is metro but you can choose between the iOS7 theme, infragistics theme and its popular predecessor infragistics2012 theme. The css files and the themes for mobile applications are also placed inside the Content folder. If you are developing a mobile app, you can set a specific theme based on the OS on which the app will be run. You can select between android, ios and windowsphone themes.

Inside the Images folder are placed the image files that are used in the sample application. They are all included in the Infragistics subfolder. If you want to use your own images, it would be best to place them inside the Images folder – this way your project will stay clear and well organized.

The Infragistics` JavaScripts are placed inside the Scripts folder as well as all the libraries that the package depends on.

Inside the packages.config file you can see all the installed packages and their versions.

Finally, you have the demo html file ignite-ui-demo.html. There is a Japanese version of the demo file, as well.

Now, let`s run the English version of the application sample. Right-click on the html file and select View in Browser. This will open the sample in your default browser.

So, you can explore the sample and see how Infragistics` Splitter, Tree, Map and DataChart components work. You can edit the sample or create a completely different sample from scratch, using every Ignite UI component you want.

As you saw, using the Ignite UI Trial package is the easiest way to get started with building your own web project. With Ignite UI you can create a single solution that crosses platforms and devices with an integrated project. Need one app that looks native to iPad, iPhone, Android phones and tablets, Windows Phone, the Surface and also looks great on the desktop? That's no problem with Ignite UI. Feeling excited? Give it a try right now – Inspiration is just a click away!

Amazon just gave me something high on my wish list of improvements to their website. They recently added the ability to drag and drop the items in your wish list to reorder the list. I’d like to think it was all due to my December 20^th, 2013 blog post, Amazon’s Wish List Problem, but in reality, it was probably something they had intended to do for a long time.

Previously, Amazon placed your most recently added products at the top of your wish list. As you can imagine, gift givers tend to notice and buy the items toward the top of the list rather than the items far down the page. Although Amazon provided the ability to add comments and indicate your priorities next to each item, those descriptions were easy to overlook.

As a result, the only way to move items to the top of your wish list was an awkward workaround of clicking into the product page for the items you wanted at the top of the list and clicking Add to Wish List again, which moved those items at the top of your wish list.

Now, with the recent improvements, Amazon added handles next to each item on your wish list, which appear on rollover to indicate that you can drag and drop a product to another position (as shown in Figure 1).

Dragging items around the list is an extremely easy and natural way to rearrange your list. To make it easier to move items far down the list, they also added a “Top” link that moves the item to the top of the list with one click (as shown in Figure 2).

Both of these changes are great improvements, providing absolute control over the order of the items in your wish list. So thank you, Amazon, for giving me the item on the top of my wish list!

Here's this week's roundup of top articles in the Infragistics Community! Check 'em out!

4. Idiot Buttons: The Placebo in UX Design (The Usabilla Blog)

3. Performance Considerations of Class Design and General Coding in .NET (CodeProject)

2. Top 6 Websites to Learn Programming Languages (DesignCular)

1. AngularJS vs. Backbone.js vs. Ember.js - Choosing Your JS Framework (airpair)

The event was held on Friday, September 12th at Die börse, Wolkenburg 100, 42119, Wuppertal, Germany. NRW Conf is one of the oldest .NET community events in Germany, organized from Constantin Klen and Daniel Fisher  for the  the eighth time.

Infragistics was a four bar sponsor of  NRW Conf. Company had a booth, company presentation and provided swags for the event raffle. The company was represented form Kiril Matev and me ( Mihail Mateev ).

Infragistics also had a short sponsorship presentationabout Indigo Studio ( the amazing UI prototyping tool, offered from Infragistics ) during the lunch break – speaker was Kiril Matev  .

There was huge interest in the other products offered by Infragistics, as Ignite UI, XAML Components, Enterprise Mobility (Share Plus and Report Plus).

You can take a look at some pictures from this awesome event:

NRW Conf Keynote:

Infragistics booth – Kiril is talking with ateendees about Infragistics dev tools:

Kiril is talking about Indigo Studio

NRW Conf 2014 Closing with Constantin Klen and Daniel Fisher

If you want more information about the event and Infragistics community feel free to contact me at mmateev@infragistics.com or to contact community@infargistics.com

Follow this event on Twitter with hash tag  #nrwconf .

You can learn more about the Infragistics events if you follow us on Twitter @mihailmateev  and @Infragistics and stay in touch on Facebook, Google+, LinkedIn and Infragistics Friends User Group !