CodeKicks.com - Focus on Microsoft Technologies

.Net Framework - Tuple Trouble: Why C# Tuples Get to Break the Guidelines

noreply@blogger.com (Ratnakar Dutt) — Wed, 27 Jun 2018 16:43:00 +0000

.Net Framework - Tuple Trouble: Why C# Tuples Get to Break the Guidelines

Back in the August 2017 issue of MSDN Magazine I wrote an in-depth article on C# 7.0 and its support for tuples (msdn.com/magazine/mt493248). At the time I glossed over the fact that the tuple type introduced with C# 7.0 (internally of type ValueTuple<…>) breaks several guidelines of a well-structured value type, namely:

• Do Not declare fields that are public or protected (instead encapsulate with a property).

• Do Not define mutable value types.

• Do Not create value types larger than 16 bytes in size.

These guidelines have been in place since C# 1.0, and yet here in C# 7.0, they’ve been thrown to the wind to define the System.ValueTuple<…> data type. Technically, System.ValueTuple<…> is a family of data types of the same name, but of varying arity (specifically, the number of type parameters). What’s so special about this particular data type that these long-respected guidelines no longer apply? And how can our understanding of the circumstances in which these guidelines apply—or don’t apply—help us refine their application to defining value types?

Let’s start the discussion with a focus on encapsulation and the benefits of properties versus fields. Consider, for example, an Arc value type representing a portion of the circumference of a circle. It’s defined by the radius of the circle, the start angle (in degrees) of the first point in the arc, and the sweep angle (in degrees) of the last point in the arc, as shown in Figure 1.

Figure 1 Defining an Arc

public struct Arc

