Gil Fink's Blog : Tips & Tricks

Quick Tip – Including Empty Directory While Deploying a Web Application

Gil Fink — Wed, 18 May 2011 16:02:00 GMT

Quick Tip – Including Empty Directory While Deploying a Web Application

During this week I had to deploy an ASP.NET MVC 3 web application to a host environment using web deploy. The problem I faced was the deployment of an empty directory which is being used by the application. By design, when using web deploy tool in Visual Studio it skips empty directories when packaging a web application.
So How can you deploy this empty directory and overcome this problem?
The solution is to put an empty stub file in the directory you want to deploy.
Just create an empty text file in the directory and Visual Studio will deploy the directory.

Just to share a thought - This solution is a workaround to a Visual Studio problem which IMHO need to be solved. If a developer is adding an empty directory, VS need to give him/her the ability to choose whether to deploy it or not and not to omit the directory from the deployment package.

Quick Tip – Disable/Enable Button by Textbox Client Event using jQuery

Gil Fink — Thu, 16 Sep 2010 17:00:00 GMT

Quick Tip – Disable/Enable Button by Textbox Client Event using jQuery

I find myself often with a need to disable/enable a button according to client events that occur on web pages. Today I helped to implement this behavior again so I thought it will be nice to share the code I used. In this example I’m disabling/enabling a button according to whether a textbox holds some text. I’m using jQuery to make the code simple. Pay attention that this solution can be implemented for other events also.

The Code

$(document).ready(function () {    $('#txtAgentName').blur(function () {        if ($.trim(this.value) == "") {            $('#btnUpdate').attr("disabled", true);        }        else {            $('#btnUpdate').removeAttr("disabled");        }    });});  

As you can see I wire up the ready event of the page and hook a blur event to the textbox with the txtAgentName id. In the blur event I check the value of the textbox and if it is empty I disable the button and if it is not I enable the button. The page that this example is taken from is an MVC 2 view which holds the textbox and the button elements like the following elements:

<input id="btnUpdate" type="submit" value="Update" disabled /><%= Html.TextBox("txtAgentName") %>

Summary

A lot was written about how jQuery simplify the Javascript code that you write. In this tip I used jQuery to set Html elements appearance when some client event occurs.

Discover which Control Raised a PostBack

Gil Fink — Mon, 01 Mar 2010 14:22:00 GMT

Discover which Control Raised a PostBack

Yesterday I
needed a
solution for
an annoying
problem. I have
some buttons
on a ASP.NET
web form
and I need to know which button raised the postback not in the
event itself but in the page load event. This post will show a
way to solve this conundrum.

Discover which Control Raised a PostBack

When we use ASP.NET and we have ASP buttons on the page
if we want to do something before their postback event happen
we need to discover whether they raised a postback. Since
an ASP button uses the form.submit() method on the client side
then on the server side the
Page.Request.Params[“__EVENTTARGET”] will return null.
The following method will discover which control raised a postback:

private Control GetControlThatRaisedPostBack(){              string id = Page.Request.Params["__EVENTTARGET"];   if (!string.IsNullOrEmpty(id))   {       return Page.FindControl(id) as Control;   }   foreach (var ctlID in Page.Request.Form.AllKeys)   {       Control c = Page.FindControl(ctlID) as Control;       if (c is Button)       {           return c;       }   }   return null;}

As you can see if the control isn’t a button then it will
have __EVENTTARGET which will be handled first. If we
deal with ASP buttons then we need to iterate on the form
keys and through them we will find the button. This is because
when a button is clicked it uses the form.submit() method.
That method add the button to the list of elements that are
submitted in the form (and only the button that called the submit
and no other buttons).

Summary

Finding which control raised a postback in the form outside
the postback event can be very annoying. I hope that the method
I provided will be helpful to you.

CompiledQuery in Entity Framework

Gil Fink — Mon, 01 Mar 2010 13:50:00 GMT

CompiledQuery in Entity Framework

