Yosif Yosifov

Binding UI controls using Fluent API

2012-01-26T00:43:00.001-08:00

Hi guys,

I've been working on ASP.NET Web Forms application for a while and have been constantly writing Data Binding on all kinds of containers - repeaters, list views, grid views and etc.

Let's imagine a very simple scenario. We have a Contact Class and Address Class. You get the Address of the Contact, using the Contact Id. In most cases, these objects will come from the databases, but for the purposes of this post, we don't need any complications. Therefore here are my classes:

namespace FluentBindingSample.Data
{
    public class Address
    {
        public int ContactId { get; set; }
        public string Country { get; set; }
        public string City { get; set; }
        public int PostalCode { get; set; }

        public Address()
        {
        }
    }
}

and

namespace FluentBindingSample.Data
{
    public class Contact
    {
        public int ContactId { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }

        public Contact()
        {
        }
    }
}

Now, here is a sample data provider, which will help us retrieve Contacts and retrieve data (currently, hardcoded):

using System;
using System.Collections.Generic;
using System.Linq;
using FluentBindingSample.Data;

namespace FluentBindingSample.Model
{
    public class SampleDataProvider
    {
        public static IEnumerable< Contact > GetSampleContacts()
        {
            yield return new Contact { ContactId = 1, FirstName="Leo", LastName="Messi" };
            yield return new Contact { ContactId = 2, FirstName = "Wayne", LastName = "Rooney" };
            yield return new Contact { ContactId = 3, FirstName = "Christiano", LastName = "Ronaldo" };
        }

        public static Address GetAddressByContactId(int contactId)
        {
            switch (contactId)
            {
                case 1:
                    return new Address { Country = "Argentina" };

                case 2:
                    return new Address { Country = "England" };

                case 3:
                    return new Address { Country = "Portugal" };

                default:
                    throw new NotSupportedException();
            }
        }
    }
}

We're ready with our sample Business Layer. Now, let's bind this data to a Repeater:

<asp:Repeater ID="rptContats" runat="server">
        <HeaderTemplate>
            <table>
                <thead>
                    <tr>
                        <th>
                            Contact Id
                        </th>
                        <th>
                            First Name
                        </th>
                        <th>
                            Last Name
                        </th>
                        <th>
                            Country
                        </th>
                    </tr>
                </thead>
                <tbody>
        </HeaderTemplate>
        <ItemTemplate>
            <tr>
                <td>
                    <asp:Literal ID="ltrContactId" runat="server" />
                </td>
                <td>
                    <asp:Literal ID="ltrFirstName" runat="server" />
                </td>
                <td>
                    <asp:Literal ID="ltrLastName" runat="server" />
                </td>
                <td>
                    <asp:Literal ID="ltrCountry" runat="server" />
                </td>
            </tr>
        </ItemTemplate>
        <FooterTemplate>
                </tbody>
            </table>
        </FooterTemplate>
    </asp:Repeater>

We've finally set up our sample - we've reached the main point of this article. What I have always found boring is implementing an ItemDataBound event, getting all controls, casting and initiating them. I think this is a common problem and the code looks like this:

private void rptContats_ItemDataBound(object sender, RepeaterItemEventArgs e)
        {
            if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
            {
                Contact contact = e.Item.DataItem as Contact;

                Literal ltrContactId = e.Item.FindControl("ltrContactId") as Literal;
                Literal ltrFirstName = e.Item.FindControl("ltrFirstName") as Literal;
                Literal ltrLastName = e.Item.FindControl("ltrLastName") as Literal;
                Literal ltrCountry = e.Item.FindControl("ltrCountry") as Literal;

                ltrContactId.Text = contact.ContactId.ToString();
                ltrFirstName.Text = contact.FirstName;
                ltrLastName.Text = contact.LastName;

                Address address = SampleDataProvider.GetAddressByContactId(contact.ContactId);
                ltrCountry.Text = address.Country;
            }
        }

You see, we get all controls. Cast them, initialize them. Get some other things, related to the object and bind them too.
What are the problems of this approach - we do not have any code reusability. In case I want to show some Contact details in another Template Control I'll have to copy paste my whole code. The code is bloated - we say few things with much lines.
How can we improve the current situation? What I've come to useful in my projects is to implement a Fluent API. Let us see, how can Fluent API improve our code.
We first have to create the Interface of the API, itself. For our Contact and Address classes, this can look like this:

using System;
using System.Linq;
using System.Web.UI;

namespace FluentBindingSample.Model.Binders
{
    public interface IContactBinder
    {
        IContactBinder WithTextControl(Control control, string controlName);

        IContactBinder BindFirstName();

        IContactBinder BindLastName();

        IContactBinder BindContactId();
    }
}

and

using System.Web.UI;

namespace FluentBindingSample.Model.Binders
{
    public interface IAddressBinder
    {
        IAddressBinder WithTextControl(Control control, string controlName);

        IAddressBinder BindCountry();
    }
}

The implementation of this Fluent APIs is quite straight forward, too:

using System;
using System.Linq;
using System.Web.UI;
using FluentBindingSample.Data;

namespace FluentBindingSample.Model.Binders
{
    public class ContactBinder : IContactBinder
    {
        private readonly Contact contact;
        private ITextControl textControl;

        private ContactBinder()
        {
            
        }

        public ContactBinder(Contact contact)
        {
            if (contact == null)
            {
                throw new ArgumentNullException();
            }

            this.contact = contact;
        }

        public IContactBinder WithTextControl(Control control, string controlName)
        {
            ITextControl textControl = control.FindControl(controlName) as ITextControl;

            this.textControl = textControl;

            return this;
        }