{

public Arc (double radius, double startAngle, double sweepAngle)

{

Radius = radius;

StartAngle = startAngle;

SweepAngle = sweepAngle;

}

public double Radius;

public double StartAngle;

public double SweepAngle;

public double Length

{

get

{

return Math.Abs(StartAngle - SweepAngle)

/ 360 * 2 * Math.PI * Radius;

}

public void Rotate(double degrees)

{

StartAngle += degrees;

SweepAngle += degrees;

}

// Override object.Equals

public override bool Equals(object obj)

{

return (obj is Arc)

&& Equals((Arc)obj);

}

// Implemented IEquitable<T>

public bool Equals(Arc arc)

{

return (Radius, StartAngle, SweepAngle).Equals(

(arc.Radius, arc.StartAngle, arc.SweepAngle));

}

// Override object.GetHashCode

public override int GetHashCode() =>

return (Radius, StartAngle, SweepAngle).GetHashCode();

public static bool operator ==(Arc lhs, Arc rhs) =>

lhs.Equals(rhs);

public static bool operator !=(Arc lhs, Arc rhs) =>

!lhs.Equals(rhs);

}

Do Not Declare Fields That Are Public or Protected

In this declaration, Arc is a value type (defined using the keyword struct) with three public fields that define the characteristics of the Arc. Yes, I could’ve used properties, but I chose to use public fields in this example specifically because it violates the first guideline—Do Not declare fields that are public or protected.

By leveraging public fields rather than properties, the Arc definition lacks the most basic of object-oriented design principles—encapsulation. For example, what if I decided to change the internal data structure to use the radius, start angle and arc length, for example, rather than the sweep angle? Doing so would obviously break the interface for Arc and all clients would be forced to make a code change.

Similarly, with the definitions of Radius, StartAngle and SweepAngle, I have no validation. Radius, for example, could be assigned a negative value. And while negative values for StartAngle and SweepAngle might be allowable, a value greater than 360 degrees wouldn’t. Unfortunately, because Arc is defined using public fields, there’s no way to add validation to protect against these values. Yes, I could add validation in version 2 by changing the fields to properties, but doing so would break the version compatibility of the Arc structure. Any existing compiled code that invoked the fields would break at runtime, as would any code (even if recompiled) that passes the field as a by ref parameter.

Given the guideline that fields should not be public or protected, it’s worth noting that properties, especially with default values, became easier to define than explicit fields encapsulated by properties, thanks to support in C# 6.0 for property initializers. For example, this code:

public double SweepAngle { get; set; } = 180;

is simpler than this:

private double _SweepAngle = 180;

public double SweepAngle {

get { return _SweepAngle; }

set { _SweepAngle = value; }

}

The property initializer support is important because, without it, an automatically implemented property that needs initialization would need an accompanying constructor. As a result, the guideline: “Consider automatically implemented properties over fields” (even private fields) makes sense, both because the code is more concise and because you can no longer modify fields from outside their containing property. All this favors yet another guideline, “Avoid accessing fields from outside their containing properties,” which emphasizes the earlier-described data encapsulation principle even from other class members.

At this point lets return to the C# 7.0 tuple type ValueTuple<…>. Despite the guideline about exposed fields, ValueTuple<T1, T2>, for example, is defined as follows:

public struct ValueTuple<T1, T2>

: IComparable<ValueTuple<T1, T2>>, ...

{

public T1 Item1;

public T2 Item2;

// ...

}

What makes ValueTuple<…> special? Unlike most data structures, the C# 7.0 tuple, henceforth referred to as tuple, was not about the whole object (such as a Person or CardDeck object). Rather, it was about the individual parts grouped arbitrarily for transportation purposes, so they could be returned from a method without the bother of using out or ref parameters. Mads Torgersen uses the analogy of a bunch of people who happen to be on the same bus—where the bus is like a tuple and the people are like the items in the tuple. The Items are grouped together in a return tuple parameter because they are all destined to return to the caller, not because they necessarily have any other association to each other. In fact, it’s likely that the caller will then retrieve the values from the tuple and work with them individually rather than as a unit.

The importance of the individual items rather than the whole makes the concept of encapsulation less compelling. Given that items in a tuple can be wholly unrelated to each other, there’s often no need to encapsulate them in such a manner that changing Item1, for example, might affect Item2. (By contrast, changing the Arc length would require a change in one or both of the angles so encapsulation is a must.) Furthermore, there are no invalid values for the items stored within a tuple. Any validation would be enforced in the data type of the item itself, not in the assignment of one of the Item properties on the tuple.

For this reason, properties on the tuple don’t provide any value, and there’s no conceivable future value they could provide. In short, if you’re going to define a type whose data is mutable with no need for validation, you may as well use fields. Another reason you might want to leverage properties is to have varying accessibility between the getter and the setter. However, assuming mutability is acceptable, you aren’t going to take advantage of properties with differing getter/setter accessibility, either. This all raises another question—should the tuple type be mutable?

Do Not Define Mutable Value Types

The next guideline to consider is that of the mutable value type. Once again, the Arc example (shown in the code in Figure 2) violates the guideline. It’s obvious if you think about it—a value type passes a copy, so changing the copy will not be observable from the caller. However, while the code in Figure 2demonstrates the concept of only modifying the copy, the readability of the code does not. From a readability perspective, it would seem the arc changes.

Figure 2 Value Types Are Copied So The Caller Doesn’t Observe the Change

[TestMethod]

public void PassByValue_Modify_ChangeIsLost()

{

void Modify(Arc paramameter) { paramameter.Radius++; }

Arc arc = new Arc(42, 0, 90);

Modify(arc);

Assert.AreEqual<double>(42, arc.Radius);

}

What’s confusing is that in order for a developer to expect value copy behavior, they would have to know that Arc was a value type. However, there’s nothing obvious from the source code that indicates the value type behavior (though to be fair, the Visual Studio IDE will show a value type as a struct if you hover over the data type). You could perhaps argue that C# programmers should know value type versus reference type semantics, such that the behavior in Figure 2 is expected. However, consider the scenario in Figure 3when the copy behavior is not so obvious.

Figure 3 Mutable Value Types Behave Unexpectedly

public class PieShape

{

public Point Center { get; }

public Arc Arc { get; }

public PieShape(Arc arc, Point center = default)

{

Arc = arc;

Center = center;

}

public class PieShapeTests

{

[TestMethod]

public void Rotate_GivenArcOnPie_Fails()

{

PieShape pie = new PieShape(new Arc(42, 0, 90));

Assert.AreEqual<double>(90, pie.Arc.SweepAngle);

pie.Arc.Rotate(42);

Assert.AreEqual<double>(90, pie.Arc.SweepAngle);

}

Notice that, in spite of invocation Arc’s Rotate function, the Arc, in fact, never rotates. Why? This confusing behavior is due to the combination of two factors. First, Arc is a value type that causes it to be passed by value rather than by reference. As a result, invoking pie.Arc returns a copy of Arc, rather than returning the same instance of Arc that was instantiated in the constructor. This wouldn’t be a problem, if it wasn’t for the second factor. The invocation of Rotate is intended to modify the instance of Arc stored within pie, but in actuality, it modifies the copy returned from the Arc property. And that’s why we have the guideline, “Do Not define mutable value types.”

As before, tuples in C# 7.0 ignore this guideline and exposes public fields that, by definition, make ValueTuple<…> mutable. Despite this violation, ValueTuple<…> doesn’t suffer the same drawbacks as Arc. The reason is that the only way to modify the tuple is via the Item field. However, the C# compiler doesn’t allow the modification of a field (or property) returned from a containing type (whether the containing type is a reference type, value type or even an array or other type of collection). For example, the following code will not compile:

pie.Arc.Radius = 0;

Nor will this code:

pie.Arc.Radius++;

These statements fail with the message, “Error CS1612: Cannot modify the return value of ‘PieShape.Arc’ because it is not a variable.” In other words, the guideline is not necessarily accurate. Rather than avoiding all mutable value types, the key is to avoid mutating functions (read/write properties are allowable). That wisdom, of course, assumes that the value semantics shown in Figure 2 are obvious enough such that the intrinsic value type behavior is expected.

Do Not Create Value Types Larger Than 16 Bytes

This guideline is needed because of how often the value type is copied. In fact, with the exception of a ref or out parameter, value types are copied virtually every time they’re accessed. This is true whether assigning one value type instance to another (such as Arc = arc in Figure 3) or a method invocation (such as Modify(arc) shown in Figure 2). For performance reasons, the guideline is to keep value type size small.

The reality is that the size of a ValueTuple<…> can often be larger than 128 bits (16 bytes) because a ValueTuple<…> may contain seven individual items (and even more if you specify another tuple for the eighth type parameter). Why, then, is the C# 7.0 tuple defined as a value type?

As mentioned earlier, the tuple was introduced as a language feature to enable multiple return values without the complex syntax required by out or ref parameters. The general pattern, then, was to construct and return a tuple and then deconstruct it back at the caller. In fact, passing a tuple down the stack via a return parameter is similar to passing a group of arguments up the stack for a method call. In other words, return tuples are symmetric with individual parameter lists as far as memory copies are concerned.

If you declared the tuple as a reference type, then it would be necessary to construct the type on the heap and initialize it with the Item values—potentially copying either a value or reference to the heap. Either way, a memory copy operation is required, similar to that of a value type’s memory copy. Furthermore, at some later point in time when the reference tuple is no longer accessible, the garbage collector will need to recover the memory. In other words, a reference tuple still involves memory copying, as well as additional pressure on the garbage collector, making a value type tuple the more efficient option. (In the rare cases that a value tuple isn’t more efficient, you could still resort to the reference type version, Tuple<…>.)

While completely orthogonal to the main topic of the article, notice the implementation of Equals and GetHashCode in Figure 1. You can see how tuples provide a shortcut for implementing Equals and GetHashCode. For more information, see “Using Tuples to Override Equality and GetHashCode.”

Wrapping Up

At first glance it can seem surprising for tuples to be defined as immutable value types. After all, the number of immutable value types found in .NET Core and the .NET Framework is minimal, and there are long-standing programming guidelines that call for value types to be immutable and encapsulated with properties. There’s also the influence of the immutable-by-default approach characteristic to F#, which pressured C# language designers to provide a shorthand to either declare immutable variables or define immutable types. (While no such shorthand is currently under consideration for C# 8.0, read-only structs were added to C#7.2 as a means to verify that a struct was immutable.)

However, when you delve into the details, you see a number of important factors. These include:

• Reference types impose an additional performance impact with garbage collection.

• Tuples are generally ephemeral.

• Tuple items have no foreseeable need for encapsulation with properties.

• Even tuples that are large (by value type guidelines) don’t have significant memory copy operations beyond that of a reference tuple implementation.

In summary, there are plenty of factors that favor a value type tuple with public fields in spite of the standard guidelines. In the end, guidelines are just that, guidelines. Don’t ignore them, but given sufficient—and I would suggest, explicitly documented—cause, it’s OK to color outside the lines on occasion.

For more information on the guidelines for both defining value types and overriding Equals and GetHashCode, check out chapters 9 and 10 in my Essential C# book: “Essential C# 7.0” (IntelliTect.com/EssentialCSharp), which is expected to be out in May.

Lifecycle of an ASP.NET MVC 5 Application

noreply@blogger.com (Unknown) — Tue, 04 Mar 2014 06:40:00 +0000

Here you can download a PDF Document that charts the lifecycle of every ASP.NET MVC 5 application, from receiving the HTTP request to sending the HTTP response back to the client. It is designed both as an educational tool for those who are new to ASP.NET MVC and also as a reference for those who need to drill into specific aspects of the application. The PDF document has the following features:

Relevant HttpApplication stages to help you understand where MVC integrates into the ASP.NET application lifecycle.
A high-level view of the MVC application lifecycle, where you can understand the major stages that every MVC application passes through in the request processing pipeline.
A detail view that shows drills down into the details of the request processing pipeline. You can compare the high-level view and the detail view to see how the lifecycles details are collected into the various stages.
Placement and purpose of all overridable methods on the Controller object in the request processing pipeline. You may or may not have the need to override any one method, but it is important for you to understand their role in the application lifecycle so that you can write code at the appropriate life cycle stage for the effect you intend.
Blown-up diagrams showing how each of the filter types (authentication, authorization, action, and result) is invoked.
Link to a useful article or blog from each point of interest in the detail view.

Reading Excel using OpenXML

noreply@blogger.com (Unknown) — Wed, 08 May 2013 13:31:00 +0000

public DataTable ReadDataFromExcel()
       {
        string filePath = @"c:/temp/temp.xlsx";
           using (SpreadsheetDocument LobjDocument = SpreadsheetDocument.Open(filePath, false))
           {

               WorkbookPart LobjWorkbookPart = LobjDocument.WorkbookPart;
               Sheet LobjSheetToImport = LobjWorkbookPart.Workbook.Descendants<Sheet>().First<Sheet>();
               WorksheetPart LobjWorksheetPart = (WorksheetPart)(LobjWorkbookPart.GetPartById(LobjSheetToImport.Id));
               SheetData LobjSheetData = LobjWorksheetPart.Worksheet.Elements<SheetData>().First();

//Read only the data rows and skip all the header rows.
int LiRowIterator = 1;

               // for progress bar
               int LiTotal = LobjSheetData.Elements<Row>().Count() - MobjImportMapper.HeaderRowIndex;
               // =================

foreach (Row LobjRowItem in LobjSheetData.Elements<Row>().Skip(6))
{

                   DataRow LdrDataRow = LdtExcelData.NewRow();
                   int LiColumnIndex = 0;
                   int LiHasData = 0;
                   LdrDataRow[LiColumnIndex] = LobjRowItem.RowIndex; //LiRowIterator;
                   LiColumnIndex++;

                   //TODO: handle restriction of column range.
                   foreach (Cell LobjCellItem in LobjRowItem.Elements<Cell>().Where(PobjCell
                       => ImportHelper.GetColumnIndexFromExcelColumnName(ImportHelper.GetColumnName(PobjCell.CellReference))
                       <= MobjImportMapper.LastColumnIndex))
                   {

                       // Gets the column index of the cell with data
                       int LiCellColumnIndex = 10;
                       if (LiColumnIndex < LiCellColumnIndex)
                       {
                           do
                           {
                               LdrDataRow[LiColumnIndex] = string.Empty;
                               LiColumnIndex++;
                           }
                           while (LiColumnIndex < LiCellColumnIndex);
                       }

string LstrCellValue = LobjCellItem.InnerText;

                       if (LobjCellItem.DataType != null)
                       {
                           switch (LobjCellItem.DataType.Value)
                           {
                               case CellValues.SharedString:
                                   var LobjStringTable = LobjWorkbookPart.GetPartsOfType<SharedStringTablePart>().FirstOrDefault();
                                   DocumentFormat.OpenXml.OpenXmlElement LXMLElment = null;
                                   string LstrXMLString = String.Empty;
                                   if (LobjStringTable != null)
                                   {
                                       LstrXMLString =
                                           LobjStringTable.SharedStringTable.ElementAt(int.Parse(LstrCellValue, CultureInfo.InvariantCulture)).InnerXml;

                                       if (LstrXMLString.IndexOf("<x:rPh", StringComparison.CurrentCulture) != -1)
                                       {
                                           LXMLElment = LobjStringTable.SharedStringTable.ElementAt(int.Parse(LstrCellValue, CultureInfo.InvariantCulture)).FirstChild;
                                           LstrCellValue = LXMLElment.InnerText;
                                       }
                                       else
                                       {
                                           LstrCellValue = LobjStringTable.SharedStringTable.ElementAt(int.Parse(LstrCellValue, CultureInfo.InvariantCulture)).InnerText;

                                       }
                                   }
                                   break;
                               default:
                                   break;
                           }
                       }
                       LdrDataRow[LiColumnIndex] = LstrCellValue.Trim();
                       if (!string.IsNullOrEmpty(LstrCellValue))
                           LiHasData++;
                      LiColumnIndex++;
                   }

                   if (LiHasData > 0)
                   {
                       LiRowIterator++;
                       LdtExcelData.Rows.Add(LdrDataRow);
                   }
               }
           }

return LdtExcelData;
}

Reading XML Content

noreply@blogger.com (Unknown) — Wed, 08 May 2013 12:57:00 +0000

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using System.Diagnostics;
using System.Threading;
using System.Xml;
using System.Reflection;

namespace XMLReading

{

class Program
{
static void Main(string[] args)
{

string fileName = @"C:\temp\t.xml";
List<EmergencyContactXMLDTO> emergencyContacts = new XmlReader<EmergencyContactXMLDTO, EmergencyContactXMLDTOMapper>().Read(fileName);

foreach (var item in emergencyContacts)
            {
Console.WriteLine(item.FileNb);
            }
         }
    }

public class XmlReader<TDTO, TMAPPER> where TDTO : BaseDTO, new() where TMAPPER : PCPWXMLDTOMapper, new()
    {
public List<TDTO> Read(String fileName)
        {
XmlTextReader reader = new XmlTextReader(fileName);
List<TDTO> emergencyContacts = new List<TDTO>();
while (true)
            {
                TMAPPER mapper = new TMAPPER();
bool isFound = SeekElement(reader, mapper.GetMainXMLTagName());
if (!isFound) break;
                TDTO dto = new TDTO();
foreach (var propertyKey in mapper.GetPropertyXMLMap())
                {
String dtoPropertyName = propertyKey.Key;
String xmlPropertyName = propertyKey.Value;
                    SeekElement(reader, xmlPropertyName);
                    SetValue(dto, dtoPropertyName, reader.ReadElementString());
                }
                emergencyContacts.Add(dto);
            }
return emergencyContacts;
        }

private void SetValue(Object dto, String propertyName, String value)
        {
PropertyInfo prop = dto.GetType().GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
            prop.SetValue(dto, value, null);
        }

private bool SeekElement(XmlTextReader reader, String elementName)
        {
while (reader.Read())
            {
XmlNodeType nodeType = reader.MoveToContent();
if (nodeType != XmlNodeType.Element)
                {
continue;
                }

if (reader.Name == elementName)
                {
return true;
                }
            }
return false;
        }
    }

public class BaseDTO

{

}

public class EmergencyContactXMLDTO : BaseDTO
{

public string FileNb { get; set; }

public string ContactName { get; set; }

public string ContactPhoneNumber { get; set; }

public string Relationship { get; set; }

public string DoctorName { get; set; }

public string DoctorPhoneNumber { get; set; }

public string HospitalName { get; set; }

}

public interface PCPWXMLDTOMapper
{
Dictionary<string, string> GetPropertyXMLMap();
String GetMainXMLTagName();
}

public class EmergencyContactXMLDTOMapper : PCPWXMLDTOMapper
    {
public Dictionary<string, string> GetPropertyXMLMap()
        {
return new Dictionary<string, string>
            {
                { "FileNb", "XFileNb" },
                { "ContactName", "XContactName"},
                { "ContactPhoneNumber", "XContactPhoneNumber" },
                { "Relationship", "XRelationship" },
                { "DoctorName", "XDoctorName" },
                { "DoctorPhoneNumber", "XDoctorPhoneNumber" },
                { "HospitalName", "XHospitalName" },
            };
        }

public String GetMainXMLTagName()
        {
return "EmergencyContact";
        }
    }
}

Reading Excel using ClosedXML

noreply@blogger.com (Unknown) — Wed, 08 May 2013 12:53:00 +0000

I have used closedXML api to read the excel. Here is how you do it. Statistically, this performs better than OpenXML.

public DataTable ReadDataFromExcelUsingClosedXML()
{
string filePath ="@c:/temp/example.xlsx";

var LobjWorkbook = new XLWorkbook(filePath);
var LobjWorksheet = LobjWorkbook.Worksheets.First();

            var LobjFullRange = LobjWorksheet.RangeUsed();
            var LobjUsedRange = LobjWorksheet.Range(MobjImportMapper.HeaderRowIndex + 1, 1, LobjFullRange.RangeAddress.LastAddress.RowNumber,
                                                    LobjFullRange.RangeAddress.LastAddress.ColumnNumber);

var LiNumberOfcolumnsInTheExcel = LobjUsedRange.ColumnCount();

            // for progress bar
            int LiAggregateRowCounter = MobjImportMapper.HeaderRowIndex;
            int LiTotalNumberOfRows = LobjWorksheet.RowCount() - LiAggregateRowCounter;
            int LiPercentage = 0;

            foreach (var LobjRow in LobjUsedRange.RowsUsed())
            {
                int LiTemp = 0;
                object[] LobjrowData = new object[LiNumberOfcolumnsInTheExcel + 1];
                LobjrowData[LiTemp] = LobjRow.RangeAddress.FirstAddress.RowNumber;
                LiTemp++;

LobjRow.Cells().ForEach(PobjCell => LobjrowData[LiTemp++] = PobjCell.Value);
LdtExcelData.Rows.Add(LobjrowData);

                // for progress bar
                LiPercentage = ((100 * LiAggregateRowCounter / LiTotalNumberOfRows) / 4) * 3;
                if (LiPercentage > 5)
                    PobjBackgoundWorker.ReportProgress(LiPercentage);
                LiAggregateRowCounter++;
                // =====================
            }

return LdtExcelData;
}

In JavaScript, curly brace placement matters: An example by David

noreply@blogger.com (Unknown) — Mon, 24 Oct 2011 20:26:00 +0000

I used to follow Kernighan and Ritchie style of code formatting, but lost that habit. Not sure how may hours spent on fixing JS issues due to Allman format. Every time I feel bad whilst Visual Studio gives K&R style. Just realized the impotence of K&R style for JS. My Big thanks to David for pointing the curly brace placement issue with JS and posting such a nice article. In JavaScript, curly brace placement matters: An example

ASP.NET Event Handling using ASPX and Code behind

noreply@blogger.com (Unknown) — Sat, 08 Oct 2011 11:05:00 +0000

This video shows how to register UI events in ASP.NET. Registration can be done in two ways first one is using APSX file and second one is using Code behind. This Video explains both the approaches, also explains you how easily events can be created in Visual Studio.

State Design Pattern .NET Code Sample

noreply@blogger.com (Unknown) — Sun, 25 Sep 2011 20:03:00 +0000

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        Person p1 = new Person("P1");
        Person p2 = new Person("P2");
        p1.EatFood();
        p2.EatFood();
        p1.Vomit();
        p2.Vomit();
    }
}


interface StomachState
{
    void Eat(Person p);
    void Vomit(Person p);
}

class StomachFull : StomachState
{
    public void Eat(Person p)
    {
        Console.WriteLine("Can't eat more.");
    }

    public void Vomit(Person p)
    {
        Console.WriteLine("I've just Vomited.");
        p.StomachState = new StomachEmpty();
    }
}

class StomachEmpty : StomachState
{
    public void Eat(Person p)
    {
        Console.WriteLine("I've just had food.");
        p.StomachState = new StomachFull();
    }

    public void Vomit(Person p)
    {
        Console.WriteLine("Nothing to Vomit.");
    }
}

class Person
{
    private StomachState stomachState;
    private String personName;
    public Person(String personName)
    {
        this.personName = personName;
        StomachState = new StomachEmpty();
    }

    public StomachState StomachState 
    { 
        get 
        {
            return stomachState;
        } 
        set 
        {
            stomachState = value;
            Console.WriteLine(personName + " Stomach State Changed to " + StomachState.GetType().Name);
            Console.WriteLine("***********************************************\n");
        } 
    }

    public Person(StomachState StomachState)
    {
        this.StomachState = StomachState;
    }

    public void EatFood()
    {
        StomachState.Eat(this);
    }

    public void Vomit()
    {
        StomachState.Vomit(this);
    }
}

Export from asp.net page to Excel, word & pdf

noreply@blogger.com (Unknown) — Mon, 23 May 2011 11:32:00 +0000

Here is an excellent articles that talks about exporting data from asp.net page to Excel, word and pdf

http://www.codeproject.com/KB/TipsnTricks/AllInOneExportData.aspx

DataTable to Generic List Conversion

noreply@blogger.com (Unknown) — Sun, 01 May 2011 19:21:00 +0000

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

namespace ConsoleApplication1
{
    class Program
    {

        static void Main(string[] args)
        {
            DataTable table = new DataTable
            {
                Columns = {
                            {"Number", typeof(int)},
                            {"Name", typeof(string)}
                         }
            };

            //Just adding few test rows to datatable.
            for (int i = 1; i <= 5; i++)
            {
                table.Rows.Add(i, "Name" + i);
            }

            var returnList = from row in table.AsEnumerable()
                              select new MyObject
                              {
                                  Number = row.Field<int>("Number"),
                                  Name = row.Field<String>("Name")
                              };

            //Displaying converted collection
            foreach (MyObject item in returnList)
            {
                Console.WriteLine("{0}\t{1}", item.Number, item.Name);
            }
        }
    }

    class MyObject
    {
        public int Number { get; set; }
        public String Name { get; set; }
    }
}

Microsoft offers Professional Tools for small companies with support at no cost

noreply@blogger.com (Unknown) — Fri, 11 Feb 2011 09:50:00 +0000

How to Hibernate from .NET Apps and How to enable Hibernate in Windows XP

noreply@blogger.com (Unknown) — Thu, 10 Feb 2011 22:16:00 +0000

The usage of Computer desktop or laptop is increased all around the world phenomenally. This link gives you the picture on how power consumption is for various devices we use daily. to reduce the power consumption Hibernate is one of the best way provided by default in Windows Vista or Windows 7. Hibernate feature enables you to close the machine without closing your applications, that means the applications will be restored as they were once we restart the machine. Hibernate feature is not enabled in Windows XP by default. I’ve seen many people that they run (do not switch off) the machines months and months as they do not want to close the windows or applications running in Windows XP. below are the steps to enable Hibernate in Windows XP.

Right click on Desktop.
Click on properties.
Go to screen save tab.
Click on power button
Select Hibernate tab
Check the checkbox “Enabled Hibernate”
Apply the settings.

Now when you try to shutdown, “Shut down windows” dialog shows “Hibernate” options. Now you can safely close the machine without closing your applications or windows as they will be restored once you on the machine.

</SPAN?

Some time you might want to provide this future programmatically for the applications you develop for windows. Generally you might want to provide this option in windows applications where process needs huge time. Download managers are the one of the best example. below is the code to do a Hibernate from the .NET code.

using System.Windows.Forms;

namespace CodeKicks.WinApp.Machine
{
    public static class MyMachineHelper
    {
        public static void DoHibernate()
        {
            //Application.SetSuspendState(PowerState.Suspend, true, false);
            Application.SetSuspendState(PowerState.Hibernate, true, false);
        }
    }
}

Configure SQL Express 2005 for remote access

noreply@blogger.com (Unknown) — Fri, 28 Jan 2011 09:46:00 +0000

Please follow the below steps as shown in pictures to configure SQL Server Express 2005 for remote access.

Fig1: Open SQL Serve Configuration Manager

Fig2: Navigate to SQL Serve 2005 N/W configuration and click on Protocols node

Fig3: Enable TCP/IP Protocol

Fig4: Enable Named Pipes Protocol

Fig5: After enabling TCP/IP and Named Pipes protocols

Fig6: Finally click on TCP/IP to configure the port number to listen N/W requests to SQL Express 2005.

Visual Studio 2010 Installation Screenshots, links to installation Guides, Forum

noreply@blogger.com (Unknown) — Thu, 27 Jan 2011 21:15:00 +0000

Today Installed Visual Studio 2010 in my new Sony Vaio laptop. I’ve habit of taking screen shots while setups are running. It helps me if I want to find the items what I installed earlier for that software. but taking screen shots is not required for the software's like Visual Studio as it provides add/remove items at anytime. Below are the screen shorts for the members are you new to Visual Studio installation, it’s pretty much easy and self understandable if you follow the instructions mentioned in installation wizard. I thought it does several system restarts as earlier versions, but VS2010 did not restart the machine. Just it said successfully installed. You might want to refer this link for further assistance. You can also ask your queries in this forum. You can also find installation guide. Happy coding with Visual Studio 2010 :-)

You might also want to other articles
27 New Features of .NET Framework 4.0
New features of IIS 7.0
22 New Features of Visual Studio 2008 for .NET Professionals

An observation on .NET loops – foreach, for, while, do-while

noreply@blogger.com (Unknown) — Mon, 24 Jan 2011 11:49:00 +0000

It’s very common that .NET programmers use “foreach” loop for iterating through collections. Following is my observation whilst I was testing simple scenario on loops. “for” loop is 30% faster than “foreach” and “while” loop is 50% faster than “foreach”. “do-while” is bit faster than “while”. Someone may feel that how does it make difference if I’m iterating only 1000 times in a loop.

This test case is only for simple iteration. According to the "Data structure" concepts, best and worst cases are completely based on the data we provide to the algorithm. so we can not conclude that a "foreach" algorithm is not good. All I want to tell that we need to be little cautious even choosing the loops.

Example:- You might want to chose quick sort when you want to sort more numbers. At the same time bubble sort may be effective than quick sort when you want to sort less numbers.

Take a simple scenario, a request of a simple web application fetches the data of 10000 (10K) rows and iterating them for some business logic. Think, this application is being accessed by 1000 (1K) people simultaneously. In this simple scenario you are ending up with 10000000 (10Million or 1 Crore) iterations.

below is the test scenario with simple console application to test 100 Million records.

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var sw = new Stopwatch();
            var numbers = GetSomeNumbers();

            sw.Start();
            foreach (var item in numbers)
            {

            }
            sw.Stop();

            Console.WriteLine(
            String.Format("\"foreach\" took {0} milliseconds",
            sw.ElapsedMilliseconds));

            sw.Reset();
            sw.Start();
            for (int i = 0; i < numbers.Count; i++)
            {

            }
            sw.Stop();

            Console.WriteLine(
            String.Format("\"for\" loop took {0} milliseconds",
            sw.ElapsedMilliseconds));

            sw.Reset();
            sw.Start();
            var it = 0;
            while (it++ < numbers.Count)
            {

            }
            sw.Stop();

            Console.WriteLine(
            String.Format("\"while\" loop took {0} milliseconds",
            sw.ElapsedMilliseconds));

            sw.Reset();
            sw.Start();
            var it2 = 0;
            do
            {

            } while (it2++ < numbers.Count);

            sw.Stop();

            Console.WriteLine(
            String.Format("\"do-while\" loop took {0} milliseconds",
            sw.ElapsedMilliseconds));
        }

        #region Get me 10Crore (100 Million) numbers
        private static List<int> GetSomeNumbers()
        {
            var lstNumbers = new List<int>();
            var count = 100000000;
            for (var i = 1; i <= count; i++)
            {
                lstNumbers.Add(i);
            }
            return lstNumbers;
        }
        #endregion Get me some numbers
    }
}

In above example, I was just iterating through 100 Million numbers. You can see the time to execute various loops provided in .NET

Output
"foreach" took 1108 milliseconds

"for" loop took 727 milliseconds

"while" loop took 596 milliseconds

"do-while" loop took 594 milliseconds

Press any key to continue . . .

So I feel we need to be careful while choosing the looping strategy. Please comment your thoughts.

Control HelpButton, HelpRequested, HelpButtonClicked - Instant help for windows Dialog Form components

noreply@blogger.com (Unknown) — Fri, 21 Jan 2011 10:34:00 +0000

Instant help for windows dialog components is a great feature and very much known since windows 98. but I saw many many people are not aware it and query on Google to get help, but “help button” for dialogs helps you or your customers to get the help instantly. Every dialog window has help icon if that dialog was coded to enable it. it really helps to know the functionality of the components quickly. For example I was trying to pint a document from acrobat reader and opened printer properties to print the content front and back of the paper.

If you observe there is a help button before close button. To get help on options of “Print on Both Sides” you would need to click on help button first and then click on the area on which you want to see the help. above picture shows help text for the options of “Print on Both Sides”. If you would like to get the help using keyboard you can use F1 key.

Help button can be displayed only if minimize button and maximize button both are not shown unless you want go with custom buttons. below is the way if you want to get Help button for windows forms.

In this sample demo I want to have a checkbox and need to show help when I click on F1 on check box. So I created a form which country check box and help label as show in adjacent picture.

Below is the code for your code bind file.

using System;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial classForm1: Form
   {
        publicForm1()
        {
            InitializeComponent();
        }

        private void Form1_Load(objectsender, EventArgs e)
        {
            this.Text = "Help Button Demo Form";
            lblHelp.Text = "Press F1 on any component to get Instant Help";

            this.HelpButton = true;
            this.MaximizeBox = false;
            this.MinimizeBox = false;

            chkCountry.Tag = "Check or Uncheck Coutry Check Box";
            chkCountry.HelpRequested += newHelpEventHandler(chkCountry_HelpRequested);
            chkCountry.MouseLeave += newEventHandler(chkCountry_MouseLeave);
        }

        void chkCountry_HelpRequested(objectsender, HelpEventArgs hlpevent)
        {
            ControlrequestingControl = (Control)sender;
            lblHelp.Text = (string)requestingControl.Tag;
            hlpevent.Handled = true;
        }

        void chkCountry_MouseLeave(objectsender, EventArgs e)
        {
            lblHelp.Text = "Press F1 on any component to get Instant Help";
        }
    }
}

In above code “HelpRequested” is an event will be fired when you click on F1 on Country checkbox. I stored the help information in the checkbox property called “Tag”. You might also maintain a property file to keep help text for each component differently. If you click on F1 when focus is on main form instead on individual component then generally separate help window opens. This can be done using the event “Form.HelpRequested” to open help windows as in below code.

this.HelpRequested += newHelpEventHandler(Form1_HelpRequested);

voidForm1_HelpRequested(objectsender, HelpEventArgs hlpevent)
{
frmHelp.Show();
}

NetAdvantage - jQuery, ASP .NET MVC and HTML5 UI Components released for Web Developers

noreply@blogger.com (Unknown) — Thu, 20 Jan 2011 09:32:00 +0000

Built for speed and portability across operating systems, iPad/tablets, desktops and multi-browser support. Includes controls for ASP .NET MVC and uses the latest technologies like HTML 5 & CSS 3. This preview includes a sampling of powerful UI controls: grid, date picker, rating, editors, even a video player! All work with the popular WebKit engine that underpins many modern desktop browsers without requiring plug-ins or extensions. The grid embraces the latest Web techniques and frameworks like jQuery Client Templates and DOM virtualization. Download these essentials for jQuery and ASP .NET MVC from us today.

NHibernate 3 Webcast - Open to Public – Thursday from Pluralsight

noreply@blogger.com (Unknown) — Wed, 19 Jan 2011 12:04:00 +0000

This week for the very first time, we're giving all newsletter subscribers FREE access to our exclusive weekly webcast! Join us Thursday for a 45 minute presentation on NHibernate 3 presented by James Kovacs. James is an independent architect, developer, trainer and jack-of-all-trades. He also happens to be the instructor for our upcoming NHibernate virtual classroom course next week.
LiveMeeting Login Add to outlook calendar

Thursday 20 Jan 2011 - 09:30PM IST, 11:00 AM EST , 16:00 UTC

Getting started with Blocks and namespaces - Enterprise Library 5.0 Tutorial Part 2

noreply@blogger.com (Unknown) — Tue, 18 Jan 2011 02:03:00 +0000

This is my second post in this series. In first blog post I explained how to install Enterprise Library 5.0 and provided links to various resources. Enterprise Library is divided into various blocks. Simply we can say, a block is a ready made solution for a particular common problem across various applications. So instead focusing on implementation of common problem across various applications, we can reuse these fully tested and extendable blocks to increase the productivity and also extendibility as these blocks are made with good design principles and patterns. Major blocks of Enterprise Library 5.0 are as follows.

Core infrastructure
Functional Application Blocks
- Caching
- Data
- Exception Handling
- Logging
- Security
- Cryptography
- Validation
Wiring Application Blocks

Unity
Policy Injection/Interception

Each block resides in its own assembly, and also some extra assemblies for common infrastructure. Assemblies are as follows.

Microsoft.Practices.EnterpriseLibrary.Caching.Cryptography.dll
Microsoft.Practices.EnterpriseLibrary.Caching.Database.dll
Microsoft.Practices.EnterpriseLibrary.Caching.dll
Microsoft.Practices.EnterpriseLibrary.Common.dll
Microsoft.Practices.EnterpriseLibrary.Configuration.Design.HostAdapter.dll
Microsoft.Practices.EnterpriseLibrary.Configuration.Design.HostAdapterV5.dll
Microsoft.Practices.EnterpriseLibrary.Configuration.DesignTime.dll
Microsoft.Practices.EnterpriseLibrary.Configuration.EnvironmentalOverrides.dll
Microsoft.Practices.EnterpriseLibrary.Data.dll
Microsoft.Practices.EnterpriseLibrary.Data.SqlCe.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.Logging.dll
Microsoft.Practices.EnterpriseLibrary.ExceptionHandling.WCF.dll
Microsoft.Practices.EnterpriseLibrary.Logging.Database.dll
Microsoft.Practices.EnterpriseLibrary.Logging.dll
Microsoft.Practices.EnterpriseLibrary.PolicyInjection.dll
Microsoft.Practices.EnterpriseLibrary.Security.Cache.CachingStore.dll
Microsoft.Practices.EnterpriseLibrary.Security.Cryptography.dll
Microsoft.Practices.EnterpriseLibrary.Security.dll
Microsoft.Practices.EnterpriseLibrary.Validation.dll
Microsoft.Practices.EnterpriseLibrary.Validation.Integration.AspNet.dll
Microsoft.Practices.EnterpriseLibrary.Validation.Integration.WCF.dll
Microsoft.Practices.EnterpriseLibrary.Validation.Integration.WinForms.dll
Microsoft.Practices.ServiceLocation.dll
Microsoft.Practices.Unity.Configuration.dll
Microsoft.Practices.Unity.dll
Microsoft.Practices.Unity.Interception.dll

Enterprise Library Configuration Tool

In addition to these assemblies you would get configuration tool “EntLibConfig-32.exe”. If you are targeting your application to .NET 4.0 framework then you would need to use “EntLibConfig.NET4.exe”. Optionally you can install Visual Studio 2008 and Visual Studio 2010 add-ins whilst installing of Enterprise Library. So that you can invoke the enterprise Library configuration from Visual Studio by right clicking on “app.config” or “web.config” file as shown below.

I would suggest you to download the documentation from Codeplex which was released on May 2010. It consists 3MB of information.

you can also find issue tracker to know various issues/bugs currently people talking about enterprise library. There is also discussion link takes you to community site where you can post your questions.

In my next blog post, I would cover more on each block.

Installing Enterprise Library 5.0 - Enterprise Library 5.0 Tutorial Part 1

noreply@blogger.com (Unknown) — Sun, 16 Jan 2011 06:33:00 +0000

Microsoft has released Enterprise Library on April 2010. it’s free you can download and install from “Download Enterprise Library”. you can also find older version of enterprise library 4.1 still if your project needs it for maintenance purpose. but I suggest go for 5.0 as it has great enhancements and improved UI configuration tool.

Will it work only with Visual Studio 2008? Yes, it works with also .NET 3.5 and Visual Studio 2008. you can take advantage of new improved UI configuration tool which comes from enterprise library 5.0 with VS2008. I suggest you to install it including documentation. you can also find community links.

You’ll find 2 types of installers Whilst download. You might want to chose 2nd type with no source code option for production usage you .

1. “Enterprise Library 5.0 - Source Code.msi” which is of 5.3 MB size contains source code of enterprise library.

This installer is useful if you want to have a insight of the enterprise patterns source code. In this installation you would need to go through following steps.

Once you finish above wizard you can see that all the source code has been copied to the folder given in first step. Folders are as follows…

You can find the source code at the folder Blocks. If you want to build the assemblies yourself or dig into the code for advanced usage. but once you complete the wizard automatically installer initiate the MSBuild script file “BuildLibrary.bat” which compiles the source code and copies all the required dlls in bin folder. You can find the batch script execution screen below. This step completes the required installation with default configuration.

2. “Enterprise Library 5.0.msi” which is of 11 MB size. You can get following things with this installer.

1. Source Code
2. All compiled binaries/assemblies
3. Configuration Editor for Visual Studio.

Once you start the installer, You would need to read and agree the license terms as shown below.

In this following screen you can find that installer is going to install Configuration tool for Visual Studio 2008. if you have Visual Studio 2010 installed in your machine, then this wizard also installs the configuration tool for Visual Studio 2010.

In this link you can find all overview and system requirements to use these patterns. In my next blog posts I’ll provide more insight to various blocks of Enterprise Library 5.0.

VMMap - awesome memory analysis tool

noreply@blogger.com (Unknown) — Sun, 31 Oct 2010 14:02:00 +0000

VMMap is a process virtual and physical memory analysis utility. It shows a breakdown of a process's committed virtual memory types as well as the amount of physical memory (working set) assigned by the operating system to those types. Besides graphical representations of memory usage, VMMap also shows summary information and a detailed process memory map. Powerful filtering and refresh capabilities allow you to identify the sources of process memory usage and the memory cost of application features.