There are times
when we want
to make optimizations
on some piece of
code. If we want to
reduce the cost of
executing a query in Entity Framework we can use a CompiledQuery
to the rescue. Yesterday I used added a compiled query to a code
base which was executing multiple times. This reduced the execution
time of the repeating queries. In the post I’ll explain what are
CompiledQueries and how to use them.

CompiledQuery

CompiledQueries are a delegate which store a compiled LINQ query that we
have built in advance. When we use them we can reduce the cost of
executing a LINQ query. This can be very helpful when we have a query that
we execute multiple times. Pay attention that the compilation of a query
also cost so don’t use CompliedQueries for every query you build only for
the queries that you want to run a lot.

Creating a CompliedQuery

When we want to use a CompiledQuery we will first create a static member
which will hold the delegate that will be created from the CompiledQuery.
The reason for the static member is because CompliedQuery is always
used with a context and we don’t want to lose it when we dispose the
context. The following code is showing how to declare a CompiledQuery:

private static Func<SchoolEntities, decimal, IQueryable<Department>> _compiledQuery =    CompiledQuery.Compile((SchoolEntities ctx, decimal budget) =>        (from d in ctx.Departments         where d.Budget > budget         select d));

We declare a Func delegate which will hold the compiled query as a static
member and we use the CompiledQuery object to with the Compile
method to compile the LINQ query.
When we want to use the compiled query we do it by invoking it:

using (var context = new SchoolEntities()){    var query = _compiledQuery.Invoke(context, 150000);    foreach (var item in query)    {        Console.WriteLine(item.Name);    }}

CompiledQuery Restrictions

Currently there are few restrictions that you must know when you
are using a CompiledQueries:

No compilation is being done up until the first execution of the
query. This means that in the first execution of a CompiledQuery
we will get a downgrade of performance (because of the
compilation). The other executions will much faster.
There is a side affect of this restriction. When combined with Merge
options the first Merge option that you pass with the first context
will be saved and will be used in the other executions.
For example running the following code for the first compiled query
execution will cause the next running to use the
MergeOption.NoTracking:

context.Departments.MergeOption = MergeOption.NoTracking;var query = _compiledQuery.Invoke(context, 150000);

Changes to the query such as compositions or calling for methods like
First(), FirstOrDefault() and more will produce a not complied query.
You must use the query as is.
If you want to avoid this problem call the AsEnumerable() method
and transform the query to LINQ to Objects query.

Summary

Lets sum up, CompiledQuery is a very powerful tool for performance
when you use Entity Framework. You should follow the restrictions
I wrote when you use them in your code.

The Regulator

Gil Fink — Tue, 02 Feb 2010 13:37:00 GMT

The Regulator

Yesterday, I reviewed a regular expression that
was written by one of the developers and
I needed to improve it since it wasn’t performing
the appropriate thing. Since I know The Regulator
tool, I opened it and in 5 minutes I came up with this
regular expression which validate Israeli phone/cellular
numbers:

^0(5[012345678]|6[47]|[23489]){1}(\-)?[^0\D]{1}\d{6}$

With The Regulator I created and checked the expression and
then implemented it in the application.

What is The Regulator?

The Regulator is a free tool that was written by Roy Osherove.
It’s purpose is to help us create regular expressions and also
to test them inside The Regulator application. It allows the
building and verifying of regular expressions and also includes
testing functionality that enable us to see a display of the hierarchical
tree that will be generated by match, replace and split operations.
The following screen show the main screen of The Regulator:

Where Can You Download It?

You can download the tool from here.

Enjoy!

Applying Strategy Pattern Instead of Using Switch Statements

Gil Fink — Sun, 22 Nov 2009 14:53:00 GMT

Applying Strategy Pattern Instead of Using Switch Statements

Once in a while I’m stumbling on switch statements during a
Code Review session. Whenever this is happening my first reaction
is to understand why did the developer use it.
Since using switch statement sometime implies spaghetti code and
also can get very crowded (in case statements of course) in this post
I’m going to show an alternative method that I prefer to use.

Alternative Method for Switch Statements

