.NET Lounge

Information Architecture and Faceted Navigation in SharePoint 2010

2011-12-02T09:17:00.008+05:30

SharePoint 2010 has new features included (such as Taxonomy, Document Sets) and search improvements (such as Refiners). This has brought in a whole lot of changes to the thought process related to information architecture.

In MOSS 2007, we dealt with a linear guided navigation. SPS2010 improvements and new features introduced faceted navigation. It is also referred as faceted search or (free form) guided navigation. The faceted search presents users with a list of relevant suggestions for refining the search results by document type, site, author, modified date, tags etc.

Information architecture is the key in designing the content management systems, knowledge management portals, e-Commerce sites and so on. Consider below points while deciding on Information architecture.

• Content Roll up: Using Content Query web part, relevant and related content can be made available on content pages, document set welcome pages etc. Content Query web part has few improvements related to managed metadata (taxonomy) columns. Read here what’s new in content query web part.
• Refiners: This is a key to faceted search. The refinement web part can be used to narrow the search results.
• Extensibility of Search Web part: SPS 2010 has search web parts which can be extended. In MOSS 2007, these web parts are sealed. Scenario based search functionality can be extended and used on various pages, document set pages.

I have listed here few of the points. There are many features in SPS 2010 which we can exploit for the better information architecture and good navigation providing better user experience.
Few links about faceted search and information architecture.
• Building Information Architecture in SPS 2010
• Faceted Navigation
• How Microsoft is leveraging the features in Infopedia and Microsoft Academy Mobile
• Case Study: Microsoft Infopedia

SharePoint: Site Columns and Content Types

2011-08-02T18:41:00.000+05:30

There are various posts on the internet describing the site columns and content types. In this post I am co-relating these with concepts of objects and classes. This will help the developer visualize these concepts differently.

Content and Object

Object has data. Class provides the set of attributes to detail the object instances.

Content is data. Content has two categories: Structured and Unstructured.

Content comprises of documents and list items. Content does not include list or library itself. List or library helps user to organize the content.

Structured content is the one which separates its storage from its display. e.g. List Items can be sorted/filtered and viewed in List web part or data row in a SQL data table.

Unstructured content is the one which cannot be viewed separately the format in which they are stored. e.g. Word document cannot be viewed without the MS Office Word.

Content type provides the set of attributes to define the metadata about content. The attributes are provided in the form of columns/fields in the list or at the site level.

Site Column

When the column is defined at site level, it is a site column. The site column is reusable across all lists and libraries in the site.

This is very similar to have property declared in an interface and will be available across all objects implementing the interface.

Content Type

Content type is a set of site columns. The site column helps in describing the content. The content type can be used across the lists and libraries in the site.

This is just like a complex data type. The data types/ classes has properties to describe the object.

Document Library Creation with Specific Document Template Using Server Object Model

2011-04-13T17:36:00.003+05:30

Introduction: There is no way in SharePoint UI to create a document library with blank Excel/PowerPoint document template. But it is possible to create a document library with such document templates programmatically.

Technicalities:
I will first take you through the classes involved in development.

SPListCollection

SPListTemplateType

SPListTemplate

SPDocTemplate

SPListCollection has Add method with 7 overloads. Look for the method signatures here.

We will concentrate on the following signature:

public virtual Guid Add(
 string title,  //Title for the library
 string description,//Description about the library
 SPListTemplate template,//The list template. We are interested in Document Library.
 SPDocTemplate documentTemplate //The document template for library.e.g. Excel, Word or Powerpoint etc.
)

SPListTemplateType is a enumeration. The enumeration has underlying integer values which match the Type attribute of ListTemplate element. Please visit here for details.

SPListTemplate represents the list definition or list template for the list. The list definition/template has the views and fields defined. SPWeb.ListTemplates returns the list definitions for the web site. SPSite.GetCustomListTemplates method returns the list template collection for the site collection. More details.

SPDocTemplate represents the document template. Whenever we create a document library, it is created by using blank Word Document template. There are many document templates available in SharePoint 2010 OOB. The document templates have IDs. The ID is used to filter the document template collection presented by SPWeb.DocTemplates property. Document Template IDs list follows:

Document Template ID	Description
101	A blank Microsoft Word 97-2003 document.
103	A blank Microsoft Excel 97-2003 document.
104	A blank Microsoft PowerPoint 97-2003 document.
105	A blank Microsoft basic page ASPX document.
106	A blank Microsoft Web Part Page ASPX document.
111	A basic Microsoft OneNote 2010 Notebook.
121	A blank Microsoft Word document.
122	A blank Microsoft Excel document.
123	A blank Microsoft PowerPoint document.

Code:

using (SPSite site = new SPSite(serverUrl)) {
   using (SPWeb web = site.OpenWeb()) {
       SPListTemplate lstTemplate = web.ListTemplates["Document Library"];
       SPDocTemplate docTemplate =(from SPDocTemplate dt in web.DocTemplates
                                   where dt.Type == 122
                                   select dt).FirstOrDefault();
       Guid newLibID = 
         web.Lists.Add("Expense Claims", "Excel Expenses", lstTemplate, docTemplate);
       SPDocumentLibrary newLib = web.Lists[newLibID] as SPDocumentLibrary;
       newLib.OnQuickLaunch = true;
       newLib.Update();
}
}

The code is for console application.(I know you are aware, just for clarity).

Visibility Of Quick Launch Bar in Web Part Page of SP2010

2010-06-12T20:03:00.008+05:30

Introduction:
Web part pages are usually have only web part zones for web parts. They lack the quick launch navigation bar.
In MOSS 2007, it was easy to have web part pages with quick launch by tweaking few lines in the page.

Team Site:
I used the same technique to show quick launch in web part page of SP Server 2010 publishing portal site. But it did not work for me. I googled for the same but was helpless.

While working on some other site collection with a team site, I created a web part page & I found few additional CSS statements blocking the visibility of quick launch. I modified the line & wow, it worked there. I detailed the steps below for the same.
Step I:
Open the web part page in SharePoint Designer 2010. Comment the following lines.

Step II:
Scroll up & locate the below shown lines.

Modify the line and set the display to ‘block’.

That’s it. It worked for me.

Publishing Portal:
Then I used same technique at the publishing portal. But it did not work there. Again, I googled specific to Publishing Portal and again without relevant search results.

Then I started going through the page source and found that the CSS line, which I modified, is inside a VersionedContentPlaceHolder with an ID as “WebPartPageHideQLStyles”.

I just commented it and it worked for me.

SharePoint 2010 - Silverlight Client Object Model

2010-04-10T15:39:00.007+05:30

Introduction:

Recently, I worked on a project based on SharePoint 2010 Beta. While providing solution to client, we came across Silverlight Client Object Model (OM). Microsoft SharePoint Foundation 2010 has it as part of new Client API.

As it is new to us, few questions come to our mind: How to use it? What are the basic steps to make it work? What objects, properties and methods available for use? We dig out the answer for the same & made use of it in our project successfully. I’m not the only one to have such questions, hence this post. Hope this will help others also.

Silverlight Client OM helps us develop client-side solutions. To use Silverlight Client OM, one needs to refer two DLL files (assemblies) in the application: Microsoft.SharePoint.Client.Silverlight.dll and Microsoft.SharePoint.Client.Silverlight.Runtime.dll. The assemblies are located on SharePoint Server machine at “C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\ClientBin” folder.

To start coding, one must add “using” statement for Microsoft.SharePoint.Client namespace. This core namespace provides types and members for working with SharePoint site-collection, sites, list data, and security. The Client API does not provide any admin objects or objects with scope higher than site collection.

All client objects inherit Microsoft.SharePoint.Client.ClientObject class & collections are inherited from Microsoft.SharePoint.Client.ClientObjectCollection class.

Client Object and Value Object:

All types, inheriting from ClientObject class, are referred as client objects whereas types, inheriting from ClientValueObject class, are value objects. Value objects have only properties & no methods. Do not conflict with Value Type concept of .NET Framework.

Scalar Property:

Property, returning value object is referred as scalar property.

Frequently Used Types:

All these types belong to “Microsoft.SharePoint.Client” namespace. “ClientContext” is the central object to gain access to Client OM.

Initializing Client Context:

ClientContext object requires the URL of site as a parameter to the constructor.

