2013 in review

Posted on January 5, 2014 by Thuru

The WordPress.com stats helper monkeys prepared a 2013 annual report for this blog.

Here’s an excerpt:

The concert hall at the Sydney Opera House holds 2,700 people. This blog was viewed about 14,000 times in 2013. If it were a concert at Sydney Opera House, it would take about 5 sold-out performances for that many people to see it.

Click here to see the complete report.

CRUD operations in Infragistics WebDataGrid

Posted on December 4, 2013 by Thuru

DataGrids are vital controls in many user interfaces. Like it or not still 2D tables are one of the most comfortable user interface elements in not only viewing data but also in performing rapid inserts and updates.

CRUD operations of DataGrid is not a big innovation, but there are plenty of ways to do that. This post explains how to perform CRUD operations using Infragistics WebDataGrid control in ASP.NET.

This code is written using Infragistics version 12.2

Create a simple WebDataGrid.

<ig:WebDataGrid ID="WebGridCarton" runat="server" Height="350px" Width="100%" AutoGenerateColumns="False" 
   DataKeyFields="CartonViewModelGuid" EnableDataViewState="True" 
   OnRowAdded="WebGridCarton_RowAdded" OnRowAdding="WebGridCarton_RowAdding" 
   OnRowDeleted="WebGridCarton_RowDeleted" OnRowsDeleting="WebGridCarton_RowsDeleting" 
   OnRowUpdated="WebGridCarton_RowUpdated" OnRowUpdating="WebGridCarton_RowUpdating">
   <Columns>
       <ig:BoundDataField DataFieldName="CartonViewModelGuid" Key="CartonViewModelGuid" Hidden="true" HtmlEncode="true">
       <Header Text="Guid">
       </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="CartonInfoId" Key="CartonInfoId" Hidden="true" HtmlEncode="true">
           <Header Text="Id">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="SelectionColumn" Key="SelectionColumn" HtmlEncode="true" Width="15">
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="Size" Key="Size" HtmlEncode="true">
           <Header Text="Size">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="Length" Key="Length" HtmlEncode="true">
           <Header Text="Length (cm)">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="Width" Key="Width" HtmlEncode="true">
           <Header Text="Width (cm)">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="Height" Key="Height" HtmlEncode="true">
           <Header Text="Height (cm)">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="Volume" Key="Volume" HtmlEncode="true">
           <Header Text="Volume (cbm)">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="Weight" Key="Weight" HtmlEncode="true">
           <Header Text="Weight (kg)">
           </Header>
       </ig:BoundDataField>
       <ig:BoundDataField DataFieldName="WeightLimit" Key="WeightLimit" HtmlEncode="true">
           <Header Text="Weight Limit (kg)">
           </Header>
       </ig:BoundDataField>
   </Columns>
   <Behaviors>
       <ig:Activation Enabled="true"></ig:Activation>
       <ig:Selection CellClickAction="Row" RowSelectType="Single" Enabled="true"></ig:Selection>
       <ig:EditingCore AutoCRUD="false">
           <Behaviors>
               <ig:CellEditing EditModeActions-EnableF2="true" EditModeActions-MouseClick="Single" Enabled="true">
                   <ColumnSettings>
                       <ig:EditingColumnSetting ColumnKey="CartonInfoId" ReadOnly="true" />
                       <ig:EditingColumnSetting ColumnKey="SelectionColumn" ReadOnly="true" />
                       <ig:EditingColumnSetting ColumnKey="CartonViewModelGuid" ReadOnly="true" />
                       <ig:EditingColumnSetting ColumnKey="Size" EditorID="DropDownProvider_Size" ValidatorID="RequiredFieldValidator1" />
                       <ig:EditingColumnSetting ColumnKey="Length" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:EditingColumnSetting ColumnKey="Width" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:EditingColumnSetting ColumnKey="Height" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:EditingColumnSetting ColumnKey="Volume" EditorID="WebTextEditor1" ReadOnly="true" ValidatorID="DecimalValidator" />
                       <ig:EditingColumnSetting ColumnKey="Weight" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:EditingColumnSetting ColumnKey="WeightLimit" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                   </ColumnSettings>
                   <EditModeActions MouseClick="Single" />
               </ig:CellEditing>
               <ig:RowAdding Alignment="Top" EditModeActions-EnableF2="true" EditModeActions-EnableOnActive="true"
                   EditModeActions-MouseClick="Single" Enabled="true">
                   <EditModeActions EnableOnActive="True" MouseClick="Single" />
                   <ColumnSettings>
                       <ig:RowAddingColumnSetting ColumnKey="SelectionColumn" ReadOnly="true" />
                       <ig:RowAddingColumnSetting ColumnKey="Size" EditorID="DropDownProvider_Size" ValidatorID="RequiredFieldValidator1" />
                       <ig:RowAddingColumnSetting ColumnKey="Length" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:RowAddingColumnSetting ColumnKey="Width" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:RowAddingColumnSetting ColumnKey="Height" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:RowAddingColumnSetting ColumnKey="Volume" EditorID="WebTextEditor1" ReadOnly="true" ValidatorID="DecimalValidator" />
                       <ig:RowAddingColumnSetting ColumnKey="Weight" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                       <ig:RowAddingColumnSetting ColumnKey="WeightLimit" EditorID="WebTextEditor1" ValidatorID="DecimalValidator" />
                   </ColumnSettings>
               </ig:RowAdding>
               <ig:RowDeleting Enabled="true" />
           </Behaviors>
       </ig:EditingCore>
   </Behaviors>
   <EditorProviders>
       <ig:TextBoxProvider ID="WebTextEditor1">
           <EditorControl ID="EditorControl1" ClientIDMode="Static" runat="server"></EditorControl>
       </ig:TextBoxProvider>
       <ig:DropDownProvider ID="DropDownProvider_Size">
           <EditorControl ClientIDMode="Predictable" DropDownContainerMaxHeight="100px" EnableAnimations="False"
               EnableDropDownAsChild="False" ID="CartonSizeDrdEditor" DropDownContainerWidth="185px" AutoPostBack="true" 
               EnableAjaxViewState="true">
           </EditorControl>
       </ig:DropDownProvider>
   </EditorProviders>