Whenever you start to use a switch statement you should
ask yourself whether you can use Strategy Pattern instead.
The Strategy Pattern help us to divide an algorithm from a host class
and then move it to another class. By doing so the client can choose
which algorithm will be performed in runtime from a set of algorithms
that were implemented earlier.
The Strategy Pattern can also help us when we want to replace a
switch statement. We can look at every case as a different
algorithm that we want to use which differ only by some condition
or a key. Since this is the case, for every case we can build a class that
do an action (the algorithm) and by that we can prevent the horror of
using an “endless” switch or spaghetti code.

Applying Strategy Pattern Over a Switch Statement

The following code shows how to replace a switch statement with
a Strategy implementation. We start with the first implementation
before we refactor it:

class Program{    public enum ePassengerTitle    {        Mr,        Mrs,        Doctor,    }     static void Main(string[] args)    {        ePassengerTitle title = ePassengerTitle.Doctor;        switch (title)        {            case ePassengerTitle.Mr:                // do something                break;            case ePassengerTitle.Mrs:                // do something                break;            case ePassengerTitle.Doctor:                // do something                break;            default:                break;        }    }}

As you can see I have an enum which holds a passenger title.
This title can get crowded for example when we want to add
more titles like Reverend, Miss or more.
Lets see how we can change this implementation to use the
Strategy Pattern:

#region Strategy Interface public interface IPassengerTitleStrategy{    void DoAlgorithm();} #endregion #region Concrete Classes public class MrPassengerTitleStrategy : IPassengerTitleStrategy{    #region IPassengerTitleStrategy Members     public void DoAlgorithm()    {        throw new NotImplementedException();    }     #endregion} public class MrsPassengerTitleStrategy : IPassengerTitleStrategy{    #region IPassengerTitleStrategy Members     public void DoAlgorithm()    {        throw new NotImplementedException();    }     #endregion} public class DoctorPassengerTitleStrategy : IPassengerTitleStrategy{    #region IPassengerTitleStrategy Members     public void DoAlgorithm()    {        throw new NotImplementedException();    }     #endregion} #endregion #region Context public class Context{    #region Members     private static Dictionary<ePassengerTitle, IPassengerTitleStrategy> _strategies =        new Dictionary<ePassengerTitle, IPassengerTitleStrategy>();     #endregion     #region Ctor     public static Context()    {        _strategies.Add(ePassengerTitle.Mr, new MrPassengerTitleStrategy());        _strategies.Add(ePassengerTitle.Mrs, new MrsPassengerTitleStrategy());        _strategies.Add(ePassengerTitle.Doctor, new DoctorPassengerTitleStrategy());    }        #endregion     #region Methods     public static void DoAlgorithm(ePassengerTitle title)    {        _strategies[title].DoAlgorithm();    }     #endregion} #endregion

You can see that I register all the algorithms inside a dictionary
which will help us to imply the relevant algorithm whenever we
need it. The registration is done inside the Context class which
then exposes the DoAlgorithm method which gets the relevant
passenger title and implies to it the relevant algorithm.
Lets see how our program change when we use the Strategy
implementation:

public enum ePassengerTitle{    Mr,    Mrs,    Doctor,} class Program{    static void Main(string[] args)    {        ePassengerTitle title = ePassengerTitle.Doctor;        Context.DoAlgorithm(title);    }}

This is only one way to implement the Strategy Pattern. There are other
ways to do the same thing but without dictionaries which you can find in
the internet.

What we gain by using Strategy Pattern?

The code is easier to read. I don’t need to go and read (or
search) an “endless” switch statement to understand each
aspect of the code.
The code is more maintainable. I only need to go to the
relevant class that implement the algorithm in order to change it
or refactor it when needed.
It is easier to add more algorithms. I only need to add more classes
to the pile of algorithms and that is it. Doing so helps us to imply
the Open / Closed Principle because in switch statement we are going
to have to change our code (add another case statement) in opposed
to Strategy which we add another algorithm class.
Strategy Pattern is more testable.

Even so, there are times that switch statement is preferable then
Strategy Pattern but when you find yourself having an “endless” switch
or repeat the same switch all over the place this should alert you that
Strategy Pattern is needed.

Summary

In the post I showed an alternative method for switch statement use. I
always prefer the use of Strategy Pattern instead of switch statements.
This approach is more OOP for developing even though it will force you to
implement more classes. In the end you can choose either the switch
statement or Strategy Pattern but if you have chosen a switch statement
do it in the right place.

Back to Basics – How to Invoke Web Methods from a Remote Machine

Gil Fink — Sun, 08 Nov 2009 15:50:00 GMT

Back to Basics – How to Invoke Web Methods from a Remote Machine

I’ve been
asked today
how to enable
invocation of
WebMethods of
an asmx web service
from a remote machine
for testing.
The post holds the answer.

How to Invoke Web Methods from a Remote Machine?

Sometimes we want to test our asmx web service not from
localhost but from a remote machine. Trying to open the test form
of the web service from a remote machine will show the following
message: “The test form is only available for requests from the local
machine”. In order to enable the invocation we need
to go the the web service’s configuration file and add to the
system.web element the following configuration:

<webServices>    <protocols>        <add name="HttpGet"/>        <add name="HttpPost"/>    </protocols></webServices>

The configuration will enable the protocols of Get and Post on the
service and that is it.
Pay attention – you should use this configuration only in develop or
test environments. Also, this ability is only available for simple types.
Trying it with complex types won't work.

Summary

Enabling test invocation from a remote machine is very easy. It include
simple configuration and it will work. Don’t forget to use it only in
develop or test environments.
Enjoy!

Quick Tip – Adding Business Validation Messages to ValidationSummary

Gil Fink — Fri, 11 Sep 2009 19:01:00 GMT

Quick Tip – Adding Business Validation Messages to ValidationSummary

Two days ago I was asked
how to insert business
validation messages into a
ValidationSummary control.
The post is the answer I
gave to the person who asked
me.

The Problem

We have a web form that is doing input validation and output the errors
inside a ValidationSummary control. Since ValidationSummary shows a
summary of all validation errors from ASP.NET validators how can we
add business validations which are part of the business logic we have to
the output of the ValidationSummary ?
Also, how can we make the input not valid according to the business logic?

The Answer

We can use the CustomValidator control to our rescue. In code we will
create the CustomValidator and sets its IsValid property to false. We
also add our business error message to the ErrorMessage property.
Then we will add the created CustomValidator to the Page’s Validator
list. The following helper method will perform what I describe:

public static void AddBusinessErrorMessage(Page page, string message){    var validator = new CustomValidator();    validator.IsValid = false;    validator.ErrorMessage = message;    page.Validators.Add(validator);}

Summary

In the post I showed an example of using a CustomValidator in order
to add business error messages to a ValidationSummary control.
There are more solutions out there that will do the same thing but this
solution is the easiest to implement.

Quick Tip – How to Enable Local Cache in Velocity (Microsoft Distributed Cache) Client

Gil Fink — Thu, 16 Jul 2009 18:04:34 GMT

Quick Tip – How to Enable Local Cache in Velocity (Microsoft Distributed Cache) Client

Since I got this question twice
this week, I’m writing this post.
One of Velocity (Microsoft
Distributed Cache) features is
called local cache. In this post I’ll
show how to enable that feature.

Velocity Client Local Cache

Local cache is a Velocity feature that can help speed up access on Velocity clients.
When enabled, a de-serialized copy of the object is saved in the client memory.
Before retrieving cached objects, the client cache will first checks whether the
object exists locally and if so will get it from the local cache.

Enabling Local Cache

There are two ways to enable local cache on a Velocity client:

The runtime way – the DataCacheFactory object has a constructor that gets
as parameter whether the local cache is enabled.
for example:

         DataCacheServerEndpoint[] servers = new DataCacheServerEndpoint[1];

        servers[0] = new DataCacheServerEndpoint("localhost",

                                22233, "DistributedCacheService");

        bool routingClient = false;

        // True = Enable local cache

        // False = Disable local cache

        bool localCache = false;

        var factory = new DataCacheFactory(servers,

            routingClient, localCache);

        var cache = factory.GetCache("default");

The configuration way – in the client config file, we we use the localCache
attribute like in the following example:

        <dcacheClient deployment="simple" localCache="false">

          <hosts>    

            <host name="localhost"

                  cachePort="22233"

                  cacheHostName="DistributedCacheService" />

          </hosts>

        </dcacheClient>

Summary

Local cache is a very useful feature of Velocity. It can help to boost the
performance of an application that uses Velocity to new heights.

Creating AutoCompleteExtender Trigger Button

Gil Fink — Wed, 10 Jun 2009 14:23:00 GMT

Creating AutoCompleteExtender Trigger Button

Yesterday I’ve been
consulting at a client.
During the day, I got a
question regarding
ASP.NET AJAX
Control Toolkit’s
AutoCompleteExtender.
The question was how
to create a trigger button to the AutoCompleteExtender in order to
go to the server and fetch the results.
This post will describe how to do that.

Creating an Autocomplete Web Service

The first thing to do when you want to use the AutoCompleteExtender
is to create the web service that you’ll connect to. In my example, I’m
going to use the following suggestions web service:

[WebService(Namespace = "http://tempuri.org/")][WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)][ToolboxItem(false)][ScriptService]public class SuggestionsService : WebService{    [WebMethod]    public string[] GetSuggestions(string prefixText, int count)    {        List<string> results = new List<string>();        for (int i = 0; i < count; i++)        {            results.Add(string.Format("{0}{1}", prefixText, i));        }         return results.ToArray();    }}

Creating The Web Page

After we have our service, it is time to create our web page.
The following web page contains a text box with the
AutoCompleteExtender and a button to trigger the auto complete
from client side:

<form id="form1" runat="server">        <asp:ScriptManager ID="ScriptManager1" runat="server" />        <div>                    <asp:TextBox ID="txtAutoComplete" runat="server"></asp:TextBox>            <cc1:AutoCompleteExtender ID="SuggestionsAutoComplete" runat="server"                 TargetControlID="txtAutoComplete" ServiceMethod="GetSuggestions"                 ServicePath="SuggestionsService.asmx" MinimumPrefixLength="1"                CompletionSetCount="20">            </cc1:AutoCompleteExtender>            <br />            <asp:Button ID="btnTrigger" runat="server" Text="Trigger Auto Complete"                 OnClientClick="BLOCKED SCRIPTshowAutoComplete()"/>                </div></form>

Nothing special here.

The Trigger Function

The following method is the trigger function:

<script type="text/javascript">    function showAutoComplete() {        var autoComplete = $find('SuggestionsAutoComplete');        autoComplete.get_element().focus();        autoComplete._textBoxHasFocus = true;        autoComplete.get_element().value = '';        Sys.Net.WebServiceProxy.invoke(autoComplete.get_servicePath(),           autoComplete.get_serviceMethod(),           false,           { prefixText: '', count: autoComplete._completionSetCount },           Function.createDelegate(autoComplete, autoComplete._onMethodComplete),           Function.createDelegate(autoComplete, autoComplete._onMethodFailed),           '',           5000);         $common.updateFormToRefreshATDeviceBuffer();    }</script>

First I find the extender. Then, I set focus on the extender.
Without setting the focus on the extender nothing will work.
After the focus setting, I use the Sys.Net.WebServiceProxy.invoke
method which will invoke the auto complete. The last thing to do is to
use the $common.updateFormToRefreshATDeviceBuffer method which
is registered by the AutoCompleteExtender in order to make
updates to form elements and to refresh their document buffer
to what is showing live in the browser.

Summary

Lets sum up, today I showed a simple solution to a demand that was
raised by a customer. As I could see in my searches on the net that
demand is common so I hope this solution will help you if you need
that functionality.