e.g. ClientContext context=new ClientContext(“http://www.somesite.com/”);

Silverlight web part when host the Silverlight application, they pass the URL of site as a initialization parameter (InitParams) to the application.

Properties of ClientContext:

Property	Description
Site	Retrieves site-collection associated with current context
Web	Retrieves context specific site.
Current	Static property representing current context object.

By using these properties, one can access client objects up to the site-collection level.

Methods of ClientContext:
Below are the three important methods of ClientContext.

Method	Description
Load	Used to load the query for the action.
LoadQuery	Used to load the LinQ query & to perform queryable load. (see below)
ExecuteQueryAsync	Used to send the query to the server. This is an asynchronous operation.

Client Objects do not have associated data until data retrieval is performed. Data retrieval is done using the Load & Execute methods of ClientContext. Data retrieval can be executed in two ways: In-place load & queryable load.

Queryable load uses “LoadQuery” method of context object & returns enumerable generic collection. It means, retrieved data goes to result collection. It does not load the data in the object itself.

In-place load uses “Load” method of context & loads data to client objects. That means, retrieved data will be loaded to client objects.

LinQ has two forms of data projection syntax: query syntax & method syntax. “LoadQuery” should be used when using query syntax. For method syntax, either of the load methods works. LinQ in Client OM is LinQ-to-Object.

Once the query is loaded to the context, use ExecuteQueryAsync method to send the action query to server to get data. ExecuteQueryAsync has two parameters as delegate objects: ClientRequestSucceededEventHandler & ClientRequestFailedEventHandler.

ClientRequestSucceededEventHandler specifies the method to be executed after successful completion of ExecuteQueryAsync whereas ClientRequestFailedEventHandler invokes method on failure of query execution.

Steps for Data Retrieval

1. Get ClientContext object.
2. Specify the object to retrieve data using object model.
3. Load the object either using in-place load or queryable load.
4. Execute the query.
5. Write code to process object in a method which will execute after successful invocation query.

Data Retrieval Example:

using System;
using Microsoft.SharePoint.Client;

namespace Example.Silverlight.ClientOM
{
ClientContext context;
Web site;

public MainPage()
{
InitializeComponent();
}

private void Button_Click(object sender, RoutedEventArgs e)
{
context = ClientContext.Current;
site = context.Web;

context.Load(site,website=>website.Title);

context.ExecuteQueryAsync(OnSuccess, null);
}
private void OnSuccess(object sender, ClientRequestSucceededEventArgs e)
{
MessageBox.Show(“Site Title:”+site.Title);
}
}

I know that this post requires few more examples. But due to time-constraint it is not possible. I'll update the post with few more samples and updates in few days. So visit again!!!

Sorting List of Custom Objects

2009-11-20T16:26:00.004+05:30

“System.Collections” and “System.Collections.Generic “ namespaces have classes for collections. Collection objects are the specialized objects which can hold multiple objects of other classes. Other classes also refer to collection classes along with non-collection classes. The two different namespaces have non-generic and generic versions of collection classes.
My discussion is focusing on the ArrayList collection class. This discussion also covers the generic version “List<T>"class.

What is ArrayList?
ArrayList is a non-generic collection class. Object of this class can hold list of homogeneous objects. Homogeneous objects means objects of any class (data type). This collection may not have necessarily objects of same type.

ArrayList grows dynamically with addition of new objects. It does not have any fixed length. Initially, empty ArrayList object has capacity of 0 objects. As we add first object, the capacity grows to hold 4 objects. When we add the fifth object, it grows by double to hold 8 objects in it. ArrayList capacity doubles when its capacity is crossed.

List<T> is just the generic version of ArrayList. Generic collection object can have objects of same type only.

Sorting:

ArrayList and List have the sort method already implemented. This sort method works very well for primitive system data types (e.g. int, long etc.). But what about the user-defined types (viz. Class, Struct,Enum)? To order the objects you should know how to compare them. How to acquaint .NET Framework about comparing user-defined data types?

public class Person
{
public string Name;
public int Age;
}
List<person> plist=new <Person>();
… //Add few person objects.
plist.Sort(); 

Consider we’ve the list of person objects. How sorting will happen, based on Name or Age? What it’ll compare (name or age of persons)? Try it.

Comparison of Person object is possible only if we implement IComparable or IComparer interface. The IComparable interface has single method, CompareTo. See the code below with IComparable interface implementation.

public class Person : IComparable //Change it to IComparable<Person>
{
public string Name;
public int Age;

#region IComparable Members
//Argument will be of Person type if IComparable<Person> is //implemented.
public int CompareTo(Object obj)
{
Person p=obj as Person //Not required if generic IComparable implemented.
return this.Name.CompareTo(p.Name);
}
#endregion
}

IComparable interface has generic variant, IComparable<T> interface. The CompareTo method of IComparable<T> takes object of T as argument. So type-casting of argument is avoided.

Now it’ll sort the Person list with respect to their names. What if we’d like to have the sorting by Age? Change the code.

What if we’d like to have sorting by Age as well as by Name? Then IComparable interface implementation is not sufficed. We’ve to create two implementations (classes) of IComparer interface : NameComparer and AgeComparer. IComparer interface has Compare method accepting two objects. Cast the objects to appropriate type & then compare. Generic version of IComparer is IComparer<T> can be implemented in similar way. It avoids need of type-casting.

NameComparer will have implementation of Compare method based on Name whereas AgeComparer will have implementation based on Age. These classes will not have any other code.

Sort method overload accepts object of IComparer implementation (class) as argument. If our requirement is to compare by Age use object of AgeComparer, or else NameComparer for alphabetical sorting.

public class NameComparer : IComparer
{
#region IComparer Members

public int Compare(object x, object y)
{
Person p = x as Person;
Person q = y as Person;
return p.Name.CompareTo(q.Name);
}

#endregion
}
public class AgeComparer : IComparer
{
#region IComparer Members

public int Compare(object x, object y)
{
Person p = x as Person;
Person q = y as Person;
return p.Age.CompareTo(q.Age);
}

#endregion
}
…
plist.Sort(new AgeComparer());

That’s all folks!!! Reuse the .NET functionality.

Response.Redirect and Server.Transfer

2009-11-03T10:37:00.007+05:30

Response.Redirect:

Response is the object which accumulates the HTML/Javascript for the page requested. Each response has an associated Request object. Request object has the information about HTTP request headers and request body. Request body contains posted parameters.

I've used Web Developer helper tool to show you the details of HTTP Request & Response. HTTP request is comprised of HTTP command(e.g. GET,POST HEAD etc.) alongwith HTTP Headers (e.g. User-Agent) and the request body,if any. Request body appears only if user is posting some selections / values back to HTTP server. Diagram (1) shows you the details of HTTP Request.

The image below shows the GET Request body.

The images below show the POST request with Request body

If Response.Redirect is used to change the page to be shown, there is no access method available to access the posted values on second page. The reason : Response.Redirect involves round-trip to redirect the browser to new page. Browser redirection to new page has new request. Request body of first request of the round-trip lost unprocessed.

Response.Redirect helps to redirect to different server. Page on test.com can be redirected to google.com.

In essence, Response.Redirect involves one round-trip with two different requests. Response.Redirect loose the first-request body. Use Response.Redirect to redirect the browser to some page of different server. For same server, my suggestion is to use hyperlink or Server.Transfer.

Server.Transfer:

Server object represents the server processing request. Server.Transfer cannot transfer to the page of different server. Server.Transfer does not involve any round-trip. Request body is available to new page (of same server)as no round-trip involves.

Dynamic Stylesheet Assignment Dependent on Browser

2008-07-09T12:57:00.003+05:30

I've two stylesheets. One for Internet Explorer & other for other browsers. When the client is IE, the web page should have IE-specific stylesheet attached. For rest of the browsers, the web page must use the other stylesheet.
Demo: Get two stylesheets with body background set to two different colors.

body
{
background-color:blue;
}

body
{
background-color:black;
}

Add the following code to Page_Load event handler:

protected void Page_Load(object sender, EventArgs e)
  {
      HtmlLink lnk = new HtmlLink();
      if (Request.Browser.Type.Contains("IE"))
      {
          lnk.Href = "~/StyleSheet.css";
      }
      else
      {
          lnk.Href = "~/StyleSheet2.css";
      }
      lnk.Attributes.Add("rel", "stylesheet");
      lnk.Attributes.Add("type", "text/css");
      this.Header.Controls.Add(lnk);
  }

Test with Internet Explorer & some other browser like Mozilla, Opera etc.

Delegates in C#

2008-05-26T05:00:00.003+05:30

Pointer is a variable, which stores address of some memory location. The memory location can be the storage for some value or beginning of function. When it points to function, it is function pointer. Function pointer has address of the function.

Function pointers are not safe. In thousand lines of code, if we have to invoke the function using function pointer, we cannot assure that the pointer points to function without going through the code.
We cannot ensure the number of parameters to the function or the order of parameters. Order of parameters refer to data types. What will happen if we invoked a function with function pointer & pointer is not pointing to function? What will happen if we invoked a function with function pointer & number of arguments are more or less passed? What will happen if we invoked a function with function pointer & order of parameters is wrong? (e.g. Function accepts int first & we pass string first.)

In all cases, our application will crash. In essence, Function pointers are not type-safe.

.NET has got a concept of delegates which are type-safe function pointers with ability to point to multiple functions. Delegates are declared in C# using keyword delegate.

public delegate void DisplayDelegate(string msg);

Declaration of delegate is just like function declaration. That is, the delegate must be declared with return data type & parameters. Parameter names are not relevant.

Internally, a class "DisplayDelegate" is generated which derives from System.MulticastDelegate. System.MulticastDelegate derives from System.Delegate. System.Delegate is the base class. One can create the object of "DisplayDelegate" class. The constructor accepts the function which has same signature as that of delegate declaration.

using System;

namespace DelegateDemo
{
public delegate void DisplayDelegate(string msg);
class Program
{
    static void Main(string[] args)
    {
        DisplayDelegate del = new DisplayDelegate(Show);
        del("Hello, delegate!!!");
        //Or del.Invoke("Hello, delegate!!!");
    }
    static void Show(string str)
    {
        Console.WriteLine(str);
    }
}
}

To invoke function using delegate, use Invoke function on delegate object with parameter values for the function. The function wrapped in delegate can be static or instance function.

Let's see, how delegates are type-safe? When one creates a delegate object, the delegate is aware of the parameters required. Wherever you call the function using delegate, compiler will not compile the program if,

function specified in constructor is not with appropriate function signature.
the number of parameters are less or more while invoking the function.
the order of parameters is not appropriate.

In essence, delegates are type-safe. One can catch the errors at compile-time only using delegates

A single delegate can have multiple functions. All functions must have same signature like delegate. Delegate invokes functions in FIFO(First-In,First-Out) order. If the function has return value, return value of last function invoked will be returned by delegate. Return values of all other functions are lost.

System.Delegate class has two static methods Combine and Remove. Use the methods to provide the delegate with multiple functions.

using System;
using System.Windows.Forms;

namespace DelegateDemo
{
  public delegate void DisplayDelegate(string msg);
  class Program
  {
      static void Main(string[] args)
      {
          DisplayDelegate del = new DisplayDelegate(Show);
          DisplayDelegate del1 = new DisplayDelegate(Print);
          del = (DisplayDelegate)Delegate.Combine(del, del1);
          del("Hello,World!!!");
          del = (DisplayDelegate)Delegate.Remove(del, del1);
          del("Hi!!!");
      }
      static void Show(string str)
      {
          MessageBox.Show(str);
      }
      static void Print(string msg)
      {
          Console.WriteLine(msg);
      }
  }
}

System.Delegate has two properties Method and Target. The derived class have these properties inherited. "Method" property gets the method represented by delegate. "Target" gets the instance/object on which the delegate operates. "Target" returns null for static methods.

static void Main(string[] args)
      {
          DisplayDelegate del = new DisplayDelegate(Show);
          Console.WriteLine(del.Method.Name);
          if(del.Target!=null)
          Console.WriteLine(del.Target.ToString());
      }

If delegate has multiple functions, one can use GetInvocationList method of System.Delegate class to retrieve System.Delegate[] array.

static void Main(string[] args)
      {
          DisplayDelegate del = new DisplayDelegate(Show);
          DisplayDelegate del1 = new DisplayDelegate(Print);
          del = (DisplayDelegate)Delegate.Combine(del, del1);
          foreach (DisplayDelegate minf in del.GetInvocationList())
          {
              Console.WriteLine(minf.Method.Name);
          }
      }

Number Flip in numeric data types

2008-05-21T05:00:00.004+05:30

Look at the code below. It prints -128 as output. Oops!!! How?

using System;

namespace NumberFlipDemo
{
class Program
{
static void Main(string[] args)
{
sbyte i = 127;
i++;
Console.WriteLine(i.ToString());
}
}
}

Let dig out the answer.
If we look at carefully, signed byte has range from -128 to 127.
Three methods to represent negative numbers:
Signed Magnitude -->Two representations for 0; -1 repsentated as 81.
1's Complement --> Two Representation for 0; -1 represented as FE.
2'Complement --> Single Representation for 0; -1 represented as FF.
How negative numbers are represented in the machine? Let's check.See the code here.

static void Main(string[] args)
{
sbyte i = -1;
Console.WriteLine(i.ToString("x"));
//parameter "x" to ToString gives hex o/p.
}

Output is FF. Machine uses 2's complement.

How to compute 2's Complement representation?Consider we want to represent -2 in 2's complement.
Take binary representation of 2 i.e. 0000 0010. Complement all bits. Result is 1111 1101. Now add 1 to it. We will get 1111 1110 i.e. FE.

To compute 2's complement representation of a number. First complement the bits of binary representation of the number absolute.( abs(-2)=2). Add bit 1 to the complemented bits. The result is 2's complement.
Now back to our question. Why the above code snippet gives wrong o/p without any error?
Consider that size of integer is 2 bits. Hence range of numbers to be accomodated in integer data type is -2 to 1. Let put binary representation of all these numbers in a table.

1--> 01
0--> 00
-1 --> 11 (2's complement)
-2 --> 10 (2's complement)

Now if my integer variable has a extreme positive value i.e. 1 e.g. i=1;
Add 1 to i.

i+1=1+1 =>(01)+(01)=(10)=> -2
i has value 1 i.e. binary 01. Add 1 bit to it.See the result. It gives us 10 which is being binary representation for -2.

In same fashion, number flips to -128 in case of signed byte. The theory is applicable to all whole number data types i.e. byte, sbyte,int, short, long.

Be careful while making choice of data type!!! The theory applies to all programming lanaguages.

Extension Methods in C# 3.0

2008-05-20T05:00:00.003+05:30

Developer code for assemblies. Compile it & publish it for client use. User of assembly may like to have some additional functionality in data types of the assembly. e.g int or Int32 do not have function to convert integer to complex number. ComplexNumber is the new data type defined by user.

Now with C# 3.0 has provided with the concept of extension methods. Extension methods enable us to extend the functionality of data types already defined. No source code of the assembly is available to modify & recompile the assembly. Still one can extend the data types functionality.

Inheritance also provides capability to extend the functionality but the extended functionality is available only for derived classes & not to the base class. e.g Consider I'd like to have a ToInt function in String class. If I use inheritance approach, I have to create new derived type. So I cannot use methods of derived type on my String objects.

Extension methods are written in static class. The method should also a static method. First parameter of the method must be of type being extended. The first parameter must have this keyword before it.

See the code below.

public static class ExtensionInt
{
 public static Complex ToComplex(this int val)
 {
     Complex temp = new Complex();
     temp.Real = val;
     return temp;
 }
}

Complex is the type defined as follows:

public class Complex
{
 public int Real;
 public int Imag;
 public override string ToString()
 {
     return (Real.ToString() + "+i" + Imag.ToString());
 }
}

Use the method ToComplex for int or Int32.

 static void Main(string[] args)
  {
      int i = 5;
      Console.WriteLine(i.ToComplex().ToString());
  }

Sealed classes can take advantage of extension methods. LINQ makes use of extension methods defined in Enumerable static class. The class extends functionality of objects implementing IEnumerable interface. To use the extension methods from Enumerable class refer the assembly System.Core.

Local Type Inference in C# 3.0

2008-05-19T05:00:00.004+05:30

C# 3.0 has new feature called "Local Type Inference". Type Inference lets compiler decide the data type of variable/object. Variable initializing data value helps compiler to decide the data type. C# 3.0 introduces new keywaord "var" to declare such variables. No explicit type declaration is required.

Local Type Inference has type inference only for local variables. One cannot declare class-/struct-level fields with keyword "var". "var" cannot act as return type for function and cannot appear in function parameter i.e. no "var" should be used in function signature.

using System;

namespace TypeInference
{
class Program
{
static void Main(string[] args)
{
var i = 5;
var intArray = new int[] { 1, 2, 3, 4, 5 };
//Variables declared with var cannot be assigned to null if no type has been inferred.
var str = default(string);
Console.WriteLine("Data Type Of i:"+i.GetType().Name);
Console.WriteLine("Data Type of intArray:" + intArray.GetType().Name);
//Console.WriteLine("Data Type of str:" + str.GetType().Name); -->Null Reference Exception
str = "";
Console.WriteLine("Data Type of str:" + str.GetType().Name);
}
}
} 

Obtaining System Information in C#

2008-05-15T16:22:00.002+05:30

System.Windows.Forms namespace has SystemInformation class. The class has various static properties. To get information about the current system environment, use the class.

To determine the startup mode of the system, use BootMode property. The property can have values : Normal, FailSafe or FailSafeWithNetwork. All these values are defined in BootMode enumeration of System.Windows.Forms namespace.

using System;
using System.Windows.Forms;

//Add reference to System.Windows.Forms assembly.

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(SystemInformation.BootMode.ToString());
}
}
}

To access the computer name, use ComputerName property.

Console.WriteLine(SystemInformation.ComputeName);

To find out number of displays connected to machine, MonitorCount propery will help us.

Console.WriteLine(SystemInformation.MonitorCount.ToString());

Availability of mouse can be checked with the help of property MousePresent.

static void Main(string[] args)
{
if(SystemInformation.MousePresent)
Console.WriteLine("System has the mouse connected");
}

To check for network connection availability, use Network property.

if(SystemInformation.Network)
Console.WriteLine("System is connected to the network.");

There are lot many properties exposed by SystemInformation class. Check out MSDN!!!

Boxing and UnBoxing in C#

2008-05-15T14:28:00.007+05:30

Boxing and unboxing are essential concepts of .NET type system.

Boxing refers to conversion of value type to reference type.

int i=5;
object o=i; //boxing

Unboxing refers to the conversion of reference type to value -type.

int j=(int)o; //Unboxing & type-casting.

Too much boxing and unboxing hits the application performance. Care must be taken while coding. Try to avoid boxing and unboxing.

See the below code. Does the following code has boxing?

using System;

namespace BoxingDemo
{
class Program
{
static void Main(string[] args)
{
int count = 5;
Console.WriteLine("Count:" + count);
}
}
}

Look at the IL Code generated. It has box instruction. Boxing happens here.

How to avoid it? See the code below & IL generated for it. It has no boxing.

using System;

namespace BoxingDemo
{
class Program
{
static void Main(string[] args)
{
int count = 5;
Console.WriteLine("Count:" + count.ToString());
}
}
} 

Be careful!!!

Value Type & Reference Type in .NET

2008-05-15T14:15:00.005+05:30

Object, variables; declared in .NET Compatible languages; requires data type to be specified. Data types specifies what kind of data (textual or numeric or complex) can be stored in the object/variable.

Data types in .NET are categorized in two types: Value Type and Reference Type.

Value type variables are allocated on stack & directly store the data value. Value-types cannot be assigned to null value. Value type variable vanish when they go out-of-scope (visibility).

Value types are : all primitive system types(int, float etc.) and structures, enumerations.

Reference types are allocated on heap. Value gets stored in heap. The address of memory location, having value, gets stored in stack in memory location tagged with the object/variable. Heap is garbage collected. Reference type variables/objects can be assigned null value.

Reference types: Classes, Delegates, Arrays and Interfaces

Union in C#

2008-05-14T17:30:00.010+05:30

One can simulate union in C# with the help of StructLayout and FieldOffset attributes.

StructLayout attribute allows the user to control the physical layout of the data fields of a class or structure. Specify the LayoutKind the first parameter as LayoutKind.Explicit.

Tag each field with FieldOffset attribute. The attribute must be applied so that the type members are overlaying the same memory area.

using System;
using System.Runtime.InteropServices;
// Above namespace required for StructLayout attribute
namespace UnionTest
{
class Program
{
static void Main(string[] args)
{
Union test = new Union();
test.x = 256;
//Setting value 256 makes high-order byte to be set to 1. Byte ranges up to 255.
Console.WriteLine("Low:" + test.lowx + "\nHigh:" + test.highx);
}
}
[StructLayout(LayoutKind.Explicit,Size=2)]
public struct Union
{
//2 bytes
[FieldOffset(0)]public short x;
//1 byte
[FieldOffset(0)]public byte lowx;
//1 byte -->represents high-order byte.
[FieldOffset(1)]public byte highx;
}
}