Besides flexible views for analyzing live processes, VMMap supports the export of data in multiple forms, including a native format that preserves all the information so that you can load back in. It also includes command-line options that enable scripting scenarios.

VMMap is the ideal tool for developers wanting to understand and optimize their application's memory resource usage.

How great leaders inspire action - Simon Sinek

noreply@blogger.com (Unknown) — Fri, 29 Oct 2010 17:27:00 +0000

Simon O. Sinek (born 1973) is a marketing consultant known for developing "The Golden Circle," a model based on human decision-making that guides organizations on how to inspire people to buy or support any product, company or idea.

Here is one of his speech

Own a KINECT for MS-XBOX before anyone does

noreply@blogger.com (Unknown) — Fri, 29 Oct 2010 17:09:00 +0000

Following is the announced by Richik Nandi from Microsoft team.
Dear Customer,
We believe that our privileged customers shouldn't have to wait for good things. So, here's a special offer exclusively for you. Be one of the first in India to own and experience Kinect for XBOX 360, few days before it is even launched in stores.

Introducing the new Kinect for XBOX 360®. Kinect needs no controllers. You are the controller.

Kinect brings games and entertainment to life in extraordinary new ways without using a controller. The sensor recognizes your face, eyes and body movements to deliver a superb gaming experience.

Easy to use and great fun, Kinect gets everyone off the couch. See a ball? Kick it. Want to join a friend in the fun? Simply jump in. Imagine controlling movies and music with the wave of a hand or the sound of your voice! Kinect is all about fun for you and your family. And the best part is Kinect works with every Xbox 360®.

There are two options you can choose from:

• Kinect sensor + 4GB Xbox 360 bundle + Kinect Adventures game at
Rs 22,990/-and get Dance Central game worth Rs 1999 from Redington, 20% discount voucher from Starwood on food and beverages, T-shirt from PUMA and a Kinect adventure live card absolutely free using your unique promo code : XbTXXZl2Sb

• Kinect Sensor at Rs 9,500/-and get 20% discount voucher from Starwood on food and beverages, T-shirt from PUMA and a Kinect adventure live card absolutely free using your unique promo code : lDg6o8SuYh

We want you to own your Kinect before the official launch. The promotion closes by 10th November.

To know more about Kinect click here. To book your Kinect

PRE-ORDER now!

Enter your details along with the above mentioned promo code to avail of the free gifts offer. We will have your Kinect delivered by 19th November 2010.
Enjoy being the controller. Enjoy the Kinect.

Now Shipping! NetAdvantage for .NET 2010 Volume 3!

noreply@blogger.com (Unknown) — Wed, 20 Oct 2010 02:53:00 +0000

The new NetAdvantage Ultimate includes all four Line of Business user interface control sets for ASP .NET, Windows Forms, WPF and Silverlight plus two advanced Data Visualization UI control sets for WPF and Silverlight. With six NetAdvantage products in one robust package, Infragistics® gives you hundreds of controls and infinite development possibilities.

Unified XAML Product Strategy-Share Code, Get More Controls In the 10.3 release, Infragistics continues to deliver code parity between the XAML platforms, WPF and Silverlight. In the line of business toolsets, Infragistics introduces the new xamSchedule™, full-featured, Outlook® 2010-style schedule controls, and the new xamDataTree™, a data bound tree view that comfortably handles tens of thousands of tree nodes. Mimicking our Silverlight Drag and Drop Framework, the WPF Drag and Drop Framework CTP empowers you to add your own rich touches to your applications.

Track Users' Behaviors New to all NetAdvantage Silverlight controls is the Infragistics Analytics Framework (IGAF), which empowers you to track user behavior in RIAs running on Silverlight 4. Building on the Microsoft® Silverlight Analytics Framework, with IGAF you can analyze the user's behaviors to ensure the experience you want to deliver.

NetAdvantage for Windows Forms--New Office® 2010 Ribbon and Application Menu 2010 Create new experiences with Windows Forms. Now with Office 2010 styling, NetAdvantage for Windows Forms has new features such as Microsoft® Office 2010 ribbon and enhanced Infragistics.Excel to export the contents of the high performance WinGrid™ into Microsoft Excel® 2010. The new Windows Message Support enables Infragistics standalone editor controls to process numerous Windows® OS messages, allowing them to respond just like native controls to changes in the Windows environment.

Create Faster Web 2.0 Experiences with NetAdvantage for ASP .NET Infragistics continues to push the envelope to deliver the fastest ASP .NET WebForms controls available on the market. Our lightning fast ASP .NET grids are now enhanced with XPS/PDF Exporting and Summary Rows. This release also includes support for jQuery Templating (as a CTP) within our WebDataGrid™ and WebDataTree™ controls allowing you to quickly cut down overall page size.

Deliver Business Intelligence with Power, Flexibility and the Office 2010 Experience NetAdvantage for WPF Data Visualization and NetAdvantage for Silverlight Data Visualization help you deliver flexible, powerful and usable end user experiences in Business Intelligence applications. Both suites include the Pivot Grid that delivers the full power of online analytical processing (OLAP) to present multi-dimensional data, sliced and diced in cross-tabulated form for end users to drill down into, interact with and easily extract meaning from the data.

Mapping Made Easy 10.3 marks the official release of the WPF Data Visualization xamMap™ control to map anything and everything from geographic to geo-spacial mapping data. Map layers allow you to add successive levels of detail, navigational panes for panning in all directions, color swatch panes that facilitate value scales like Choropleth shading, and scale panes allowing users to zoom-in and out. Both toolsets introduce the first of many relationship maps! With the xamOrgChart™ CTP you can map out organizational charts of up to 50K employees, competitive brackets (think World Cup) and any other relational, organizational map your application needs.

http://www.infragistics.com

Number of Weeks between 2 Dates in SQL Server and Oracle

noreply@blogger.com (Unknown) — Wed, 20 Oct 2010 02:45:00 +0000

This post gives you queries in Oracle and SQL Server to find number of weeks between 2 given dates Microsoft SQL Server Syntax:

SELECT DATEDIFF (ww, '01/01/1753', '12/31/9999');

Oracle Syntax:

SELECT floor(
             (to_date('12/31/9999','mm/dd/yyyy')
              - to_date('01/01/1753','mm/dd/yyyy')
             )
             / 7) diff
FROM DUAL;