ASpeak

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.

We all have times when we are off for a few days from work and we want the email senders to be automatically notified of it. In outlook you can use Out of Office Assistant wizard for this purpose.

While searching for good funny out of office quotes, I stumbled across following set of hilarious messages. Some are offending but worth a try.

1- I am currently out at a job interview and will reply to you if I fail to get the position. Be prepared for my mood.
2- You are receiving this automatic notification because I am out of the office. If I was in, chances are you wouldn’t have received anything at all.
3- Sorry to have missed you but I am at the doctors having my brain removed so that I may be promoted to management.
4- I will be unable to delete all the unread, worthless emails you send me until I return from vacation on 5/18. Please be patient and your mail will be deleted in the order it was received.
5- Thank you for your email. Your credit card has been charged $5.99 for the first ten words and $1.99 for each additional word in your message.
6- The e-mail server is unable to verify your server connection and is unable to deliver this message. Please restart your computer and try sending again. (The beauty of this one is that when you return, you can see how many in-duh-viduals did this over and over).
7- Thank you for your message, which has been added to a queuing system. You are currently in 352nd place and can expect to receive a reply in approximately 19 weeks.
8- Please reply to this e-mail so I will know that you got this message.
9- I am on holiday. Your e-mail has been deleted.
10- Hi. I’m thinking about what you’ve just sent me. Please wait by your PC for my response.
11- Hi! I’m busy negotiating the salary for my new job. Don’t bother to leave me any messages.
12- I’ve run away to join a different circus.
13- AND, FINALLY, ABSOLUTELY THE BEST: I will be out of the office for the next 2 weeks for medical reasons. When I return, please refer to me as ‘Loretta’ instead of ‘Anthony’

I can see the smile on your face   If you have any other funny quote then share with me.

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 !

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>

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 ?