        public IContactBinder BindFirstName()
        {
            textControl.Text = contact.FirstName;

            return this;
        }

        public IContactBinder BindLastName()
        {
            textControl.Text = contact.LastName;

            return this;
        }

        public IContactBinder BindContactId()
        {
            textControl.Text = contact.FirstName;

            return this;
        }
    }
}

and

using System;
using System.Linq;
using System.Web.UI;
using FluentBindingSample.Data;

namespace FluentBindingSample.Model.Binders
{
    public class AddressBinder : IAddressBinder
    {
        private readonly Address address;
        private ITextControl textControl;

        private AddressBinder()
        {

        }

        public AddressBinder(Address address)
        {
            if (address == null)
            {
                throw new ArgumentNullException();
            }

            this.address = address;
        }

        public IAddressBinder WithTextControl(Control control, string controlName)
        {
            ITextControl textControl = control.FindControl(controlName) as ITextControl;

            this.textControl = textControl;

            return this;
        }

        public IAddressBinder BindCountry()
        {
            textControl.Text = address.Country;

            return this;
        }
    }
}

Now we've come to the sweet part. Integrating the Fluent API in the Item Data Bound event:

private void rptContats_ItemDataBound(object sender, RepeaterItemEventArgs e)
        {
            if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
            {
                Contact contact = e.Item.DataItem as Contact;

                IContactBinder contactBinder = new ContactBinder(contact);
                contactBinder.WithTextControl(e.Item, "ltrContactId").BindContactId();
                contactBinder.WithTextControl(e.Item, "ltrFirstName").BindFirstName();
                contactBinder.WithTextControl(e.Item, "ltrLastName").BindLastName();

                Address address = SampleDataProvider.GetAddressByContactId(contact.ContactId);
                IAddressBinder addressBinder = new AddressBinder(address);
                addressBinder.WithTextControl(e.Item, "ltrCountry").BindCountry();
            }
        }

Now - this is much shorter, more readable and reusable. If I need to bind such information elsewhere, I have the functionality to do it and can just reuse it.
When can we use such approach?
- If we want to reuse code.
- If we want to encapsulate some logic - for instance formatting of the text, default values and etc.
What's the cost? We have to create Fluent API for the objects - this means little more developer effort in the beginning, which can be paid off later. It all depends on the case. If you have complex objects and functionality with formatting, default values and etc, I think such approach will armor you better than the simpler way.

The solution we outlined in this blog post can be downloaded from here:
Fluent Binding API Sample
Hope you found some ideas for yourselves in this post.

Happy Coding!

ORA-12154: TNS:could not resolve the connect identifier specified in Visual Studio

2011-10-07T08:05:00.000-07:00

Hi guys,

If you are trying to connect to an Oracle Database, through Server Explorer in Visual Studio, you have to ensure that:

1. You have installed the Oracle Data Provider (downloadable from the Oracle Website)
2. Have created the tnsnames.ora file, holding information about the databases (http://www.orafaq.com/wiki/Tnsnames.ora). This file should be created most often in the Network\Admin folder under the Oracle Provider. In my case: C:\app\user\product\11.2.0\client_1\Network\Admin

After having these prerequisites, I still couldn't connect to the Oracle Database. The Visual Studio wizard told me: "ORA-12154: TNS:could not resolve the connect identifier specified". What resolved this issue for me was to add the Environment Variable with name "TNS_ADMIN" and value the Path to the directory containing the "tnsnames.ora" file.
Something like:
TNS_NAMES="C:\app\user\product\11.2.0\client_1\Network\Admin"
Then just restart Visual Studio and you're free to go.

Hope this helps someone out there :)

More on Template Design Pattern

2011-07-20T13:10:00.000-07:00

Hi guys,
hope you liked the last article, which included a modification the Template method pattern.

I would like to continue the same topic and expose another useful implementation of the pattern. It's a very basic example of OOP - nothing advanced.

What do we want solve
In web applications you often have to expose your data through different formats - like XML, JSON or RSS. Every time, you need to get the Response of the page, clear it, fill it with contents and then end the Response.
This can be an error prone information, as you have to take care of some details like "Flushing" the response before ending it. It would be nice, if you could skip these details after you've written and tested them once.

Response Template implementation
My approach to this problem was to create a simple ResponseTemplate class, which is actually a plain implementation of the Template design pattern. Below is a sample implementation:

public abstract class ResponseTemplate
{
 protected HttpResponse Response { get; private set; }

 public ResponseTemplate(HttpResponse httpResponse)
 {
     this.Response = httpResponse;
 }

 public void WriteResponse()
 {
     this.Response.Clear();

     SetContentType();

     Write();

     this.Response.Flush();
     this.Response.End(); 
 }

 internal abstract void Write();

 internal abstract void SetContentType();
}

Using this class, you forget about the details. You just pass the HttpResponse and implement the SetContentType() and Write() methods.

Now if I would want to return an XML I would write a concrete implementation inheriting the ResponseTemplate class:

public class XmlResponse : ResponseTemplate
{
 private string XML { get; set; }

 public XmlResponse(HttpResponse httpResponse, XDocument doc)
     : base(httpResponse)
 {
     this.XML = doc.ToString();
 }

 public XmlResponse(HttpResponse httpResponse, string xml)
     : base(httpResponse)
 {
     this.XML = xml;
 }

 internal override void Write()
 {
     base.Response.Write(this.XML);
 }

 internal override void SetContentType()
 {
     base.Response.ContentType = ContentType.Xml;
 }
}

In the end, these are all just plain and very simple OOP principles. The main purpose why I continue making them look harder by calling them things like "Template Design Pattern" is that this facilitates your communication with the other developers. But, this is a whole different topic, worth writing some day.

Happy coding!

Try/Catch refactoring

2011-05-19T11:19:00.000-07:00

Hi guys,
every now and then I enjoy learning and inventing some new tiny tricks and tips. They make my life easier and my code tidier. Today I would like to share some small refactoring, which I find neat and use all the time.

Original Code
Most probably, you often have to write repetitive code like the one below:

try
{
    // Perform operations
}
catch (System.Exception ex)
{
    // Log Exception
}

This is pretty common in windows applications/services. What I don't like is repetitive writing it.
So, how can we refactor it? We can review our list of Design Patterns and observe that what we can do is implement something like the Template method pattern. In C# we can use lambda expressions and anonymous methods to implement a lightweight version of a modification of this pattern.

Template method pattern modificatoin
Using the Template method pattern idea, we have to wrap our executing code with try/catch statements. We can create a class we can use to actually "inject" our operation. Something like this one:

public static class SafeCodeExecutor
{
    public static T Execute<T>(Func<T> operation)
    {
       try
       {
           return operation();
       }
       catch (System.Exception ex)
       {
           // Log Exception
       }
       return default(T);
    }
}

Now, we can freely use our SafeCodeExecutor throughout our project. Sample usage would be:

string designPatternName = SafeCodeExecutor.Execute<string>(() => 
    {
        return "Template method pattern"; 
    });

Of course, you can free use a method inside the Execute<>.

You can build more Execute template methods which fit your needs - for instance taking Action with some parameters and etc (for instance:

public static void Execute<T>(Action<T> operation, T item)

). It's all up to you.

Hope you liked this little trick!

FIPS compliant algorithms

2011-02-28T20:00:00.000-08:00

Hi guys!

Distributed software
If you're building and distributing a software/product, you must be aware that some of the Encryption algorithms of the .NET Framework are considered "FIPS approved" (Federal Investigation Processing Standards) and others aren't.

What problems can cause this? Well, if you're using MD5 in your distribution and your customer is running your software on a machine configured to ensure FIPS, your software won't be working.

For instance, in Windows there is a setting called - "System cryptography: Use FIPS compliant algorithms for encryption, hashing, and signing". Enabling it, ensures that all applications on the PC are using algorithms which are approved by FIPS.

FIPS approved algorithms list
It's a good idea, to always check the Encryption algorithms you're using against the list of approved FIPS algorithms:
https://wiki.mozilla.org/FIPS_Validation

This way you'll ensure your software robustness and reliability.

More resources

http://csrc.nist.gov/groups/STM/cmvp/standards.html#02

http://technet.microsoft.com/en-us/library/cc780081%28WS.10%29.aspx

Little victories make up the big victory

2011-02-21T14:15:00.000-08:00

Hi guys!

This will be my first blog post, not directly related to problems, code snippets and etc. I hope I'll write more like these in the future!

Code refactoring
In our daily work we frequently do refactoring. Sometimes we do some pieces of code refactoring, which we enjoy as we see the code becoming better and better and we feel happy and satisfied about that. But sometimes, we have to refactor something bigger, some spaghetti code with much legacy in it.
I've encountered such case recently. I struggled with it for few days and was highly disappointed by my performance.

Don't underestimate your tasks
I was frustrated as nothing was working. I've taken a wrong decision to cut-off the whole project I wanted to refactor and rewrite it. Thinking it will be an easy job to do, I didn't pay much attention, neither estimated accurately all the functionality I had to cover.

What happened was that it turned out to be tougher than expected. I had erased everything old, the whole solution couldn't be build. I couldn't even cover all the functionality, yet. This all happened for few days in which I've been feeling miserable. It was a dead-end thing and I haven't felt that way for some time. I was close to resigning from this task, as the deadline was coming closer and I was becoming more and more heartless. But admitting that you have failed with a task is something hard to live with (at least for me).

Don't lose hope, change directions
Then, I decided to change completely my plan I've firstly tried to follow. I commented most of the code I haven't refactored yet and struggled with building the other code. I've spent few hours on this, but finally built the project (Victory 1). I've started testing and bug fixing (Victory 2..N). It was such a relief. This whole system was alive and beating again!

Get motivated, get the work done
I saw a light in the dark - this whole thing might start working. Fully motivated, I continued iteratively refactoring the remaining part of the project. This took me some time, but in the end, everything was fine and I was satisfied with my work.

The moral of this story is, that when firstly I got my project built successfully this was actually my first victory - and it felt great. When I started testing, bug-fixing and improving my code I achieved my next victories. From this time on the job was easy to do.

Small victories, make up the big victory
Sometimes, you need to get to the small victories as fast as possible, to have the power and motivation to continue until you win the battle.

Learn from your mistakes and don't repeat them
Next time, I'll certainly pay more attention to the details, estimate them and try to iteratively do things, not taking them all at once.

Keep tuned, for more stories of failures and successes!

Securing your application's configuration data

2011-01-16T09:21:00.000-08:00

Hi guys!
We all add our passwords, connection strings and etc in our config files. But how secure are they? I'll focus on Web Applications.

Basic security
Internet Information Services (IIS) - the most popular server for ASP.NET Applications is by default set to reject all requests to files with extensions .config. So, any file on your web server, named as *.config is safe and cannot be viewed.

Next steps
However, let's consider another scenario. What if we want to protect ourselves from everyone who actually have access to our web servers? We can use 3 approaches - it's only up to you to choose how to combine them:

1. Built-in web.config encryption - By default ASP.NET provides as with the functionality to encrypt the whole web.config or a configuration section in it. After we encrypt it the IIS server automatically decrypts it when starts reading the web.config file. Encrypting is simple and straightforward:

aspnet_regiis -pef ConfigurationSectionName

Example is explained here: http://odetocode.com/blogs/scott/archive/2006/01/08/encrypting-custom-configuration-sections.aspx

2. Custom encryption - In most cases, we're collaborating with other people when working on projects and our source is saved into a Source Control. If we want to hide some sensitive information, we can't actually check-in an encrypted config section, because we won't be able to change the settings there anymore.

What we can do now is implement a custom Encryption and Decryption algorithm. Then we'll be able to save an encrypted version of the password in the config file and decrypt it before we start using it. We use plenty of approaches for doing this - use standard algorithm like Rijndael or write a custom encryption/decryption function. Someone can still decrypt the password, but it's not in plain text anymore.

3. Operating System access control usage - We can go one step further - we can physically deny access to the configuration files for anyone except the Application Pool user of our Web Application. This way no one logged on the machine won't be able to see the contents of these files.

This security is useful, when there are people having access to the server - they can log in or browse it through network share. Restricting the permissions only to the Application Pool User will prevent everyone else from reading the contents of these files.

In Conclusion
Security is an important part of our applications. All ways to add security to your application in this article are quite simple. You can combine any set of them, until you're satisfied with the level of security or meet your project's security requirements.

You can leave a comment, if you have some additions to this list of security actions.

Bitmasks demystified

2010-10-30T10:57:00.000-07:00

Hi guys!
Using bitmasks, has been always a powerful technique for storing small set of different flags in only one variable. A flag can represent anything, which we may want to check whether is ON or OFF.

What is a bitmask?
Bitmask only sounds scary and complex, but it actually is something very simple. It's only the name of the representation of one number in Binary Notation. For instance, let's look at a few representations:

00010 is the number 2

00100 is the number 4

00101 is the number 5

Still, we don't see the number 5 as "00101", but we can use Bitwise Operators to check whether on some position of the binary representation of the number there is 0 or 1.

What can we use a bitmask for?
The bitmask can be used to store some states. In C#, there is the FlagsAttribute which actually states, that the enum we're creating will be used for bit manipulation. One of the most popular enums, which is decorated with the FlagsAttribute is the BindingFlags enum.
So, if we want to store small number of flags, we can use the bitmask.

How does the bitmask work?
By setting as number values of our Enum members the powers of the 2, we end up having an enum collection like the one below:

[Flags]
public enum CustomFileMode : int
{
    Create = 1,
    Open = 2,
    Append = 4,
    Truncate = 8
}

The bit representation of the same collection is as follows:

Create - 0001

Open - 0010

Append - 0100

Truncate - 1000

Now, if we have the number 5 (0101), using the Bitwise Operation &, we can check whether any of the Enum members is set on. How do we perform the check? We evaluate the Flag & Bitmask statement. This will give us a positive result, if the Flag is set as On in the Bitmask. (i.e. it's 1 in the bitmask's binary representation).

When checking for Truncate flag, we evaluate the (CustomFileMode.Truncate & 5) statement and see that the result is (1000 & 0101 = 0000), so the Truncate flag is not turned on. (because, the result is zero)

If we check for the Append flag, we evaluate the (CustomFileMode.Append & 5) statement and the result is (0100 & 0101 = 0100), which is greater than zero - so the Flag CustomFileMode.Append is turned on.

As we have selected only numbers which are a power of the 2, we don't have any duplicate values in binary representation, as a power of the 2 is always having just one 1 in it's binary representation.

How do we set a flag? We use the bitwise operator | (OR). Let's start with an empty number 0 and we want to set the flags Append and Create. What we can do is:

0000 | Append (0100) = 0100
0100 | Create (0001) = 0101

We now see, that in the result 0101, we have both Append and Create flags set.

How do we use a Bitmask in C#
We'll examine one simple example, which outlines how easy it is to create a bitmask in C#. The steps to follow are:
1. Create a Enum which derives from an integer class
2. Decorate the Enum with FlagsAttribute
3. Create the values of the Enum, using only powers of the 2
4. Write your own business logic for checking the Flags in a bitmask using the Enum
Here is a sample Console Application code, which you can play with to explore the Bitmasks:

using System;
using System.Collections.Generic;

namespace BitmaskExample
{
    public class Program
    {
        static void Main(string[] args)
        {
            // Create a new CustomFileMode. We set the Open, Create and Truncate operations on.
            CustomFileMode fileModes = CustomFileMode.Open | CustomFileMode.Create | CustomFileMode.Truncate;

            if (IsFlagSet(fileModes, CustomFileMode.Append))
            {
                Console.WriteLine("Append flag is set.");
            }

            if (IsFlagSet(fileModes, CustomFileMode.Open))
            {
                Console.WriteLine("Open flag is set.");
            }

            if (IsFlagSet(fileModes, CustomFileMode.Create))
            {
                Console.WriteLine("Create flag is set.");
            }

            if (IsFlagSet(fileModes, CustomFileMode.Truncate))
            {
                Console.WriteLine("Truncate flag is set.");
            }
        }

        /// <summary>
        /// Checks if the flag is turned on in the bitmask
        /// </summary>
        /// <param name="bitmask">The bitmask - consisting of all the Flags turned on</param>
        /// <param name="flag">The flag we're checking for</param>
        /// <returns>True if the flags is on, otherwise returns false.</returns>
        static bool IsFlagSet(CustomFileMode bitmask, CustomFileMode flag)
        {
            return (bitmask & flag) != 0;
        }
    }