</ig:WebDataGrid>

This grid has one drop down editor and others fields are text box editors. And it supports CRUD. The grid control has 6 CRUD events associated with it. They’re RowAdding, RowAdded, RowUpdating, RowUpdated, RowDeleting and RowDeleted.

This is the ViewModel class used for data binding.

public class CartonInfoGridViewModel
{
    public string CartonViewModelGuid { get; private set; }
  
    public int CartonInfoId { get; set; }
    public string Size { get; set; }
    public string Length { get; set; }
    public string Width { get; set; }
    public string Height { get; set; }
    public string Volume { get; set; }
    public string Weight { get; set; }
    public string WeightLimit { get; set; }
  
    public CartonInfoGridViewModel()
    {
        this.CartonViewModelGuid = Guid.NewGuid().ToString();
    }
}

CartonViewModelGuid property is used identify the objects in the Session collection.

Adding Rows

In the RowAdding event we create a new ViewModel object with the values entered in the grid. And add it to the Session collection then we bind the Session collection to the grid. Please note these property names are same as the ones in the ASPX file.

protected void WebGridCarton_RowAdding(object sender, Infragistics.Web.UI.GridControls.RowAddingEventArgs e)
{
    var cartonRow = new CartonInfoGridViewModel();
  
    cartonRow.CartonInfoId = -1;
    cartonRow.Size = e.Values["Size"].ToString();
    cartonRow.Length = e.Values["Length"].ToString();
    cartonRow.Width = e.Values["Width"].ToString();
    cartonRow.Height = e.Values["Height"].ToString();
    cartonRow.Volume = e.Values["Volume"].ToString();
    cartonRow.Weight = e.Values["Weight"].ToString();
    cartonRow.WeightLimit = e.Values["WeightLimit"].ToString();
  
    if (this.Session["GridGridCartonsInfo"] != null && this.Session["GridCartonsInfo"] is List<CartonInfoGridViewModel>)
    {
        var collection = Session["GridCartonsInfo"] as List<CartonInfoGridViewModel>;
        collection.Add(cartonRow);
    }
    else
    {
        var collection = new List<CartonInfoGridViewModel>();
        collection.Add(cartonRow);
    }
  
    this.DataBindCaronInfoGrid();
}

DataBindCaronInfoGrid method binds the Session data to the Grid.

Just to prevent any Javascript errors popping up during this process in the RowAdded event we suppress the exceptions.

protected void WebGridCarton_RowAdded(object sender, Infragistics.Web.UI.GridControls.RowAddedEventArgs e)
{
    e.ExceptionHandled = true;
}

Deleting Rows

To delete a row we get the Id of the object and remove it from the Session collection. And bind the Session data to the grid.

protected void WebGridCarton_RowsDeleting(object sender, Infragistics.Web.UI.GridControls.RowDeletingEventArgs e)
{
    string id = e.Row.DataKey.First().ToString();
  
    if (this.Session["GridGridCartonsInfo"] != null && this.Session["GridCartonsInfo"] is List<CartonInfoGridViewModel>)
    {
        var collecion = this.Session["GridGridCartonsInfo"] as List<CartonInfoGridViewModel>;
  
        var removeItem = collecion.FirstOrDefault(c => c.CartonViewModelGuid == id);
  
        if (removeItem != null)
            collecion.Remove(removeItem);
    }
  
    this.DataBindCaronInfoGrid();
}
  
