ObjectCache – Caching

Posted on April 1, 2014 by Thuru

In the ASP.NET domain all the state mechanisms can be considered as caching, both in the client side (view states, query strings, cookies) and in the server side (application state, session state and the Cache object itself.) You can define the classes and properties as static to get the effective functionality of caching. In ASP.NET the Cache object is HttpContext.Cache and .NET 4 introduced the ObjectCache to be used in non ASP.NET applications. This post will walk you through about the ObjectCache. Learn about Windows Azure Caching.

ObjectCache

This is included in the System.Runtime.Caching assembly. MemoryCache is the concrete implementation of this library. The following method provides a quick glance on how ObjectCache can be used.

public static void PutInCache(string key, object value)
{
    
    var cache = MemoryCache.Default;
    var policy = new CacheItemPolicy()
    {
        AbsoluteExpiration = new DateTimeOffset(DateTime.Now.AddMinutes(5)),
        Priority = CacheItemPriority.Default
    };
  
    Console.WriteLine("Cache Size for the application in MB - {0}", cache.CacheMemoryLimit / ( 1024 * 1024) );
    Console.WriteLine("{0}% cache memory is used.", (100 - cache.PhysicalMemoryLimit));
  
    cache.Remove(key);
    
    cache.Add(key, value, policy);
  
    int result = (int) cache.Get(key);
    
}

CacheMemoryLimit property gives the allocated cache memory for the specific instance of your application, where as PhysicalMemoryLimit give the unused space of the cache in percentage. When the cache memory reaches beyond the CacheMemoryLimit then cache values are removed automatically, we can track this and take actions by registering a callback for the cache item removal.

Cache have 2 types of expiration policies. AbsoluteExpiration is the definite time after which there’s no guarantee for the item to be available in the cache memory, SlidingExpiration is where if there’re no access to the particular cache item within the specified time period there’s no guarantee for that item to be available. These 2 are very common and available in the HttpContext.Cache as well.

Cache has a priority which takes the value of the CachItemPriority enum. This enum has 2 values Default and Not Removable. Default is the default set up, means when you do not mention any value this would be applied. Default ensures the default behavior of the cache. Not Removable is used to instruct the system not to clear the values from the cache even when the system runs low in memory. These values should be cleared explicitly.

Windows server 2008 Core doesn’t support the ObjectCache and some Itanium implementations also do not support ObjectCache. Windows Server 2008 R2 with SP1 and later versions (including Windows 8.1) support ObjectCache.

Few good to know features of Entity Framework

Posted on March 3, 2014 by Thuru

I have been doing some reading about advance EF features for last couple of weeks and got to know some interesting things, this post is a compilation of the information and provides links to the relevant sites.

Starting with EF 5.0 ObjectContext was replaced with DbContext. So what’s the difference between ObjectContext and DbContext ?

This link gives the simplest answer for the above question. And using the following code you get the ObjectContext from your DbContext. Say that your have model class named MyEntities the best practice is to create a partial class (partial classes are the safest way since the auto generated classes could be overridden at any time there’s a code regeneration) and create a property that returns the ObjectContext. The below code describes the idea.

public partial class MyEntities : DbContext
{
    public System.Data.Entity.Core.Objects.ObjectContext ObjectContextProperty
    {
        get
        {
            return ((IObjectContextAdapter)this).ObjectContext;
        }
    }
}

Compiled Queries

Compiled Queries are helpful when we want to squeeze the final drop of performance from our application. We cache the TSQL statement which is produced from LINQ to Entity queries we write. Since we write the queries in LINQ these queries first get translated into TSQL statements and they’re executed against the SQL Server. As a result of caching the TSQL statements of the LINQ queries we cut down the translation time. Microsoft has mentioned this provides 7% performance improvement. Details here

This article provides information on creating compiled queries

MSDN Compile Query Class

The reason why I haven’t mention any samples here is that we do not need to worry much about the query compilation in EF 5.0 and above because it automatically happens.

This MSDN blog post explains the automatic query compilation in EF 5.0 and above. But again if you want to have more advanced and granular control over the compilation you should consider implementing your custom compiled queries. It’s better to have the compiled queries in your data repository classes.

Performance

Read this Data Access Blog article about the EF 5.0 performance. The below image take from the blog gives a summary.

As you see that updating to EF 5.0 on .NET 4.5 gives a greater performance boost to LINQ to Entities, automatic query compilation is one of the main features for this performance gain.

EF Versions – http://msdn.microsoft.com/en-us/data/jj574253

This channel 9 video is a good one about EF 5 and EF 6

http://channel9.msdn.com/Shows/Visual-Studio-Toolbox/Entity-Framework-5-and-6

Difference between Single and First in C#

Posted on February 20, 2014 by Thuru