    /// <summary>
    /// The CustomFileMode is an Enum, which states are with values the power of 2.
    /// </summary>
    [Flags]
    public enum CustomFileMode : int
    {
        Create = 1,
        Open = 2,
        Append = 4,
        Truncate = 8
    }
}

In Conclusion
I hope, this post sheds more light for you on the Bitmask concept. Your questions and suggestions are as always welcome!

Tip
You can choose a .NET type to inherit your Enum colleciton, based on how many different flags you need to set and check. The range of values, that can be stored depends on the number of bits in the type. Below are the 3 most common types:
short (8 bits) - up to 7 different flags.
int (32 bits) - up to 31 different flags.
long (64 bits) - up to 63 different flags.

ASP.NET FindControl recursively - a simple iterative approach

2010-06-01T12:56:00.000-07:00

Hi guys!

The problem:
A common problem most people face when working with ASP.NET pages is the FindControl(string id) method. It works great, but it does only what it's supposed to - it searches for the control in some naming container. What if you have multiple naming containers nested? In this case, the FindControl method is not working anymore.

The idea of the solution:
The idea is very simple, because you have only one choice - search through the whole container hierarchy until you find the control you are searching for or you have traversed all the controls.

Recursive solution:
There are many places, where the recursive solution is explained, for instance: ASP.NET 2.0 MasterPages and FindControl() is probably the most famous one.

Simple iterative approach:
Playing with algorithms is always fun. The recursive solution is nothing more than an implementation of a standard traversal algorithm - Depth First Search Algorithm. It's simple, easy and working. But what if we want to use an iterative solution? Then the answer is just to implement the Breadth First Search Algorithm. A sample implementation follows below:

  private Control FindControlById(Control containerControl, 

    string controlId)

  {

      Queue<Control> queue = new Queue<Control>();

      queue.Enqueue(containerControl);



      while(queue.Count > 0)

      {

          Control currentControl = queue.Dequeue();



          if(currentControl.ID == controlId)

          {

              return currentControl;

    }



          foreach(Control childControl in currentControl.Controls)

          {

            queue.Enqueue(childControl);

          }

      }



      return null;

}

Happy coding!

Applying GZIP Compression to WCF Services

2010-02-05T12:58:00.000-08:00

Hi guys!

Tweaking the web application's performance
Improving the web application's performance is getting more and more important these days. Recently, I have researched the approaches to gzip(compress) your WCF Service responses, which reduces the responses size in common 5 to 1 ratio. This results in faster transfer of the responses and less bandwidth. For instance, if you had responses with size 30kb, they will become 6kb when compressed, without losing anything. Sounds great, doesn't it?

3 easy ways to enable GZIP compression on your WCF Service:
1. Using IIS7
In case you are using IIS7, enabling the GZIP compression for the server's responses comes on the fly: http://blogs.iis.net/ksingla/archive/2006/06/13/changes-to-compression-in-iis7.aspx
As you see, using IIS7 to compress the WCF responses is easy and straight-forward, but not everyone is running IIS7 on their production servers. So, let's think of other options, not including the usage of IIS7.

2. Writing a custom message encoder
Fortunately, Microsoft have covered this case, too. You can use their WCF sample for Custom Message Encoder: http://msdn.microsoft.com/en-us/library/ms751458.aspx and use it in your WCF Services. You have to read and understand the sample, then modify it for your needs.

3. Using Telerik RadCompression
In case, you are finding the Custom Message Encoder sample too complicated or you are trying to use your WCF Service with Silverlight(which currently supports only basic/binary bindings), the easiest way to compress the responses, without having hard time with making things work is using the Telerik's RadCompression: http://www.telerik.com/help/aspnet-ajax/radcompression.html. Using the RadCompression, you just define the RadCompression HttpModule in your WCF Service's web.config and it instantly starts working, even when communicating with Silverlight.

In conclusion
As I had to apply gzip compression for a WCF Service, communicating with a Silverlight Application (using a Custom Binary Encoding - http://blogs.msdn.com/silverlightws/archive/2009/03/20/what-s-new-with-web-services-in-silverlight-3-beta.aspx), without using an IIS7, I had hard time trying to modify the Custom Message Encoder Sample to work in my case, so I went using the Telerik's RadCompression module, which is very fast and easy to setup.

Happy optimizing!

Using TFS SDK on 64-bit machine

2009-07-10T00:43:00.000-07:00

Hi, guys!

TFS SDK
Using the TFS SDK is pretty easy. You read some articles and documentation from the msdn: Team Foundation Server SDK. Then just add the appropriate assemblies (for example Microsoft.TeamFoundation.Client and Microsoft.TreamFoundation.WorkItemTracking.Client) and enjoy writing TFS accessing applications.

What's the problem with 64-bit machine?
Creating and building the project is easy. Some problems occur when you try to run it, though. I encountered error like this one:

"Could not load file or assembly 'Microsoft.TeamFoundation.Client, Version=9.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies. The system cannot find the file specified."

The problem is that it appears that the TFS SDK is only x86 (32-bit).

The solution
What you have to do is just change the Platform target to x86 in the Project/Properties/Build tab in your Visual Studio, and everything will work again for you. It sounds very easy, but I wasted few hours to figure this out.

Happy Coding!

Creating a useful BasePage

2009-06-01T06:46:00.000-07:00

When people start a new project,
creating a Base Page for all other pages is a must! I found a very interesting, yet simple and concrete article about the Base Page and some of the useful methods, which can be included there. This Base Page is great for avoiding code duplication and has a good level of error handling.

You can read the article here: ASP.NET Tip/Trick: Use a Base Page Class for All Application Pages

Page Refresh Handling
What I find useful adding to this Base Page, is a functionality for recognizing whether there is a Page Refresh occured (when the user presses F5 or Refresh button), because as you know, the Page Refresh actually does again what the last page post back was - all the events and stuff.
For example, when you click the button next of some results set you expect to move to the next page. What happens if you hit refresh after the rebinding? It actually executes again all the events from the previous post back, so it will move you to the next page, which you didn't want to. What is worse, it can break your application, because there can be no more results and no 'next' page. One way to handle this situation is to write some code in the Base Page so that you can track whether a Page Refresh occured and the other most common way is to stop/invalidate the page after refresh.

In conclusion,
I must remind that creating a common Base User Control is also useful and should be used as a best practice, too !

Visual Studio 2008 Keybinding Reference Poster

2009-04-21T05:40:00.000-07:00

Hi, guys !

This can sound like a promoting post for some of you, but I recently found this official Visual Studio 2008 Keybinding Reference Poster, which can be downloaded freely from here.

I find it very educative,useful and quite inspiring for myself - hanging there on the wall just in front of me. No more wondering how the Format Document or Format Selection key combination was.

Luckily,
Microsoft have created such Reference Posters for other tools and technologies too, so I will be enjoying most of them soon.

More Reference Posters
.NET Framework 3.5 Common Namespaces and Types Poster
Microsoft® Silverlight™ 1.1 Alpha Developer Reference Poster

getElementById compared in IE6, IE7 and IE8

2009-03-24T04:10:00.001-07:00

Hi guys!

These days I was enjoying the new Internet Explorer 8 and were observing the differences with the previous versions of the browser.

I encountered a problem connected with the getElementById method. It was working OK in IE6 and IE7, and now in IE8 it suddenly stopped working.

How does getElementById works in IE6/IE7
In IE6 and IE7, the method getElementById would get an element provided either the ID or the Name attribute of the element. What is more, it matches it case-insensitevily.

In Comparison
In IE8 it does exactly what it says and what it should do - it gets the element only by the ID attribute and it matches case-sensitively.

Conclusion
The reason why the old code wasn't working in IE8 was because someone has used the getElementById to get an element on the page provided it's Name. Which apparently won't work in IE8.

More on this
More on this, Here (Check the Remarks paragraph)

asp:FileUpload control in Modal Popup Extender

2009-03-20T05:31:00.000-07:00

Hello guys !

Let's go straight to the issue this time.
I have a Modal Popup Extender and want to use the standard FileUpload control in it. What I mean by saying the "standard FileUpload" control is that I will use the asp:FileUpload control and not the AJAX-enabled one which is in the AJAX Control Toolkit.

What's the issue/problem?
The problem is that the AJAX makes partial updates and doesn't perform a full postback. The FileUpload control itself works with full postback - in the postback the File which you uploaded is attached in the Request.Files collection. So, when you are not performing a full postback, the file is not uploaded in the Request.Files collection and you cannot get the file to use it - for saving in the database for example.

The solution
The Script Manager has one very useful method - RegisterPostBackControl ( http://msdn.microsoft.com/en-us/library/system.web.ui.scriptmanager.registerpostbackcontrol.aspx ). It basically registers a control, which should implicitly do a full postback. In my case, it was enough just to register the FileUpload holding control to perform a full postback and I had the File uploaded into the Request.Files and ready for use.

Conclusion
The issue and the solution were pretty straight-forward this time. But it can become trickier, if you don't know the RegisterPostBackControl method.

ASP.NET Validator in Modal Popup Extender

2009-03-04T05:19:00.000-08:00

Yesterday,
I had an interesting issue, which I want to share with you.

The Case
I had a RequiredFieldValidator in a Modal Popup Extender. After closing the popup, everything in my web page freezed. For example, clicking a LinkButton/Button wouldn't do a postback, everything just stopped working.

The Problem
After some kind of debugging, I figured out the problem. As you know, the modal popup extender works like this:
1.) When you invoke the .Show() method of the Modal Popup Extender, the AJAX.NET takes the PopupControl you want to Show as a popup and brings it to the front.
2.) When you invoke the .Hide() method or close the Modal Popup Extender from a button inside it, it again takes the PopupControl and hides it in the page.
So, the problem I encountered was, that when the user entered some invalid data and presses the cancel button(to close the ModalPopupExtender and to cancel the changes), the AJAX.NET hided the PopupControl in the page. The problem was, that the RequiredFieldValidator was yielding that there is invalid data, so it was blocking all the postbacks. The cute thing is, that you can't actually see the RequiredFieldValidator, because it's in the Modal Popup which you don't see, too.

The Solution
The simplest thing to do, was to clear all the Validators from the ModalPopupExtender, when I hide it. This is not a neat solution for me, but I don't know any better for now.

Conclusion
Probably, people encounter such a 'problem' on rare occasions, but I found it useful for myself, and will be aware of this.

XML comment contains invalid XML: Whitespace is not allowed at this location

2009-02-18T01:23:00.000-08:00

Today, I encountered this error: "XML comment contains invalid XML: Whitespace is not allowed at this location".

The problem occured in a code similar to this one:

///

/// Calculates the area & the surface
///

public double CalculateAreaAndSurface()

* Please, note that this above is just a sample code to illustrate the error, not a meaningful function or well written.

So, when I started using this function, I called it like this ObjectInstance.CalculateAreaAndSurface(), and the Visual Studio(2005 or 2008) didn't show me the comment I have written, but the error instead: "XML comment contains invalid XML: Whitespace is not allowed at this location".

After a small research, I figured out that the problem in the comment was that there is the character "&" in it, which should be replaced with the escaped version "& amp;". Some other characters like < and > are in this list of forbidden characters and should be escaped too.

WPF - Is it my preferred choice for graphics ?

2009-01-29T06:09:00.000-08:00

Hi guys!

I want to share with you some experience with WPF
Recently, I started doing a very simple Graphics project and encountered some difficulties. I wanted to share with you the thing which frustrated me mostly.

What is the most simple thing we should do when using Graphics?
For me, this is to load a simple image and manipulate it. This was pretty easy with GDI+ and System.Drawing classes like Image and Bitmap. You had everything needed - you could load a Bitmap simple like this Image.FromImage(path_to_file) and you could as easily manipulate the Bitmap's pixels - Bitmap.SetPixel(x, y, color). I of course wanted to use the same 'tricks' in WPF, but couldn't do it. After some research, I figured out why:

"GDI+ was a bit different in the sense that the Bitmap object was always cached in memory, so having a SetPixel method made sense. However, this may not be the case in WPF. For applications that do not wish to load the entire image in memory, WPF provides a way to load the image such that it is read from disk on a per-demand basis. In this case, a SetPixel equivalent does not make much sense and would not work. Thus we have chosen to not include this functionality for V1 and will consider such an API for future version."

In Conclusion
Firstly, I couldn't believe this. I could have gone with using Windows Forms Project from the very beginning, but was excited to try the WPF.
I wonder if WPF is grown enough to be used in real projects... ? I will appreciate any professional opinions on the theme.

DOCTYPE element, why do we need it ?

2008-10-17T00:08:00.000-07:00

Hey guys !

I wanna share with you some things about this DOCTYPE element which is included at the top of the html page.

Firstly, if we are using the Microsoft's AJAX Toolkit, we should ensure that we have a DOCTYPE element included, because some of our controls can freeze and not work. In my case, I was using a ModalPopupExtender which appeared in the upper left corner of the window and everything freezes (for comparision it's expected to be showed in the center of the screen ). For bad, browsers are different and in Firefox this ModalPopupExtender will work without problems, but there's no chance to work in IE. So if something with your AJAX Toolkit is behaving strange the first thing to check is the DOCTYPE element :)

Another thing which is notable to not work when the DOCTYPE element is missing is the CSS. Some properties like font-size can stop working, or again behave strange .. what is more it will depend on the browser, some things will work on Firefox and won't work in IE .. so it becomes even harder to locate the problem.

To conclude, if you have strange problems with AjaxToolkit or CSS, firstly ensure to check whether there is a DOCTYPE element in the html. Yes, I know that when Visual Studio creates a page it includes a DOCTYPE element, but in my case someone has removed this DOCTYPE for some reason .. and I had hard times figuring out why the ajaxcontrol toolkit controls was acting so strange.

More information about the doctype and the browser modes:
http://en.wikipedia.org/wiki/Quirks_mode -- quirks mode is the mode the browser enters, when you don't specify a DOCTYPE in all the browsers, when we're talking about the Transitional DTD. (You can check this by looking up in the table for HTML 4.01 spec. and Transitional DTD)

Persisting dynamically built GridView's state and data

2008-08-14T00:46:00.000-07:00

As I promised, there will be one more post about creating dynamically a GridView.
Let’s now see what happens on a Post Back ?
Our GridView created dynamically with template fields is lost. As we know the GridView has a property called “EnableViewState”. If we set this property to “true” we can expect our GridView and it’s data to be persisted after the post back. But that’s not the case. The “EnableViewState” itself saves only the data in the cells of the GridView to the ViewState, so we will again see nothing. What we have to do (something we should do to every control we have somehow constructed dynamically) is to build the GridView over and over again every time the Page is sent back to the server. We have to do this on an event where we still have the ability to change the Page’s layout and controls included in it.
For example if we are creating an UserControl we should reconstruct the GridView on it’s Init event ( http://msdn.microsoft.com/en-us/library/system.web.ui.control.init.aspx ). If we are doing this in a Web Page we should place our code in the PreInit event ( http://msdn.microsoft.com/en-us/library/system.web.ui.page.preinit.aspx ).
Now we have accomplished our task to save the GridView after Post Back. Unfortunately, creating dynamically controls needs much more coding, than creating them statically.
The other thing I would like to share is very simple. It answers the question ‘How do we handle the edit of such a custom grid ?’
We will create our own column with Edit/Update/Cancel link buttons. We place a code like this in the GridView control:

<asp:TemplateField ShowHeader="False">
     <ItemTemplate>
         <asp:LinkButton ID="lbEdit" CommandName="Edit" Text="Edit" runat="server" />

     </ItemTemplate>
     <EditItemTemplate>
         <asp:LinkButton ID="lbUpdate" CommandName="Update" Text="Update" runat="server" />

         <asp:LinkButton ID="lbCancel" CommandName="Cancel" Text="Cancel" runat="server" />

     </EditItemTemplate>
</asp:TemplateField>

Please, note that we could have just set the property of the GridView “AutoGenerateEditButton” to true to let the framework generate such a column for us.
No we have to handle the events for Update, Cancel, Edit adding code again in the GridView for the events, like this:

OnRowEditing="gv_RowEditing"
OnRowCancelingEdit="gv_RowCancelingEdit"
OnRowUpdating="gv_RowUpdating"

Now the only thing left is to implement the above methods in the code behind to handle the raised events. Sample code goes below:

protected void gv_RowEditing(object sender, GridViewEditEventArgs e)
        {
            gv.EditIndex = e.NewEditIndex; // set the edit index, which causes
                                           // the GridView to enter it’s edit
                                           // mode
            // Rebind data here
        }
        protected void gv_RowCancelingEdit(object sender, GridViewCancelEditEventArgs e)
        {
            gv.EditIndex = -1;             // Clear the edit index, and return
                                           // to change the mode again.                                 
            // Rebind data here
        }
        protected void gv_RowUpdating(object sender, GridViewUpdateEventArgs e)
        {
            DataTable dt = TableGV;         // This is my object behind the                        
                                            // GridView which holds it’s data.
                                            // And I want it updated.
           GridViewRow row = gv.Rows[e.RowIndex];
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                dt.Rows[gv.EditIndex][i] = ((TextBox)(row.Cells[i + 1].Controls[0])).Text.Trim(); // Get the data from the GridViewRow
            }
            gv.EditIndex = -1; // Again change the mode
            // Rebind data here
        }

That’s all, we now have a complete editable custom dynamically created GridView Control.

How to build a Grid View dynamically ?

2008-07-24T06:49:00.000-07:00

Today I will show you something pretty standard - how to build a asp:GridView when you don't know in advance how it will be formatted, what Columns should be bounded...
We have to build the GridView’s structure – it’s Columns. We can see that GridView.Columns.Add method takes a DataControlField as a parameter, so our attention should go to Controls inheriting DataControlField so that we can add them to the Columns collection.

There are two kinds of columns we can use - a BoundField and a TemplateField.

The first one – a BoundField , is easy to create and use. We can set properties like DataField,HeaderText, HeaderStyle, ReadOnly and so on. But we can’t set a template. This control should be used when adding a very simple row, which won’t be edited or no complex formatting will be applied to it. It’s the easiest way to add a new column, but it’s not flexible enough for all we can need. So, BoundField should be used when we don’t want anything complex from the Column.

The TemplateField on the other hand is powerful.

namespace System.Web.UI.WebControls
{
    public class TemplateField : DataControlField
    {
        public TemplateField();

        public virtual ITemplate AlternatingItemTemplate { get; set; }
        public virtual bool ConvertEmptyStringToNull { get; set; }
        public virtual ITemplate EditItemTemplate { get; set; }
        public virtual ITemplate FooterTemplate { get; set; }
        public virtual ITemplate HeaderTemplate { get; set; }
        public virtual ITemplate InsertItemTemplate { get; set; }
        public virtual ITemplate ItemTemplate { get; set; }
        protected override DataControlField CreateField();
        public override void ExtractValuesFromCell(IOrderedDictionary dictionary, DataControlFieldCell cell, DataControlRowState rowState, bool includeReadOnly);
        public override void InitializeCell(DataControlFieldCell cell, DataControlCellType cellType, DataControlRowState rowState, int rowIndex);
        public override void ValidateSupportsCallback();
    }
}

We can see from it’s class that it contains Properties for all the possible Templates (EditItemTemplate, ItemTemplate, InsertItemTemplate and etc.) . All templates should implement the ITemplate Interface , which is simple enough – it contains only one method – InstantiateIn(Control container)

namespace System.Web.UI
{
    public interface ITemplate
    {
        void InstantiateIn(Control container);
    }
}

In this method we should add whatever we like in the container. This method is called for every cell of the GridView, so the container is actually a DataControlField (which is not so important for now, except the fact that should be noted – the DataControlField is not the NamingContainer, but the GridViewRow is).
Now, for example , let’s create a class for ItemTemplate. Here is a sample code for an ItemTemplate:

public class CustomTemplateField : ITemplate
{
    public CustomTemplateField()
    {
    }

    public void InstantiateIn(Control container)
    {
        Label label = new Label(); 
        label.DataBinding += new EventHandler(label_DataBinding); // use the DataBinding event to
                                                                  // set the data to the label
        container.Controls.Add(label);                            // Simply add the control to the Controls
                                                                  // collection of the container
    }

    void label_DataBinding(object sender, EventArgs e)
    {
        Label lbl = sender as Label; // Get the label
        GridViewRow gvr = lbl.NamingContainer as GridViewRow; // And get it's naming container
        string text = DataBinder.Eval(gvr.DataItem, "Name").ToString(); // We can now use the DataItem
                                                                        // to bind some data to our
                                                                        // Controls in the cell
        lbl.Text = text; // we can of course here perform some formatting
    }
}

Any other Template’s implementation is similar to the above’s one. If we want to provide edit functionality, we should make an EditItemTemplate, for example like this one:

public class EditItemTemplate : ITemplate
{
    public EditItemTemplate()
    {
    }

    public void InstantiateIn(Control container)
    {
        TextBox txt = new TextBox();
        txt.ID = "TextBoxID";
        txt.DataBinding += new EventHandler(txt_DataBinding);
    }

    void txt_DataBinding(object sender, EventArgs e)
    {
        TextBox tb = sender as TextBox;
        GridViewRow gvr = sender as GridViewRow;
        tb.Text = DataBinder.Eval(gvr.DataItem, "Name").ToString();
    }
}

So it’s pretty easy to create dynamically a GridView with TemplateFields. And that’s all we needed to build dynamically a GridView !

What's next ?
In the next post, I will show you how we can handle the edit operation on such GridView and how to use it's ViewState.