protected void WebGridCarton_RowDeleted(object sender, Infragistics.Web.UI.GridControls.RowDeletedEventArgs e)
{
    e.ExceptionHandled = true;
}

Updating Rows

Updating the rows happens the same way, we identify the object via the Id and update the values.

protected void WebGridCarton_RowUpdating(object sender, Infragistics.Web.UI.GridControls.RowUpdatingEventArgs e)
{
    if (Session["GridGridCartonsInfo"] != null && Session["GridGridCartonsInfo"] is List<CartonInfoGridViewModel>)
    {
        var collection = Session["GridGridCartonsInfo"] as List<CartonInfoGridViewModel>;
  
        if (e.OldValues["CartonViewModelGuid"].ToString() == e.Values["CartonViewModelGuid"].ToString())
        {
            string id = e.Values["CartonViewModelGuid"].ToString();
  
            var editItem = collection.FirstOrDefault(c => c.CartonViewModelGuid == id);
  
            if (editItem != null)
            {
                editItem.CartonInfoId = Convert.ToInt32(e.Values["CartonInfoId"]);
                editItem.Size = e.Values["Size"].ToString();
                editItem.Length = e.Values["Length"].ToString();
                editItem.Width = e.Values["Width"].ToString();
                editItem.Height = e.Values["Height"].ToString();
                editItem.Volume = e.Values["Volume"].ToString();
                editItem.Weight = e.Values["Weight"].ToString();
                editItem.WeightLimit = e.Values["WeightLimit"].ToString();
            }
        }
  
        this.DataBindCaronInfoGrid();
    }          
}
  
protected void WebGridCarton_RowUpdated(object sender, Infragistics.Web.UI.GridControls.RowUpdatedEventArgs e)
{
    e.ExceptionHandled = true;
}

Note

In the ViewModel class CartonViewModelGuid property is used as the object identifier in the collection. (In this case collection is persisted in the ASP.NET Session) For the new rows we set the CartonInfoId to –1, because this is an identity column in the database.

When we update the objects which are stored in the database already we can’t change the CartonInfoId that’s the reason why we use a separate Id property for the ViewModels.

The code for the DataBindCaronInfoGrid method

private void DataBindCaronInfoGrid()
{
    if (this.Session["GridCartonsInfo"] != null && this.Session["GridCartonsInfo"] is List<CartonInfoGridViewModel>)
    {
        this.WebGridCarton.DataSource = Session["GridCartonsInfo"] as List<CartonInfoGridViewModel>;
        this.WebGridCarton.DataBind();
    }
    else
        this.LblStatus.Text = "Session expired, Please reload the page.";
}

C# – implicit & explicit keywords

Posted on September 11, 2013 by Thuru

What are the uses of the implicit and explicit keywords in C#.

implicit is used when we need implicit conversions between types. It works on value types and as well on reference types.

The below code shows the use of implicit keyword. Create a class named Digit as below and note the two static methods with implicit keyword.

class Digit
{
    public double val;
    
    public Digit(double d)
    {
        val = d;
    }
  
    public static implicit operator double(Digit d)
    {
        return d.val;
    }
  
    public static implicit operator Digit(double d)
    {
        return new Digit(d);
    }
  
}

Since the Digit class has both the Digit to double conversion and the double to Digit conversion implicit functions defined, it is safe to do the following.

Digit dig = new Digit(7);
  
//This call invokes the implicit "double" operator 
double num = dig;
//This call invokes the implicit "Digit" operator
Digit dig2 = 12;

Same works on complete reference types as well. Look at the following example.

class Animal
{
    public string  Family { get; set; }
  
    public static implicit operator Dog(Animal animal)
    {
        return new Dog() { Breed = animal.Family };
    }
  
    public static implicit operator Animal(Dog d)
    {
        return new Animal() { Family = d.Breed };
    }
}
  
class Dog
{
    public string Breed { get; set; }
}

These following conversions are possible.

Animal a = new Animal() { Family = "Golden Retriever" };
Dog d1 = a;
a = d1;

explicit keyword does the right opposite, where we have to explicitly cast the one type to the other. Say we’ve a set of classed like this.

class WaterCleaner
{
    public string Name;
}
  
class RoboticCleaner
{
    public string Name;
  
    public static explicit operator WaterCleaner(RoboticCleaner r)
    {
        return new WaterCleaner() { Name = r.Name };
    }
  
    public static explicit operator RoboticCleaner(WaterCleaner w)
    {
        return new RoboticCleaner() { Name = w.Name };
    }
}

Then you should do the explicit casting like this.

   1: RoboticCleaner rc = new RoboticCleaner() { Name = "Super Cleaner" };
   2: WaterCleaner wc = (WaterCleaner)rc;

If RoboticCleaner has implicit conversion defined then you don’t need the explicit conversion.

Now the question is what if the RoboticCleaner class has both implicit and explicit conversions defined.

Now your RoboticCleaner should be like this.

class RoboticCleaner
{
    public string Name;
  
    public static explicit operator WaterCleaner(RoboticCleaner r)
    {
        return new WaterCleaner() { Name = r.Name };
    }
  
    public static explicit operator RoboticCleaner(WaterCleaner w)
    {
        return new RoboticCleaner() { Name = w.Name };
    }
  
    public static implicit operator WaterCleaner(RoboticCleaner r)
    {
        return new WaterCleaner() { Name = r.Name };
    }
}

Then the compiler gets confused and shows this message. (click on the image to enlarge)

How to become Zeus, the great Greek God in less than $ 3,000

Posted on August 25, 2013 by Thuru

Have you ever thought about this ? How much do you really have to spend to become like Zeus, the great Greek god. Zeus is a Greek god considered as the god of the gods. Among his many super natural powers one that’s very powerful that he can materialize the objects by thinking.

So, what is to do with the current technology, how we can get that power, if we’re to get that how much it would cost ?

I say it would cost you less than $ 3,000

What do you need ?

EPOC neuroheadset – a device / gadget which is used to give commands to the computers just by thinking. This costs around $ 299.

MakerBot Replicator 2 Desktop 3D Printer

MakerBot – A 3D printer for the desktops costs around $ 2,199. It comes with a software (MakerBot Makerware) to model the objects and you import other file formats as well.

What else do we need ? We might need the EPOC SDK for the development of custom software (a free version is available or we can go for a single license which costs around $500)

We have to write our own piece of code which can get the model in our mind using EPOC SDK and transfer it to the MakerBot Makerware. Then the magic happens.

You’re Zeus, you can materialize objects just by thinking.

Deactivate Windows

Posted on August 20, 2013 by Thuru

Hi, this is really a different type of post, could be considered as radical too. Because almost everywhere in the Internet you see the posts describing how to activate the Windows (either genuinely or using any cracked piece of software or some fake serial key). But this post in contrast describes how to deactivate the Windows.

First why do you want to deactivate the Windows ? Simple, you may want to deactivate the Windows for several reasons, but one main reason is to install another serial key with a different edition. You can always do this without deactivating the current one, but still in few circumstances you may need to deactivate the Windows.

Deactivating the Windows is quite simple, just a simple command line statement. Open CMD in the Admin mode. Then type the following slmgr.vbs –upk and enter.

This will remove the current serial key from the Windows and leaves the OS in the deactivated state.

Embedding Resources in Silverlight

Posted on July 30, 2013 by Thuru

This post explains how to embed a resource file in Silverlight and use it. For the example we’ll consider embedding a CSV file and using it.

Copy the file inside the project under the appropriate path. In the properties of the file set the Build Action as Embedded Resource.

The below sample code shows how to access an embedded CSV file.

Stream shareInfo = typeof(ShareInformationManipulation)
                   .Assembly
                   .GetManifestResourceStream("data.csv");

You can read any type of embedded resource as a Stream.

VS 2013 Preview – New Features

Posted on July 23, 2013 by Thuru

VS 2013 preview is here. It has loads of new cool features. Mainly it comes with the .NET 4.5.1 If you are to develop for Windows 8.1 then you should install VS 2013 preview. This blog post describes some of the cool features in the VS 2013.

Immediately after installing the VS 2013 Preview, I started a simple Console project just to check the features listed in the above post. But besides everything one feature attracted me and it’s not mentioned in the above post. (They might have thought this is too obvious for anyone to figure it out)

VS 2013 shows the number of times each class or method is referenced on top of their declaration. This is cool and when you click on that info it will open a tooltip.

When you hover the mouse on the each reference info you will get another tooltip showing more details about the reference.

When click on the reference in the main tooltip, no wonder it will take you to the exact location of that particular reference is.

This is a super fabulous feature and we can use it for code reviews as well. This gives the overall information of how many times a class / method is referenced or called. This will provide helpful information for the performance analysis as well.

VS Blog shows how the map view in the scrollbar works, but by default this feature is disabled. To enable this right click on the scroll bar and go to Scroll Bar Options. There you can select the Use map mode for vertical scroll bar it will bring the map view which you can use to view the areas of your code without scrolling.

The VS blog says the main goal behind the VS 2013 is to bring the developer in context, it is facilitated that developer can do more without losing his scope of working context.

This is GREAT 🙂

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this: