Debug installer

17 June 2009
Comments (0)

The installer created using WIX was failing. I had no option but to perform following on command line:

msiexec -i MYSETUPFILE.msi /leavx log.txt

This will create a log file for the installer when this command is invoked. The failure sequence can be traced from the log file and is relatively simpler to debug the setup issue.

Forcefully delete an assembly from GAC

17 April 2009
Comments (3)

image 

Very often during development we try to remove an assembly from GAC. However, due to many reasons the assembly might not get deleted and the above screen is displayed. There is no easy way to remove this assembly as it may be locked due to numerous reasons and one might need to break his head identifying the proper reason behind this.

However, there is an easy solution to this problem.

Open “regedit” and navigate to “HKEY_CLASSES_ROOT\Installer\Assemblies\Global”. In this location one can find the list of all the assemblies which are registered in GAC. Delete the appropriate entry from this list. Now you can delete the assembly from GAC as well. This is a simple trick to get rid of that stubborn assembly which was stuck in your GAC.

I hope this simple trick will save many man hours ! :)

Resize Modal Dialog Box dynamically

2 April 2009
Comments (2)

This has been a pesky issue in our current project. The requirement is to pop a modal dialog box from a web form. This dialog that appears will contain various user controls based on certain conditions. It may have controls like textbox, tree view, list view, combo box and many others. User will have to select or provide appropriate values in the required fields in this box.

The problem was that the size of the dialog box can not be predetermined and must be generated based on the content of the window. Unlike windows, in web forms we can not generate the pixel sizes of each control and the sum up the vertical space acquired by it and assign that size to the window. Even if it exists I am not aware of it and it might take good amount of time for each form display for each and every user which would be a performance lag. I found a very elegant solution to resize the window as per its content dynamically after the loading of the window. Following is the code snippet for the same:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="frmDyna.aspx.cs" Inherits="frmDyna" %>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<script language="javascript" type="text/javascript">
    function PerformResize() {
        ht = (document.body.scrollHeight + 32) + 'px'
        wt = (document.body.scrollWidth + 16) + 'px'
        window.dialogHeight = ht;
        window.dialogWidth = wt;
 
    }
</script>
<body onLoad="PerformResize();">
    <form id="form1" runat="server">
    <asp:Panel ID="Panel1" runat="server" BorderStyle="Dotted" 
        Direction="LeftToRight" Wrap="False">    
    </asp:Panel>
    </form>
</body>
</html>

The caller would use following syntax to call the above form as a modal dialog: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<%@ Page Language="C#" AutoEventWireup="true"  CodeFile="Default.aspx.cs" Inherits="_Default" %>
 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
<script language="javascript" type="text/javascript">
    function OpenChild() 
    {
        var WinSettings = "center:yes;resizable:yes;scroll:1;status:0";
        var MyArgs = window.showModalDialog("frmDyna.aspx", null, WinSettings);        
    }
</script>
 
    <form id="form1" runat="server">
    <asp:Panel ID="pnlDyna" runat="server">
        <Button ID="Button1" onclick="OpenChild()"> Button1 </Button>                        
    </asp:Panel>
    </form>
</body>
</html>

Lambda based reflection Vs Normal reflection Vs Direct call

25 March 2009
Comments (2)

One friend of mine sent me the following code sample that really surprised me.

There are three different approaches being used to call a method from a different class. The approaches are -

  1. Direct Call
  2. Call through Lambda based reflection
  3. Call through Normal Reflection

It was really surprising to see the execution speed comparison between three different approaches. The lambda based approach was found to be the fastest by the order of 1000 times.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Reflection;
 
namespace LambdaReflection
{
 
    class MyClass
    {
        public void CallIt()
        {
        }
    }
 
    class Program
    {
        delegate void LocalDel<t>(T mc);
        static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            MethodInfo minfo = typeof(MyClass).GetMethod("CallIt", BindingFlags.Instance | BindingFlags.Public);
            MyClass obj = new MyClass();
 
            //compile expression tree
            LocalDel<myclass> lambdaExpression = FuncCallIt<myclass>("CallIt");
            sw.Reset();
            sw.Start();
 
            //Direct call by using object
            for (int a = 0; a &lt; 10000; a++)
            {
                obj.CallIt();
            }
            sw.Stop();
            Console.WriteLine(string.Format("Time taken by Direct call {0}", sw.ElapsedTicks));
            sw.Reset();
            sw.Start();
 
            //dynamically compiled lambda call
            for (int a = 0; a &lt; 10000; a++)
            {
                lambdaExpression(obj);
            }
            sw.Stop();
            Console.WriteLine(string.Format("Time taken by lambda-expression compilation {0}", sw.ElapsedTicks));
            sw.Reset();
            sw.Start();
 
            //reflection call
            for (int a = 0; a &lt; 10000; a++)
            {
                minfo.Invoke(obj, null);
            }
            sw.Stop();
            Console.WriteLine(string.Format("Time taken by Reflection call {0}", sw.ElapsedTicks));
            Console.ReadLine();
 
        }
        private static LocalDel<t> FuncCallIt<t>(string MethodName)
        {
            var target = Expression.Parameter(typeof(T), "a");
            MethodInfo minfo = typeof(T).GetMethod(MethodName, BindingFlags.Instance | BindingFlags.Public);
            var methodinvokeExpression = Expression.Call(target, minfo);
            var lambda = Expression.Lambda<localdel><t>&gt;(methodinvokeExpression, new ParameterExpression[] { target });
            return lambda.Compile();
        }
    }
}

Following is the result of the execution on my system:

Time taken by Direct call 2384625

Time taken by lambda-expression compilation 902430

Time taken by Reflection call 518534265

I didn’t expect lambda based call to be faster than direct call but I need to explore as how best I can make use of this knowledge in my real programming scenarios. The compiled lambda demands different compiled lambda expressions for each method being used. However, if performance is the prime objective in the application then I think this tangential approach is worth considering.

What is your opinion on it ?

Mark File for deletion on reboot

24 March 2009
Comments (0)

Requirement: Delete files from a given folder using C#.

Challenge: The file may be in use i.e. locked.

Approach: Use System Call to mark file for deletion on restart

Solution: Use PInvoke for MoveFileEx.

///
/// Consts defined in WINBASE.H
///
internal enum MoveFileFlags
{
    MOVEFILE_REPLACE_EXISTING = 1,
    MOVEFILE_COPY_ALLOWED = 2,
    MOVEFILE_DELAY_UNTIL_REBOOT = 4,
    MOVEFILE_WRITE_THROUGH  = 8
}
 
 
/// <summary>
/// Marks the file for deletion during next system reboot
/// </summary>
/// <param name="lpExistingFileName">The current name of the file or directory on the local computer.</param>
/// <param name="lpNewFileName">The new name of the file or directory on the local computer.</param>
/// <param name="dwFlags">MoveFileFlags</param>
/// <returns>bool</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/aa365240(VS.85).aspx</remarks>
[System.Runtime.InteropServices.DllImportAttribute("kernel32.dll",EntryPoint="MoveFileEx")]
internal static extern bool MoveFileEx(string lpExistingFileName, string lpNewFileName,
MoveFileFlags dwFlags);
 
//Usage for marking the file to delete on reboot
MoveFileEx(fileToDelete, null, MoveFileFlags.MOVEFILE_DELAY_UNTIL_REBOOT);

The file is marked for deletion in registry in following location

HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlSession ManagerPendingFileRenameOperations

Next Page »