In the extension methods Single / SingleOrDefault and First / FirstOrDefault have semantic distinction. Though in many places these methods are being used without the semantic consideration, more often they return the expected results. This behavior makes this misuse more common.

Both the Single and First methods have an accompanying helper method named as xxOrDefault which does nothing more than returning the default value of the specified data type if no element matches the query in the collection. For example if it’s a string collection they return null and if it’s an integer collection they return 0.

So the main semantic distinction comes between Single and First

To check this we create 3 collections like the following.

private static List<StudentViewModel> list0;
  
private static List<StudentViewModel> list1 = new List<StudentViewModel>()
{
    new StudentViewModel() { StudentId = 1, StudentName = "Thuru", Gpa = 3.92},
    new StudentViewModel() { StudentId = 2, StudentName = "Kristin", Gpa = 3.92},
    new StudentViewModel() { StudentId = 3, StudentName = "Jack", Gpa = 3.92},
    new StudentViewModel() { StudentId = 4, StudentName = "Anna", Gpa = 3.92},
    new StudentViewModel() { StudentId = 5, StudentName = "Anderson", Gpa = 3.92},
    new StudentViewModel() { StudentId = 6, StudentName = "Niki", Gpa = 3.92},
    new StudentViewModel() { StudentId = 7, StudentName = "Jhon", Gpa = 3.92},
    new StudentViewModel() { StudentId = 7, StudentName = "Brown", Gpa = 3.92},
};
  
private static List<StudentViewModel> list2 = new List<StudentViewModel>()
{
    
};

list0 is null, list1 and list2 are instantiated collections where list2 has no elements.

Single / SingleOrDefault

Single as the name specifies is used and should be used where there’s one and only element match the query.

//ArgumentNullException
list0.Single();
  
//ArgumentNullException
list0.SingleOrDefault();
  
// InvalidOperationException - Sequence contains no elements
list2.Single();
  
// works return null if there's no elements matching the criteria
StudentViewModel st = list2.SingleOrDefault();
  
  
// InvalidOperationException - Sequence contains more than one element
// if collection has only one element it returns that element
Console.WriteLine(list1.Single());
  
// works
Console.WriteLine(list1.Single(e => e.StudentId == 1));
  
// InvalidOperationException - Sequence contains more than one matching element
Console.WriteLine(list1.Single(e => e.StudentId == 7));
  
// InvalidOperationException - Sequence contains no matching element
Console.WriteLine(list1.Single(e => e.StudentId == 8));
  
StudentViewModel st1;
  
// InvalidOperationException - Sequence contains more than one element
st1 = list1.SingleOrDefault();
  
//works
st1 = list1.SingleOrDefault(e => e.StudentId == 1);
  
// InvalidOperationException - Sequence contains more than one matching element
st1 = list1.SingleOrDefault(e => e.StudentId == 7);
  
// works st1 is null
st1 = list1.SingleOrDefault(e => e.StudentId == 8);

First / FirstOrDefault

First has no issues when there’re more than one element matches the query, it simply returns the first element. But if there’re no element matching the query it prompts.

// ArgumentNullException
list0.First();
  
// ArgumentNullException
list0.FirstOrDefault();
  
// InvalidOperationException - Sequence contains no elements
list2.First();
  
// works return null if there's no elements matching the criteria
StudentViewModel st = list2.FirstOrDefault();
  
  
// returns the first element of the collection
Console.WriteLine(list1.First());
  
// works
Console.WriteLine(list1.First(e => e.StudentId == 1));
  
// returns the first element of the collection matches the query
Console.WriteLine(list1.First(e => e.StudentId == 7));
  
// InvalidOperationException - Sequence contains no matching element
Console.WriteLine(list1.First(e => e.StudentId == 8));
  
StudentViewModel st1;
  
// returns the first element of the collection
st1 = list1.FirstOrDefault();
  
// works
st1 = list1.FirstOrDefault(e => e.StudentId == 1);
  
// returns the first element of the collection matches the query
st1 = list1.FirstOrDefault(e => e.StudentId == 7);
  
// works st1 is null
st1 = list1.FirstOrDefault(e => e.StudentId == 8);

The code snippets and the comments describes the functions of the Single and First extension methods and their helping counter parts xxOrDefault.

About the semantic distinction.

If you know that your query should return only one element it’s better to use Single or SingleOrDefault. For example when you query a customer collection by customer ID you know that according to the business there’s only one customer ID with a specific value. First or FirstOrDefault could be used in the scenario but it doesn’t give you the semantics of the business logic.

And Single or SingleOrDefault throws an InvalidOperationException with the message ‘sequence contains more than one element’ if the collection has more than one element matching the query. This behavior sometimes can be used to validate.

Another common misuse of the above extension methods is chaining them unnecessarily with ‘where’ statement like this

// this is a common misuse
list1.Where(e => e.StudentId == 7).Single();
  
list1.Single(e => e.StudentId == 7);

If you want the code for the demonstration purpose you can download it here

SharePoint 2013 Item level Auditing

Posted on February 12, 2014 by Thuru

This post provides information about the item level auditing and how the server side object model works.

When you create site collection the auditing is not enabled by default. Each content database has a AuditData table to store the auditing information. You can enable the auditing at the site collection level through Site Settings => Site Collection Audit Settings. You can view the Audit Logs through Site Settings –> Audit Log Reports.

When no auditing is enabled and if you try to see / generate any of the available audit reports you will end up with a screen which says “Something went wrong”.

Now let’s walk through 2 scenarios to get some understanding about the SharePoint 2013 Item level Auditing.

Scenario 1 – No Auditing

Now in a clean new environment we will check the Audit status of the SPSite, SPWeb, SPList, SPListItem.

In the example we have a site collection and it has a Document Library names “AuditDocLib” and it has one document.

private static void PerformAuditFeatureCheck()
{
    string url = @"http://singlespserver/";
  
    using(SPSite site = new SPSite(url))
    {
        var siteAuditFlags = site.Audit.AuditFlags;
    
        var topLevel = site.OpenWeb();
        var topLevelAuditFlags = topLevel.Audit.AuditFlags;
        
        var sharedDocLib = topLevel.Lists.TryGetList("AuditDocLib");
        var shareDocLibAuditFlags = sharedDocLib.Audit.AuditFlags;
  
        var doc1 = sharedDocLib.Items.GetItemById(1);
        var doc1AuditFlags = doc1.Audit.AuditFlags;        
  
       }
}

When we run the above code AuditFlags of the SPSite, SPWeb, SPList and SPListItem is None.

Scenario 2 – Enabling Audit for specific ListItem

Now we’ll enable the auditing for a specific document in the AuditDocLib.

private static void EnableAuditForItem()
{
    string url = @"http://singlespserver/";
 
    using(SPSite site = new SPSite(url))
    {
        var topLevel = site.OpenWeb();
        
        var sharedDocLib = topLevel.Lists.TryGetList("AuditDocLib");
        
        // AuditFlag is None
        var shareDocLibAuditFlags = sharedDocLib.Audit.AuditFlags;
 
        var doc1 = sharedDocLib.Items.GetItemById(1);
        
        // AuditFlag is None
        var doc1AuditFlags = doc1.Audit.AuditFlags;        
 
        //enabling auditing for the item
        doc1.Audit.AuditFlags = SPAuditMaskType.View;
        doc1.Audit.Update();
    }
}

Now doc1 is audit enabled. And in the Audit Log Reports we can get the Audits. Below image shows the screen shot of the audit report after viewing the doc1 for few times.

Notice that the report also has the log entries for the Library (AuditDocLib). It is obvious that if a person want to view an item in the library more often he/she has to navigate to the corresponding List/Library and view the Item. But we didn’t specify to audit the Library; in the code the AuditMask is set only for the item.

Again we’ll run the PerformAuditFeatureCheck method to check the AuditFlags

You can see that the AuditFlags for the AuditDocLib is still None. This is because AuditFlags were not set for the AuditDocLib explicitly beacuse there’s no <NewAuditMask>4</NewAuditMask> event against the AuditDocLib.

This also hints us a point that just by retrieving the AuditFlags of a List / Library through the object model doesn’t give you the full insight of whether the particular List / Library is being audited. AuditFlags property gives the value of the last explicitly set AuditMask.

Accessing Contacts Information in Windows 8.1

Posted on February 12, 2014 by Thuru

Windows 8.1 SDK has lots of updates and changes compared to Windows 8 SDK. As an epitome of all these changes most of the Windows 8 SDK methods and classes have been deprecated and not advised to be used in the new development.

This post shows how to access the Contacts information in Windows 8.1 and 8. The new SDK is easy to use for sure and more sleek.

Accessing Contacts Information using Windows 8 SDK

private async void GetContactsDataUsingWindowd8SDK()
{
    var contactPicker = new Windows.ApplicationModel.Contacts.ContactPicker();
    contactPicker.CommitButtonText = "Select a contact";
  
    ContactInformation contact = await contactPicker.PickSingleContactAsync();
  
    // For multiple contacts Selection
    //IReadOnlyList<ContactInformation> contacts = await contactPicker.PickMultipleContactsAsync();
  
    var viewmodel = new ContactViewModel();
  
    if (contact != null)
    {
        string name = contact.Name;
  
        if (contact.Emails.Count > 0)
        {
            StringBuilder sb = new StringBuilder();
            foreach (IContactField field in contact.Emails)
            {
                sb.AppendFormat("{0} ({1}) \n", field.Value, field.Category);
            }
            string email = sb.ToString();
        }
  
        // Display the contact’s thumbnail
        Windows.Storage.Streams.IRandomAccessStreamWithContentType stream = await contact.GetThumbnailAsync();
  
        if (stream != null && stream.Size > 0)
        {
            BitmapImage image = new BitmapImage();
            image.SetSource(stream);
        }
    } 

Same to be done in Windows 8.1 SDK

private async void GetContactInfoUsingWindows81SDK()
{
    var contactPicker = new Windows.ApplicationModel.Contacts.ContactPicker();
    contactPicker.CommitButtonText = "Select Contacts";
  
    // select specific properties only
    contactPicker.SelectionMode = Windows.ApplicationModel.Contacts.ContactSelectionMode.Fields;
  
    //contactPicker.DesiredFieldsWithContactFieldType.Add();
  
    var contactCollection = await contactPicker.PickContactsAsync();
    //contactCollection.Add(new Windows.ApplicationModel.Contacts.Contact());
  
    List<ContactViewModel> contactViewModels = new List<ContactViewModel>();
  
    if (contactCollection != null)
    {
        foreach (var contact in contactCollection)
        {
            var viewmodel = new ContactViewModel();
  
            viewmodel.Id = contact.Id;
            viewmodel.FullName = contact.FirstName + " " + contact.LastName;
  
            if (contact.Emails.Any())
            {
                foreach (var email in contact.Emails)
                {
                    if (email.Kind == Windows.ApplicationModel.Contacts.ContactEmailKind.Personal)
                    {
                        viewmodel.PersonalEmail = email.Address;
                    }
                }
            }
  
            var thumbnail = await contact.Thumbnail.OpenReadAsync();
  
            if (thumbnail != null && thumbnail.Size > 0)
            {
                viewmodel.ContactThumbnail.SetSource(thumbnail);
            }
  
  
        }
    }
}

Code for the View Model class used in 8.1

public class ContactViewModel
{
    public string Id { get; set; }
  
    public string FullName { get; set; }
  
    public string PersonalEmail { get; set; }
  
    public BitmapImage ContactThumbnail { get; set; }
}

You can notice that 8.1 version the methods have changes and enums have been introduced to make the development more concise.

WinRT or WinMD Components

Posted on February 8, 2014 by Thuru

The WinRT platform provides developers with a new way to build reusable software components. WinRT types packaged in a WinRT component, also called a WinMD component (WinRT components == WinMD components). In traditional .NET application development, you could create a dynamic-link library (DLL) as a managed class library and use it in one or more applications.

This option is still available in Visual Studio. However, you can change the output type of a library project from class library to WinRT component, and the output of such a project is a WinMD (Windows Meta Data) file.

Benefits of creating a WinMD / WinRT component.

Contrasting to the DLL files WinRT / WinMD components can be accessed by unmanaged languages like C++ and Javascript. This allows us to create a WinRT / WinMD component in a managed language (C# or Visual Basic) and use it across different Windows Store Apps (WSA) projects implemented in unmanaged languages.

But this flexibility comes with some restrictions.

All public classes in WinRT / WinMD component should be marked sealed.
public fields aren’t allowed.
public data members must be declared as properties
Data types should be WinRT / WinMD compatible
Creating a WinRT / WinMD component in C++ has some additional property attribute settings (activatable class and ect…)

Creating a WinRT / WinMD component in C#

This is a very simple example and straight forward create Windows Store Apps (WSA) class library. Mark the class public and sealed. Create a method to return a string value.

Go to Project Properties and change the output type from Class Library to Windows Runtime Component.

Component Code

Do the build.

Accessing the C# WinRT in Javascript

Create a WSA project in Javascript. Add the WinRT project reference to the Javascript project.

Create a Javascript method to call the WinRT method. VS intellisense would guide you.

Javascript Code.

Here you can notice that the GetDate() C# method is formatted to getDate() with Javascript naming convention.

HTML Code

Run the code. 🙂

Things to consider

When you create a WinRT / WinMD component it is specifically designed for the Windows Runtime. Windows Runtime supports different language executions. In the above Javascript project we have a WinRT component developed in C# executed in the Javascript app. This is very useful when you want to extend your existing LOBs. You can use your existing managed code with little modifications, this cuts down development cost.

And also some complex data processing codes are hard to be written in pure Javascript. You can implement those in C++ and use the component in your front facing Javascript WSA.

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.";
}

Versatile Digital DNA

Category Archives: C#

ObjectCache – Caching

Few good to know features of Entity Framework

Difference between Single and First in C#

SharePoint 2013 Item level Auditing

Accessing Contacts Information in Windows 8.1

WinRT or WinMD Components

CRUD operations in Infragistics WebDataGrid

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this:

Share this: