Thursday, August 8, 2013

vs 2012 - The primary reference could not be resolved because it has an indirect dependency on the framework assembly

I started getting this error after changing the target framework in build configuration for my web application in Visual Studio 2012.












To resolve this I had to unload the project and reload it into the solution.Right Click on the application in VS 2012 solution and select Unload Project in the context menu.

























Reload the project by right clicking on the project that is not available



asp.net - Method not found: 'Void System.Web.UI.ScriptResourceDefinition.set_LoadSuccessExpression(System.String)'.

You will get this error if you try to host your application on IIS Application pool running on .Net. 4.0 and your web application is built in .Net 4.5.By default the selected target framework for Visual Studio 2012 is .Net 4.5.

Right Click on your application in Visual Studio 2012, select the build configuration and choose .Net 4.0 framework.



Wednesday, August 7, 2013

asp.net - System.BadImageFormatException: Could not load file or assembly '' or one of its dependencies. An attempt was made to load a program with an incorrect format

You will get this error if you try to host a 32 bit web application on IIS7.To fix this error set "Enable 32 bit applications" flag to true in AppPool Advance Settings.




Wednesday, July 31, 2013

vs 2012 - The following module was built either with optimizations enabled or without debug information

I started getting this warning window while debugging one of my projects and to workaround it I had to change my debugger settings.






Thursday, July 18, 2013

asp.net - Access Master Page Label from Content Page

The below screenshots show how one can have a label on master page for displaying messages to the user using the application.

Site.Master 














Site.Master.cs 















Default.aspx 
Default.aspx.cs


Friday, June 21, 2013

Saving changes not permitted

If you try to use the SQL Server designer for making changes to the table you just created, then you will get a dialog box that tells you that you cannot save the changes.One work around this issue is to disable the option "Prevent saving changes that require the table to be re-created".

To disable this option see the screenshots below.
































































HTH

Friday, May 31, 2013

asp.net - OutputCache, page level caching dynamically

I wanted to setup page level caching for one of the web application I was building since the content of the site came from a database and the content was not updated frequently.
Instead of using the declarative syntax
<%@ OutputCache Duration="20" VaryByParam="param1;param2"%> 
I use the following CachePage() method that enables caching based on configuration entries.

More on various caching techniques here (http://msdn.microsoft.com/en-us/library/y18he7cw(v=vs.100).aspx)

The following configuration entries help control how often the pages are to be cached and the query string parameter values that would invalidate the cache.

Web.Config

<add key="ENABLE_PAGE_CACHE" value="true"/>
<add key="CACHE_DURATION_UNIT" value="SECONDS"/><!--SECONDS,MINUTES,DAYS,HOURS-->
<add key="CACHE_DURATION_VALUE" value="10"/>
 <add key="CACHE_CLEAR_PARAMS" value="param1;param2"/><!--query string parameters separated by ; -->

ASPX Page

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace CachingExample
{
    public partial class _Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
       {
           if(!IsPostback)
          {
               //GetPageContentFromDB
               if(Convert.ToBoolean(ConfigurationManager.AppSettings["ENABLE_PAGE_CACHE"]) 
               CachePage();
            }
            
        }
    }
}

CachePage() Method

protected void CachePage()
        {
            try
            {
                string sCacheDurationUnit = ConfigurationManager.AppSettings["CACHE_DURATION_UNIT"];
                int iCacheDurationValue = Convert.ToInt32(ConfigurationManager.AppSettings["CACHE_DURATION_VALUE"]);
                string [] saCacheVaryParam = ConfigurationManager.AppSettings["CACHE_CLEAR_PARAMS"].Split(';');

                switch (sCacheDurationUnit)
                {
                    case "SECONDS":
                        Response.Cache.SetExpires(DateTime.Now.AddSeconds(iCacheDurationValue));
                        break;
                    case "MINUTES":
                        Response.Cache.SetExpires(DateTime.Now.AddMinutes(iCacheDurationValue));
                        break;
                    case "HOURS":
                        Response.Cache.SetExpires(DateTime.Now.AddHours(iCacheDurationValue));
                        break;
                    case "DAYS":
                        Response.Cache.SetExpires(DateTime.Now.AddDays(iCacheDurationValue));
                        break;
                    default:
                        Response.Cache.SetExpires(DateTime.Now.AddSeconds(iCacheDurationValue));
                        break;
                }
                
                Response.Cache.SetCacheability(HttpCacheability.Public);
                Response.Cache.SetValidUntilExpires(true);

                foreach(string sCacheVaryParam in saCacheVaryParam)
                    Response.Cache.VaryByParams[sCacheVaryParam] = true;

            }
            catch (Exception ex)
            {
                LogError("Caching error " + _oSessionInfo.sMachineId + ".", _oSessionInfo, null, ex);
            }
        }

Monday, April 1, 2013

c# - StreamWriter Performance

I have written several programs that read data from raw input text files,extract required fields and write to tab delimited output text files.The files are usually few GB in size.I wanted to test the performance of the StreamWriter class and below are the results.

StreamWriter when used with a buffer size greater than the default buffer size of 1024 KB performed better.

Run 1: 350 MB Input file with default buffer


using System;
using System.Diagnostics;
using System.IO;
using System.Text;

namespace FileWriterPerf

{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            try
            {
                using (StreamWriter oWriter = new StreamWriter(@"c:\File1.txt"))
                {
                    foreach (string sLine in File.ReadLines(@"c:\File.txt"))
                        oWriter.WriteLine(sLine);

                    oWriter.Flush();

                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;

            string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",

                ts.Hours, ts.Minutes, ts.Seconds,
                ts.Milliseconds);
            Console.WriteLine("RunTime " + elapsedTime);
            Console.Read();
        }
    }
}














Run 2: 350 MB Input file with 64MB buffer size
using (StreamWriter oWriter = new StreamWriter(@"c:\File1.txt",true,Encoding,ASCII,65536))


Run 3: 2 GB Input file with default buffer size
using (StreamWriter oWriter = new StreamWriter(@"c:\RawFile1.txt"))














Run 4: 2 GB Input file with 64MB buffer size
using (StreamWriter oWriter = new StreamWriter(@"c:\RawFile1.txt",true,Encoding,ASCII,65536))













Friday, March 29, 2013

c# - StreamReader vs File.ReadLines

Performance testing
Machine Configuration: Dell E6420 4 GB Ram 32- Bit i-7 Core (cores dont matter in this case.Parallel test for later)
Input File: 350+ MB tab delimited txt file

StreamReader


using System;
using System.Diagnostics;
using System.IO;

namespace FileReaderPerf

{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            try
            {
                  using (StreamReader oReader = new StreamReader(@"c:\File.txt"))
                  {
                      string sLine = oReader.ReadLine();
                      while (sLine != null)
                      {
                          Console.WriteLine(sLine);
                          sLine = oReader.ReadLine();
                      }
                  }                
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;

            string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",

                ts.Hours, ts.Minutes, ts.Seconds,
                ts.Milliseconds);
            Console.WriteLine("RunTime " + elapsedTime);
            Console.Read();
        }
    }
}


























StreamReader using a larger buffer size

using (StreamReader oReader = new StreamReader(@"c:\File.txt",Encoding.ASCII,false,8092))
























File.ReadLines

using System;
using System.Diagnostics;
using System.IO;

namespace FileReaderPerf
{
    class Program
    {
        static void Main(string[] args)
        {
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            try
            {
                 foreach(string sLine in File.ReadLines(@"c:\File.txt"))
                            Console.WriteLine(sLine);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            stopWatch.Stop();
            TimeSpan ts = stopWatch.Elapsed;

            string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
                ts.Hours, ts.Minutes, ts.Seconds,
                ts.Milliseconds);
            Console.WriteLine("RunTime " + elapsedTime);
            Console.Read();
        }
    }
}


Friday, March 22, 2013

c# - Managed Parallelism,Threading using Task Parallel Library

One of my recent task was to migrate the .Net 2.0 code for processing a few thousand files.The original code used Managed Threading using ThreadPool. I wanted to update this code using .Net4.0 Task Parallel Library's Parallel.Foreach for this task.(Source: http://msdn.microsoft.com/en-us/library/ff477033.aspx)


Below is a very very trivial example.

In the code below I am getting all the folders in a given directory and processing them in parallel using Parallel.Foreach. I am using Environment.ProcessorCount(Source: http://msdn.microsoft.com/en-us/library/system.environment.processorcount.aspx ) to get the total number of core processors on my server to control the total number of cores being used for processing.In the first example I am using all the 8 cores on my server.

using System;
using System.Threading.Tasks;
using System.IO;

namespace ManagedParallelism
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                DirectoryInfo oDirectoryInfo = new DirectoryInfo(@"C:\MyFolder");
                Parallel.ForEach(oDirectoryInfo.GetDirectories(), new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, (oDirectory) =>
                {
                        Console.WriteLine("TIMESTAMP: {0} INFO: PROCESSING DIRECTORY:{1}", DateTime.Now, oDirectory.Name);
                        ProcessDirectory(oDirectory);
                        Console.WriteLine("TIMESTAMP: {0} INFO: COMPLETED DIRECTORY:{1}", DateTime.Now, oDirectory.Name);
                        
                });
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.StackTrace);
            }
            Console.Read();
        }
        /// <summary>
        /// Function to process each of the sub directories
        /// </summary>
        /// <param name="oDirectory"></param>
        private static void ProcessDirectory(DirectoryInfo oDirectory)
        {
            //ToDo: Add code to process each sub directory in the Raw Files Folder
            //throw new NotImplementedException();
        }
    }
}
















By changing the above code to 

Parallel.ForEach(oDirectoryInfo.GetDirectories(), new ParallelOptions { MaxDegreeOfParallelism = (Environment.ProcessorCount - 4)}

parallelism can be limited to 4 cores.This value would ideally come from a configuration file.
















Task Parallel Library does make threading easy !