.NET Technical bits

Convert number to words using C#

noreply@blogger.com (Kumar S) — Fri, 15 Jun 2012 12:13:00 +0530

Convert number to words using C#

static string[] ones ={"", "one" , "two", "three", "four", "five", "six", "seven", "eight" , "nine", "ten" ,
"eleven", "twelve" , "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};

static string[] tens ={"zero","ten","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"};

static string[] thou = { "", "thousand", "lakh"};

public static string NumberToWords(int inputNum)

{

int dig1, dig2, dig3, level = 0, lasttwo, threeDigits;

string retval = "";

string x = "";

try

{

bool isNegative = false;

if (inputNum < 0)

{

isNegative = true;

inputNum *= -1;

}

if (inputNum == 0)

return ("ZERO");

string s = inputNum.ToString();

while (s.Length > 0)

{

// Get the three rightmost characters

x = (s.Length < 3) ? s : s.Substring(s.Length - 3, 3);

// Separate the three digits

threeDigits = int.Parse(x);

lasttwo = threeDigits % 100;

dig1 = threeDigits / 100;

dig2 = lasttwo / 10;

dig3 = (threeDigits % 10);

// append a "thousand" where appropriate

if (level > 0 && dig1 + dig2 + dig3 > 0)

{

retval = thou[level] + " " + retval;

retval = retval.Trim();

}

// check that the last two digits is not a zero

if (lasttwo > 0)

{

if (lasttwo < 20) // if less than 20, use "ones" only

retval = ones[lasttwo] + " " + retval;

else // otherwise, use both "tens" and "ones" array

retval = tens[dig2] + " " + ones[dig3] + " " + retval;

}

//Lakhs

if (level > 0 && dig1 > 0)

{

if (dig1 > 1)

{

retval = ones[dig1] + " lakhs " + retval;

}

else

{

retval = ones[dig1] + " lakh " + retval;

}

}// if a hundreds part is there, translate it

else if (dig1 > 0)

retval = ones[dig1] + " hundred " + retval;

s = (s.Length - 3) > 0 ? s.Substring(0, s.Length - 3) : "";

level++;

}

while (retval.IndexOf(" ") > 0)

retval = retval.Replace(" ", " ");

retval = retval.Trim();

if (isNegative)

retval = "negative " + retval;

}

catch (Exception)

{

}

return (retval);

}

Difference between WCF and ASP.NET Web Services

noreply@blogger.com (Kumar S) — Wed, 11 May 2011 17:54:00 +0530

Data translation:
ASP.NET web service depends on defining data and relies on the XmlSerializer to transform data to or from a service.

There are few issues with XmlSerializer to XML from serialize .NET types.

• The translated XML will have only the public fields or properties of .NET types

• The implemented class from IDictionary (ex: hash table) cannot be translated

• This will have the classes which implement IEnumerable interface

The WCF uses the attributes DataContract attribute and DataMemeber attribute to translate .NET types in to XML.

[DataContract]
public class Member
{
       [DataMember]
       public int memberID;
       [DataMember]
       public string memberName;
       [DataMember]
       public decimal salary;
}

The DataContractAttribute can be used for class or a struct. DataMemberAttribute can be used for private/public field or property.

DataContractSerializer and XMLSerializer:

• Performance wise DataContractSerializer better than XMLserialization

• DataContratSerializer Explicitly shows the which fields or properties are serialized into XML but XMLSerializer is not

• Hash Table can be translated in DataContractSerializer

Creating WCF and Web Services:

When we create a web service the WebService attribute need to be added to the web service class and WebMethod Attribute need to be added for any web service class methods.
For Example:

[WebService]
public class MyService : System.Web.Services.WebService
{
      [WebMethod]
      public string InvokeMe(string message)
     {
            return message;
     }
}

To create a WCF service we will write this code:
[ServiceContract]
public interface IMyService
{
        [OperationContract]
        string InvokeMe(string message);
}

public class MyService : IMyService
{
        public string InvokeMe (string message)
       {
              return message;
       }
}

The interface defines a WCF service contract using the ServiceContract attribute and the OperationContract tells which of the methods of the interface defines the operations of the service contract. The service type in WCF will be referred to as a class that implements the service.

Hosting the Services:
ASP.NET web services are created and compiled and will be hosted in IIS. This hosted will have the service file with extension .asmx and will have assembly with the compiled class. The hosted .asmx url can be added as a web reference to a .NET project so that the class and methods from service will be accessible in the project.
WCF Service can be hosted within IIS or WindowsActivationService using the steps below.

• Compile the service type into a class library.

• Copy the service file with an extension .SVC into a virtual directory and assembly into bin sub directory of the virtual directory.

• Copy the web.config file into the virtual directory.

Asp.NET Chart - How to specify Data

noreply@blogger.com (Kumar S) — Tue, 26 Apr 2011 12:33:00 +0530

The chart area(s), series, and data points can be specified declaratively (either by entering the declarative mark-up by hand or via the Properties window) or programmatically in the code-behind class. Typically the series and chart area(s) are specified declaratively and the data points are populated programmatically by querying a database or some other dynamic data store. Let's start by discussing how to display a chart whose chart area, series, and data points are all specified declaratively.

<asp:Chart ID="chtNBAChampionships" runat="server">
<Series>

<asp:Series Name="Championships" YValueType="Int32" ChartType="Column" ChartArea="MainChartArea">

<Points>

<asp:DataPoint AxisLabel="Celtics" YValues="17" />

<asp:DataPoint AxisLabel="Lakers" YValues="15" />

<asp:DataPoint AxisLabel="Bulls" YValues="6" />

<asp:DataPoint AxisLabel="Spurs" YValues="4" />

<asp:DataPoint AxisLabel="76ers" YValues="3" />

<asp:DataPoint AxisLabel="Pistons" YValues="3" />

<asp:DataPoint AxisLabel="Warriors" YValues="3" />

</Points>

</asp:Series>

</Series>

<ChartAreas>

<asp:ChartArea Name="MainChartArea">

</asp:ChartArea>

</ChartAreas>

</asp:Chart>

Note that the Chart control has a <Series> section and a <ChartAreas> section, which define the series and the chart areas, respectively. The <ChartAreas> section in the above mark-up defines a single ChartArea named MainChartArea. The <Series> section defines a single Series named Championships. This Championship series is configured to render as a column and is displayed in the MainChartArea. Next, its data points are defined via the <Points> collection. There are seven data points, each data point displaying the NBA team name via the AxisLabel property and the number of championships in the YValues property.

After defining this mark-up, visit this page through a browser. You should see a chart in your browser similar to the screen shot below:

How to add a Microsoft Chart control to an ASP.NET Page

noreply@blogger.com (Kumar S) — Tue, 26 Apr 2011 12:14:00 +0530

To add charts to a web page simply drag the Chart control from the Toolbox onto the page. Doing so adds the Chart control's declarative mark-up to the page:

<asp:Chart ID="Chart1" runat="server">

<Series>

<asp:Series Name="Series1" IsVisibleInLegend="False">

<EmptyPointStyle IsVisibleInLegend="False" />

</asp:Series>

</Series>

<ChartAreas>

<asp:ChartArea Name="ChartArea1">

</asp:ChartArea>

</ChartAreas>

</asp:Chart>

Note that the Chart control is identified in the declarative mark-up via the tag prefix and name . This prefix (asp) is mapped to the Chart Controls assembly in Web.config:

<controls>

<add tagPrefix="asp" namespace="System.Web.UI.DataVisualization.Charting" assembly="System.Web.DataVisualization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

</controls>

Additionally, an HTTP Handler named ChartHttpHandler is mapped to requests to chartImg.axd. As we'll see in a bit, when visited through a browser the Chart control renders an <img> element with a src attribute of ChartImg.axd. As a result, the browser makes a request to this file (ChartImg.axd) to display the chart image. This request is routed to the ChartHttpHandler HTTP Handler which generates the image contents and returns that binary data to the browser for display. This mapping between the ChartImg.axd path and the ChartHttpHandler HTTP Handler is implemented via the following Web.config mark-up:

<handlers>

<remove name="ChartImageHandler" />

<add name="ChartImageHandler" preCondition="integratedMode" verb="GET,HEAD,POST" path="ChartImg.axd" type="System.Web.UI.DataVisualization.Charting.ChartHttpHandler, System.Web.DataVisualization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

</handlers>

Both of the above configuration additions are automatically added to Web.config when you add a Chart control to a web page for the first time in your project.

How to implement Partial-Page Rendering

noreply@blogger.com (Kumar S) — Tue, 12 Apr 2011 16:50:00 +0530

With partial-page rendering, you can refresh individual regions of the page asynchronously and make the page more responsive to the user. You can implement partial-page rendering using ASP.NET AJAX Web server controls, and optionally write client script that uses the APIs in the Microsoft Ajax Library.
To add AJAX functionality to ASP.NET Web pages, you identify individual sections of the page that you want to update. You then put the content of these sections into UpdatePanel controls. The contents of an UpdatePanel control can be HTML or other ASP.NET controls. You can add an UpdatePanel control to the page as you would any other control. For example, in Visual Studio you can drag it from the toolbox to the Web page, or you can add it by using declarative mark-up in the page. The following example shows the mark-up for an UpdatePanel control.

<asp:UpdatePanel ID="UpdatePanel2" runat="server">
<ContentTemplate>

</ContentTemplate>
</asp:UpdatePanel>

By default, postbacks that originate from controls inside the update panel (child controls) automatically initiate asynchronous postbacks and cause a partial-page update. You can also specify that controls outside the update panel cause an asynchronous postback and that they refresh the UpdatePanel control's content. A control that causes an asynchronous postback is referred to as a trigger.
Here is a sample with UpdatePanel which refreshes a particular region of a web page. This sample refreshes a grid data and a label for every 5 seconds.
Here we have created an ASPX page with Site. master as the Master page and this page does have a developer express data grid and a label box.

<asp:Content ID="BodyContent" runat="server" ContentPlaceHolderID="MainContent">
<asp:ScriptManager ID="ScriptManager1" runat="server" />
<div>
<asp:Timer ID="Timer1" OnTick="Timer1_Tick" runat="server" Interval="5000">
</asp:Timer>
<asp:UpdatePanel ID="UpdatePanel1" UpdateMode="Conditional" runat="server">
<Triggers>
<asp:AsyncPostBackTrigger ControlID="Timer1" EventName="Tick" />
</Triggers>
<ContentTemplate>
<dx:ASPxDataView ID="ASPxDataViewSystemInfo" runat="server"
ClientIDMode="AutoID">
<ItemTemplate>
<b>ID</b>:
<asp:Label ID="IDLabel" runat="server" Text='<%# Eval("ID") %>' />
<b>Name</b>:
<asp:Label ID="PageRankLabel" runat="server" Text='<%# Eval("Name") %>' />
</ItemTemplate>
</dx:ASPxDataView>
<dx:ASPxLabel ID="ASPxLabelCurrentTime" runat="server" Text="ASPxLabel">
</dx:ASPxLabel>
</ContentTemplate>
</asp:UpdatePanel>
</div>
</asp:Content>

There is a function in the code behind file to bind data for the grid

public void BindData()
{
SqlConnection con = new SqlConnection("Data Source=10.1.14.15;Initial Catalog=iDynamics;Persist Security Info=True;User ID=developers;Password=dev");
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "select * from Staff ";
cmd.Connection = con;
con.Open();
IDataAdapter da = new SqlDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds);
cmd.ExecuteNonQuery();
ASPxDataViewSystemInfo.DataSource = ds;
ASPxDataViewSystemInfo.DataBind();
}

The refresh code needs to be executed inside the timer tick event.

protected void Timer1_Tick(object sender, EventArgs e)
{
ASPxLabelCurrentTime.Text = "Grid Refreshed at: " + DateTime.Now.ToLongTimeString();
BindData();
}

The above example will be displayed the staff details in grid and the refreshed time in the label box. The grid and label box information will be refreshed by every 5 minutes. We cannot see any flickering while refreshing the values on grid and labelbox.

ASP.NET Whole Page Rendering

noreply@blogger.com (Kumar S) — Tue, 12 Apr 2011 16:11:00 +0530

How do we refresh an ASP.NET web page to auto refresh on a set interval. Obviously, there are several methods, including Java Script.

To simply refresh the web page every five minutes, you can place the "meta http-equiv...." line shown below in the HTML editor of your ASPX page. Content ="300" means refresh every 300 seconds or five minutes.



<HEAD>

<title>WebForm1<title>



<meta content="Microsoft Visual Studio .NET 7.1" name="GENERATOR">



<meta content="C#" name="CODE_LANGUAGE">



<!--The next line of code will refresh the page every 5 minutes-->



<meta http-equiv="refresh" content="300">



<meta content="JavaScript" name="vs_defaultClientScript">



<meta content="http://schemas.microsoft.com/intellisense/ie5" 



name="vs_targetSchema">



</HEAD>

That's all there is to it, if there is only a data grid on the page! However, be aware that this refresh acts like an initial page load, and any other controls, such as Drop Down Lists, etc., which have been set to other than default values will be lost unless you do some additional coding to restore their content at the time the refresh fires.

The above code will load the entire ASP page. Here it is not possible to load/refresh a particular region or control (example: data grid). Here is the need of partial rendering comes.

Advantages of LINQ over Stored Procedures

noreply@blogger.com (Kumar S) — Fri, 8 Apr 2011 11:02:00 +0530

1. It stands for Language Integrated Query. LINQ is collection of standard query operators that provides the query facilities into .NET framework language like C#.
2. Debugging: It is really very hard to debug the stored procedure but as LINQ is part of .NET, you can use visual studio's debugger to debug the queries.
3. Deployment: With stored procedures, we need to provide an additional script for stored procedures but with LINQ everything gets complied into single DLL hence deployment becomes easy.
4. Type Safety: LINQ is type safe, so queries errors are type checked at compile time. It is really good to encounter an error when compiling rather than runtime exception!
5. Abstraction: This is especially true with LINQ-to-Entities. This abstraction also allows the framework to add additional improvements that you can easily take advantage of. PLINQ is an example of adding multi-threading support to LINQ. Code changes are minimal to add this support. It would be MUCH harder to do this data access code that simply calls stored procedures.
6. Debugging support: I can use any .NET debugger to debug the queries. With stored procedures, you cannot easily debug the SQL and that experience is largely tied to your database vendor (MS SQL Server provides a query analyzer, but often that isn't enough).
7. Vendor agnostic: LINQ works with lots of databases and the number of supported databases will only increase. Stored procedures are not always portable between databases, either because of varying syntax or feature support (if the database supports stored procedures at all).
8. Easier: You don't have to learn T-SQL to do data access, nor do you have to learn the data access API (e.g. ADO.NET) necessary for calling the stored procedures.
9. Not just tables in a relational database: LINQ's benefits include, most significantly, a standardized way to query not just tables in a relational database but also text files, XML files, and other data sources using identical syntax. A second benefit is the ability to use this standardized method from any .NET-compliant language such as C#, VB.NET, and others.
10. Collections like arrays: It allows you to query collections like arrays, enumerable classes etc in the native language of your application, and like VB or C# in much the same way as you would query a database using SQL. LINQ to SQL, which is what most of the current fuss is about, is an Object/Relational Mapper (O/RM) built in to Visual Studio.
11. Entity classes: It automatically generates entity classes based on the database schema, so it helps speed up development of n-layer architecture applications.
12. Faster to Develop: LINQ to SQL is not necessarily going to speed up data access code. Since LINQ to SQL is abstraction over the low level ADO.NET command and connection classes, it's bound to be a bit slower at runtime (but hopefully faster to develop with).
13. Amount of Code: It seems to me that the main advantage of Linq over writing a stored procedure in management studio is the hard typing of tables and parameters and auto completion of column names. The amount of code to connect to the database is significantly reduced - to one or two lines making code much more readable and removing coding errors.
14. Code is much more robust: You get auto complete on the (column / field names) and an error if you mistype or mismatch - your code is much more robust.
15. Filtering and Grouping : Say you access your code via a stored procedure (to apply filtering, grouping, join etc) and you (or someone edits) your stored procedure, to add a (returned) column which happens to be the 3rd column of 7: then that will break your code which refers to ordinal position. Actually if you got to the spec for SQL, you will find that ordinal position on a table may not be maintained, where as column name is guaranteed.
16. No ordinal position problem: Now that the ordinal position problem in the VB implementation is fixed you can happily manipulate to your heart’s content.
17. Easier to transform data into objects: Makes it easier to transform data into objects. I'm sure you've heard the term "Impedence Mismatch" being used quite often, meaning that LINQ reduces the amount of work you must do to translate between object-oriented code and data paradigms such as hierarchical, flat-file, messages, relational, and more. It doesn't eliminate the "Impedence Mismatch" because you must still reason about your data in its native form, but the bridge from here to there is (IMO) much shorter.
18. Common syntax: A common syntax for all data. Once you learn query syntax, you can use it with any LINQ provider. I think this is a much better development paradigm than the Tower of Babel that has grown over the years with data access technologies. Of course, each LINQ provider has unique nuances that are necessary, but the basic approach and query syntax is the same.
19. Strongly typed code: The C# (or VB.NET) query syntax is part of the language and you code with C# types, which are translated into something a provider understands. This means that you gain the productivity of having your compiler find errors earlier in the development lifecycle than elsewhere. Granted, many errors in stored proc syntax will generate errors when you save, but LINQ is more general than SQL Server. You have to think of all the other types of data sources that generate runtime errors because their queries are formed with strings or some other loosely typed mechanism.
20. Provider integration: Pulling together data sources is very easy. For example, you can use LINQ to Objects, LINQ to SQL, and LINQ to XML together for some very sophisticated scenarios. I think it's very elegant.
21. Reduction in work: Before LINQ, I spent a lot of time building DALs, but now my DataContext is the DAL. I've used OPFs too, but now I have LINQ that ships with multiple providers in the box and many other 3rd party providers, giving me the benefits from my previous points. I can set up a LINQ to SQL DataContext in a minute (as fast as my computer and IDE can keep up).
22. Performance in the general case doesn't become an issue: SQL Server optimizes queries quite well these days, just like stored procedures. Of course, there are still cases where stored procedures are necessary for performance reasons. For example, I've found it smarter to use a stored proc when I had multiple interactions between tables with additional logic inside of a transaction. The communications overhead of trying to do the same task in code, in addition to getting the DTC involved in a distributed transaction made the choice for a stored proc more compelling. However, for a query that executes in a single statement, LINQ is my preferred choice because even if there was a small performance gain from a stored proc, the benefits in previous points (IMO) carry more weight.
23. Built-in security: One reason I preferred stored procedures before LINQ was that they forced the use of parameters, helping to reduce SQL injection attacks. LINQ to SQL already parameterizes input, which is just as secure.
24. LINQ is declarative: A lot of attention is paid to working with LINQ to XML or LINQ to SQL, but LINQ to Objects is incredibly powerful. A typical example of LINQ to Objects is reading items from a string[]. However, that's just a small example. If you think about all of the IEnumerable collections (you can also query IEnumerable) that you work with every day, the opportunities are plentiful. i.e. Searching an ASP.NET ListBox control for selected items, performing set operations (such as Union) on two collections, or iterating through a List and running a lambda in a ForEach of each item. Once you begin to think in LINQ, which is declarative in nature, you can find many of your tasks to be simpler and more intuitive than the imperative techniques you use today.

New concepts in ASP.NET 4.0, Visual Studio 2010 IDE

noreply@blogger.com (Kumar S) — Thu, 30 Dec 2010 11:23:00 +0530

1. Code snippets: - Code snippets are pre-developed code templates which can save time spent on thinking about the syntax. There are already a lot of built-in code snippets in VS2005 and VS2008. However, those are only available for the code-behind. Code snippets in VS2010 are introduced for JScript, HTML, and ASP.NET markup as well.
2. New Profiles: - We have seen different development profiles in previous versions of .NET. Like VB, C#, Web Development, and General Development. We select a profile based on our priorities. These are selected after the first installation of Visual Studio or from the Import Export option.
In VS2010, two more profiles are introduced and both support HTML developers. Those are:
1. Web Development
2. Web Development (Code Optimized)
3. Generate From Usage: - In previous versions of ASP.NET, Microsoft introduced code refactoring to generate methods and identifiers from existing code. In ASP.NET 4.0, there is a new concept of Generate From Usage - generates properties, methods, classes, and other types based on existing code.
4. Multi Targeting: - In VS2008, it is possible to create a project in version 2.0 or 3.0, rather than developing in default 3.5. Also, there is an option to change a developed project's target framework version.
The same option is available in VS2010, but with one improvement. In the previous versions, if you create a project in framework 2.0, intellisense will still show you the types and members of 3.5 version as well, so there are more chances of error if you cannot identify the member of the chosen framework. But in VS2010, the intellisense will show you options for the appropriate framework only.
5. Multi-Monitor: - Visual Studio 2010 provides us facility to move windows of the IDE outside of the Visual Studio IDE and place them on the desktop area. It also supports having different IDE windows on multiple monitors. If we close Visual Studio and open it again, we will find all the windows on the same places where we finished them last time.
6. Code Navigation in Class Files: - A new Navigate To option gives us facility to search a term in a file more quickly. It searches the text as you type, but it works for class files only, i.e., it doesn't work for HTML or code-behind files. In the following example, it shows the function name as I type it in the Navigate To window; on selection of any, it will navigate to the function definition.

7. View Call Hierarchy: -This featrure helps to see the use of a function and its properties. For example, if you right click on a function name, it will show you the hierarchical list of function usage.
8. Code Identifier Highlighting: - On selection of an identifier, the IDE will highlight the places for you where it is utilized. For example, I selected variable i and it highlights the different places it is used.
9. Intellisense Improvements: - In VS2008, on selecting properties for an object, intellisense will show you the properties based on the alphabetical order as you type.
In VS2010, it shows you the properties based on groups. For example, if you type text for a text box, it will show you the members based on the word text, like Text, TextChanged, TextMode. It also supports Pascal case intellisense. For example, if you type TC, it will navigate to the TextChanged member.
10. EnablePersistedSelection: -On selecting a row in controls like DataList or GridView, if we move to another page index, it selects the same numbered row on the newly selected page, although we selected it only on the first page.
To avoid this, ASP.NET 4.0 has introduced a new property for these controls, called EnablePersistedSelection. If you set it to true, it will not select the same numbered row on other pages, and on navigation to the original page, for example, the first page, it will show the initially selected row as selected.
11. Web.Config Transformation: - Normally, we set some values in web.config for the development environment, and then we change those values manually at the time of deployment or testing.
For example, if we have a connection string or any key value combination in the web.config file, and we want to replace those at the time of project publishing or deployment, then we can use the new web.config transformation. It is an automatic way to perform this operation.
Web.config settings can be overridden by other config files like web.release.config, web.debug.config etc., at the time of debug, release. These values are not overridden in the original web.config but in the published web.config.
With the help of transformation, we can replace, remove, or delete a node, and for a node itself, we can remove or set attributes.
12. URL Routing: - Nowadays, we see that website URLs are more SEO specific and do not show any descriptive information. For example, rather than showing a URL like: http://mywebsite.com/userprofiles.aspx?userid=1, developers would prefer to show the URL as: http://mywebsite.com/mydetails.
URL mapping in ASP.NET 2.0 provides us an option to achieve this functionality up to some extent. We can mention exact URLs to navigate and URLs to show to the user. But in the case of postback, this option starts showing the actual URL in the browser.
URL routing was introduced in ASP.NET 3.5. Developers had to create different route handler classes depending on the number of URL routings for a website. The postback issue was solved with this URL routing option.
In ASP.NET 4.0, you do not need to define separate handler classes for each routing. There is a built-in helper function MapPageRoute which helps you to implement routing more quickly. These routes are registered on Application_Start. For example, in this example, in global.asax, the SetRouting method sets routing, the first parameter is the router's friendly name, the second parameter is to check for the URL pattern to match, and the third is the ASPX page where this functionality would be implemented for the users.
13. Add Reference Dialog: - In previous versions of Visual Studio, on opening the Add Reference dialog box, it will take some time to load .NET assembly files initially till the time it loads all the references from the GAC. In VS2010, on opening Add Reference, it opens the Projects tab by default.
If you click on the .NET or COM tab by mistake, you still have an option of canceling it before it loads all the assemblies. So, the VS IDE does not freeze like before.
14. Compressing Session Values: - ASP.NET session out-of-process state values are saved in a database or on the server. These are saved in a serialized format. Bigger session values consume more resources to be sent to the server. Now, those can be compressed with a new built-in property compressionEnabled. This attribute for the sessionState element can be mentioned in the web.config.

Scope of WCF Security and WCF Bindings and Behaviors

noreply@blogger.com (Kumar S) — Thu, 30 Dec 2010 10:37:00 +0530

When you create an overall security policy – for example, transfer security with authentication and authorization for your services – you can use bindings and behaviors to configure the required settings.
Bindings and behaviors are described as follows:
• Bindings. Bindings control the security mode, client credential type, and other security settings.
• Behaviors. Service behaviors control impersonation levels, how client credentials are authenticated and authorized, and service credentials.
You can configure bindings and behaviors, or you can program against the object model. Your binding selection determines the available security options for WCF. The following table summarizes the most commonly used bindings in WCF.

Difference Between .net 2.0,3.0,3.5

noreply@blogger.com (Kumar S) — Tue, 30 Nov 2010 13:24:00 +0530

.NET Framework 2.0
Released with Visual Studio 2005 , Microsoft SQL Server 2005, and BizTalk 2006.
The 2.0 Redistributable Package can be downloaded for free from Microsoft, and was published on 2006-01-22.
The 2.0 Software Development Kit (SDK) can be downloaded for free from Microsoft.
It is included as part of Visual Studio 2005 and Microsoft SQL Server 2005.
Version 2.0 is the last version with support for Windows 2000, Windows 98 and Windows Me.
It shipped with Windows Server 2003 R2 (not installed by default).
Changes in 2.0 on comparison with 1.1
Numerous API changes.
A new hosting API for native applications wishing to host an instance of the .NET runtime. The new API gives a fine grain control on the behavior of the runtime with regards to multithreading, memory allocation, assembly loading and more (detailed reference). It was initially developed to efficiently host the runtime in Microsoft SQL Server, which implements its own scheduler and memory manager.
Full 64-bit support for both the x64 and the IA64 hardware platforms.
Language support for generics built directly into the .NET CLR.
Many additional and improved ASP.NET web controls.
New data controls with declarative data binding.
New personalization features for ASP.NET, such as support for themes, skins and webparts.
.NET Micro Framework - a version of the .NET Framework related to the Smart Personal Objects Technology initiative.
Partial classes
Anonymous methods
.NET Framework 3.0
.NET Framework 3.0, formerly called WinFX includes a new set of managed code APIs that are an integral part of Windows Vista and Windows Server 2008 operating systems. It is also available for Windows XP SP2 and Windows Server 2003 as a download. There are no major architectural changes included with this release; .NET Framework 3.0 uses the Common Language Runtime of .NET Framework 2.0 Unlike the previous major .NET releases there was no .NET Compact Framework release made as a counterpart of this version.
.NET Framework 3.0 consists of four major new components:
Windows Presentation Foundation (WPF), formerly code-named Avalon; a new user interface subsystem and API based on XML and vector graphics, which uses 3D computer graphics hardware and Direct3D technologies. See WPF SDK for developer articles and documentation on WPF.
Windows Communication Foundation (WCF), formerly code-named Indigo; a service-oriented messaging system which allows programs to interoperate locally or remotely similar to web services.
Windows Workflow Foundation (WF) allows for building of task automation and integrated transactions using workflows.
Windows CardSpace, formerly code-named InfoCard; a software component which securely stores a person's digital identities and provides a unified interface for choosing the identity for a particular transaction, such as logging in to a website.
.NET Framework 3.5
Version 3.5 of the .NET Framework was released on 19 November 2007, but it is not included with Windows Server 2008. As with .NET Framework 3.0, version 3.5 uses the CLR of version 2.0. In addition, it installs .NET Framework 2.0 SP1, .NET Framework 2.0 SP2 (with 3.5 SP1) and .NET Framework 3.0 SP1, which adds some methods and properties to the BCL classes in version 2.0 which are required for version 3.5 features such as Language Integrated Query (LINQ). These changes do not affect applications written for version 2.0, however As with previous versions, a new .NET Compact Framework 3.5 was released in tandem with this update in order to provide support for additional features on Windows Mobile and Windows Embedded CE devices.
The source code of the Base Class Library in this version has been partially released (for debugging reference only) under the Microsoft Reference Source License.
Changes since version 3.0
New language features in C# 3.0 and VB.NET 9.0 compiler
Adds support for expression trees and lambda methods
Extension methods
Expression trees to represent high-level source code at runtime
Anonymous types with static type inference
Language Integrated Query (LINQ) along with its various providers
LINQ to Objects
LINQ to XML
LINQ to SQL
Paging support for ADO.NET
ADO.NET synchronization API to synchronize local caches and server side datastores
Asynchronous network I/O API
Peer-to-peer networking stack, including a managed PNRP resolver
Managed wrappers for Windows Management Instrumentation and Active Directory APIs
Enhanced WCF and WF runtimes, which let WCF work with POX and JSON data, and also expose WF workflows as WCF services.WCF services can be made stateful using the WF persistence model.
Support for HTTP pipelining and syndication feeds.
ASP.NET AJAX is included
New System.CodeDom namespace.

Difference between ArrayList and Generic List

noreply@blogger.com (Kumar S) — Tue, 30 Nov 2010 11:41:00 +0530

Here we will see some important differences for the collections ArrayList() and Generic List

ArrayList:

The namespace for ArrayList is System.Collections

How to create ArrayList?

ArrayList stringArrayList = new ArrayList();
Here we dont need to specify object type arraylist going to contain,store different type of objects or items

In ArrayList each item is stored as an Object so while reteriving we can get object only.

It is like Array of Objects.

Generic List:

The namespace for Generic List is System.Collections.Generic

How to create a List?

List stringList = new List();
i.e.

List<type> nameOfList = new List<type>();

type means object type which List<T> going to hold.

In List<T> , it can hold or contain only type of object which is mentioned while initialising the List<T>
Just like in above example stringList will only contain object of type string, the type supplied as generic parameter.

It is newly added in .Net 2.0 and onwards, processing will be fast and no need of explicit casting.

Let us see one example.

string first = “First String”;

string second = “Second String”;

int firstInt = 1;

int secondInt = 2;

ArrayList stringArrayList = new ArrayList(); // No need to specify the object type,can store anything.

stringArrayList.Add(first); // string type

stringArrayList.Add(second); // string type

stringArrayList.Add(firstInt); // Can contain any type so no problem in storing int

List stringList = new List(); // Need to specify the object type, will contain only string types.

stringList.Add(first);

stringList.Add(second);

See this sample

stringList.Add(firstInt); // adding int in string type List.

we will get the exceptions below as List need to contain only string types. others are not allowed.

1) ‘The best overloaded method match for ‘System.Collections.Generic.List.Add(string)’ has some invalid arguments’

2) ‘Argument ’1′: cannot convert from ‘int’ to ‘string’

See another Sample

string abcd = stringArrayList[1];

Suppose if we try to get an ArrayList item without using the casting then we can get following exception, as arraylist contain Objects only we need to cast as pre our requirments.

We will get Exception –

‘Cannot implicitly convert type ‘object’ to ‘string’. An explicit conversion exists (are you missing a cast?)’

We can avoid it as

string abcd = stringArrayList[1].ToString(); // Needs casting ,memory overhead.

IEnumerable vs. IQueryable

noreply@blogger.com (Kumar S) — Mon, 10 May 2010 17:20:00 +0530

IQueryable

• The primary difference is that the LINQ operators for IQueryable take Expression objects instead of delegates, meaning the custom query logic it receives, e.g., a predicate or value selector, is in the form of an expression tree instead of a delegate to a method.
• IQueryable extends the IEnumerable interface, so anything you can do with a "plain" IEnumerable, you can also do with an IQueryable.
• The expression can simply be a constant expression of the object itself or a more complex tree of a composed set of query operators and operands. The query provider's IQueryProvider.Execute() or IQueryProvider.CreateQuery() methods are called with an Expression passed to it, and then either a query result or another IQueryable is returned, respectively.
• IQueryable allows for out-of memory things like a remote data source, such as a database or web service.
• IQueryable is a very powerful feature that enables a variety of interesting deferred execution scenarios (like paging and composition based queries).

IEnumerable

• IEnumerable doesn’t have the concept of moving between items, it is a forward only collection. It’s very minimalistic; something that most any data source can provide. Using only this minimal functionality, LINQ can provide all of these great operators.
• IEnumerable is great for working with sequences that are iterated in-memory.
• IEnumerable just has a GetEnumerator() method that returns an Enumerator for which you can call its MoveNext() method to iterate through a sequence of T

LINQ Query Syntax versus Method Syntax

noreply@blogger.com (Kumar S) — Mon, 10 May 2010 17:17:00 +0530

Most queries in the introductory LINQ documentation are written as query expressions by using the declarative query syntax introduced in C# 3.0. However, the .NET common language runtime (CLR) has no notion of query syntax in itself. Therefore, at compile time, query expressions are translated to something that the CLR does understand: method calls. These methods are called the standard query operators, and they have names such as Where, Select, GroupBy, Join, Max, Average, and so on. You can call them directly by using method syntax instead of query syntax.
The following example shows a simple query expression and the semantically equivalent query written as a method-based query.

class QueryVMethodSyntax
{
static void Main()
{
int[] numbers = { 5, 10, 8, 3, 6, 12};

//Query syntax:
IEnumerable numQuery1 =
from num in numbers
where num % 2 == 0
orderby num
select num;

//Method syntax:
IEnumerable numQuery2 = numbers.Where(num => num % 2 == 0).OrderBy(n => n);

foreach (int i in numQuery1)
{
Console.Write(i + " ");
}
Console.WriteLine(System.Environment.NewLine);
foreach (int i in numQuery2)
{
Console.Write(i + " ");
}

// Keep the console open in debug mode.
Console.WriteLine(System.Environment.NewLine);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
/*
Output:
6 8 10 12
6 8 10 12
*/

The output from the two examples is identical. You can see that the type of the query variable is the same in both forms: IEnumerable<(Of <(T>)>).
To understand the method-based query, let's examine it more closely. On the right side of the expression, notice that the where clause is now expressed as an instance method on the numbers object, which as you will recall has a type of IEnumerable. If you are familiar with the generic IEnumerable<(Of <(T>)>) interface, you know that it does not have a Where method. However, if you invoke the IntelliSense completion list in the Visual Studio IDE, you will see not only a Where method, but many other methods such as Select, SelectMany, Join, and Orderby. These are all the standard query operators.
Although it looks as if IEnumerable<(Of <(T>)>) has been redefined to include these additional methods, in fact this is not the case. The standard query operators are implemented as a new kind of method called extension methods. Extensions methods "extend" an existing type; they can be called as if they were instance methods on the type. The standard query operators extend IEnumerable<(Of <(T>)>) and that is why you can write numbers.Where(...).

LINQ - Mixed Query and Method Syntax

noreply@blogger.com (Kumar S) — Mon, 10 May 2010 17:14:00 +0530

This example shows how to use method syntax on the results of a query clause. Just enclose the query expression in parentheses, and then apply the dot operator and call the method. In the following example, query #7 returns a count of the numbers whose value is between 3 and 7. In general, however, it is better to use a second variable to store the result of the method call. In this manner, the query is less likely to be confused with the results of the query.

// Query #7.

// Using a query expression with method syntax
int numCount1 =
(from num in numbers1
where num < 3 || num > 7
select num).Count();

// Better: Create a new variable to store
// the method call result
IEnumerable numbersQuery =
from num in numbers1
where num < 3 || num > 7
select num;

int numCount2 = numbersQuery.Count();

Because Query #7 returns a single value and not a collection, the query executes immediately.
The previous query can be written by using implicit typing with var, as follows:

var numCount = (from num in numbers...
It can be written in method syntax as follows:
var numCount = numbers.Where(n => n < 3 || n > 7).Count();
It can be written by using explicit typing, as follows:
int numCount = numbers.Where(n => n < 3 || n > 7).Count();

LINQ Queries - Method Syntax

noreply@blogger.com (Kumar S) — Mon, 10 May 2010 17:11:00 +0530

Some query operations must be expressed as a method call. The most common such methods are those that return singleton numeric values, such as Sum, Max, Min, Average, and so on. These methods must always be called last in any query because they represent only a single value and cannot serve as the source for an additional query operation. The following example shows a method call in a query expression:

List numbers1 = new List() { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
List numbers2 = new List() { 15, 14, 11, 13, 19, 18, 16, 17, 12, 10 };
// Query #4.
double average = numbers1.Average();

// Query #5.
IEnumerable concatenationQuery = numbers1.Concat(numbers2);

If the method has parameters, these are provided in the form of a lambda expression, as shown in the following example:

// Query #6.
IEnumerable largeNumbersQuery = numbers2.Where(c => c > 15);

In the previous queries, only Query #4 executes immediately. This is because it returns a single value, and not a generic IEnumerable<(Of <(T>)>) collection. The method itself has to use foreach in order to compute its value.
Each of the previous queries can be written by using implicit typing with var, as shown in the following example:

// var is used for convenience in these queries
var average = numbers1.Average();
var concatenationQuery = numbers1.Concat(numbers2);
var largeNumbersQuery = numbers2.Where(c => c > 15);

LINQ Queries - Query Syntax

noreply@blogger.com (Kumar S) — Mon, 10 May 2010 17:03:00 +0530

The recommended way to write most queries is to use query syntax to create query expressions. The following example shows three query expressions. The first query expression demonstrates how to filter or restrict results by applying conditions with a where clause. It returns all elements in the source sequence whose values are greater than 7 or less than 3. The second expression demonstrates how to order the returned results. The third expression demonstrates how to group results according to a key. This query returns two groups based on the first letter of the word.

// Query #1.
List numbers = new List() { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };

// The query variable can also be implicitly typed by using var
IEnumerable filteringQuery =
from num in numbers
where num < 3 || num > 7
select num;

// Query #2.
IEnumerable orderingQuery =
from num in numbers
where num < 3 || num > 7
orderby num ascending
select num;

// Query #3.
string[] groupingQuery = { "carrots", "cabbage", "broccoli", "beans", "barley" };
IEnumerable<IGrouping> queryFoodGroups =
from item in groupingQuery
group item by item[0];

Note that the type of the queries is IEnumerable<(Of <(T>)>). All of these queries could be written using var as shown in the following example:
var query = from num in numbers...
In each previous example, the queries do not actually execute until you iterate over the query variable in a foreach statement.

How to: Write LINQ Queries in C#

noreply@blogger.com (Kumar S) — Mon, 10 May 2010 16:59:00 +0530

The three ways in which you can write a LINQ query in C#:

1. Use query syntax. Please refer this post.
2. Use method syntax. Please refer this post.
3. Use a combination of query syntax and method syntax. Please refer this post.

WCF Message Security

noreply@blogger.com (Kumar S) — Thu, 6 May 2010 11:31:00 +0530

When using message security, the user credentials and claims are encapsulated in every message using the WS-Security specification to secure messages. This option gives the most flexibility from an authentication perspective. You can use any type of security credentials you want, largely independent of transport, as long as both the client and the service agree.

Use message security for the following scenarios:

• You are sending a message to a WCF service, and the message is likely to be forwarded to other WCF services or may be routed through intermediate systems.
• Your WCF clients are accessing the WCF service over the Internet, it’s possible that other intermediate systems may be used in between, and security is your top consideration.

Using message security has following advantages:

• It provides end-to-end security. Because message security directly encrypts and signs the message, having intermediaries does not break the security.
• It allows partial or selective message encryption and signing, thus improving overall application performance.
• Message security is transport-independent and can be used with any transport protocol.
• It supports a wide set of credentials and claims, including issue token, which enables federated security.

Using message security has following disadvantages:

• This option may reduce performance compared to transport security because each individual message is encrypted and signed.
• It does not support interoperability with older ASP.NET Web Services (ASMX) clients because it requires both the client and service to support WS-Security specifications.

WCF Transport Security

noreply@blogger.com (Kumar S) — Thu, 6 May 2010 11:26:00 +0530

When using transport security, the user credentials and claims are passed using the transport layer. In other words, user credentials are transport-dependent, which allows fewer authentication options compared to message security. Each transport protocol (TCP, IPC, MSMQ, or HTTP) has its own mechanism for passing credentials and handling message protection. The most common approach for this is to use Secure Sockets Layer (SSL) for encrypting and signing the contents of the packets sent over Secure HTTP (HTTPS).

Transport security is used to provide point-to-point security between the two endpoints (service and client). If there are intermediary systems between the client and the service, each intermediate point must forward the message over a new SSL connection.

Use transport security for the following scenarios:

• You are sending a message directly from your application to a WCF service and the message will not be routed through intermediate systems.
• You have both the service and the client in an intranet.

Using transport security has the following advantages:

• It provides interoperability, meaning that communicating parties do not need to understand the WS-Security specification.
• It may result in better performance.
• Hardware accelerators can be used to further improve performance.

Using transport security has the following disadvantages:

• Because security is applied on a point-to-point basis, there is no provision for multiple hops or routing through intermediate application nodes.
• It supports a limited set of credentials and claims compared to message security.
• It is transport-dependent upon the underlying platform, transport mechanism, and security service provider such as NTLM or Kerberos

WCF Transfer Security

noreply@blogger.com (Kumar S) — Thu, 6 May 2010 11:04:00 +0530

After selecting a binding, you can decide which type of transfer security, otherwise known as security mode, to use for your WCF service. You can provide security on the transport level or the message level. Each option has its own advantages and disadvantages. For instance, transport security secures the entire communication channel (e.g., by using SSL) and therefore only supports point-to-point communication over a single transport. Message security protects each message individually and therefore supports multipoint communication, multiple transports, or even partial message encryption if necessary. Most scenarios are best supported by using transport security. The following security modes are available across the standard bindings.

Mode	Description
None	No security is provided; all information is passed in clear text.
Transport	Mutual authentication and message protection are provided at the transport level.
Message	Mutual authentication and message protection are provided at the message level
Both	Mutual authentication and message protection are provided at both the transport and message levels. This is far more than is necessary for most scenarios.
TransportWithMessageCredential	Client authentication is provided at the message level, and message protection and service authentication are provided at the transport level.
TransportCredentialOnly	Mutual authentication is provided at the transport level; no message protection is provided. This option is available only on basicHttpBinding.

WCF Bindings and Behaviors

noreply@blogger.com (Kumar S) — Thu, 6 May 2010 10:40:00 +0530

When you create an overall security policy – for example, transfer security with authentication and authorization for your services – you can use bindings and behaviors to configure the required settings.

Bindings and behaviors are described as follows:

• Bindings. Bindings control the security mode, client credential type, and other security settings.

• Behaviors. Service behaviors control impersonation levels, how client credentials are authenticated and authorized, and service credentials.

You can configure bindings and behaviors, or you can program against the object model. Your binding selection determines the available security options for WCF. The following table summarizes the most commonly used bindings in WCF.

Binding	Common scenarios	Default security settings
basicHttpBinding	Legacy Web service protocols	No security
netTcpBinding	Binary TCP communication between machines	Transport security with Windows authentication
wsFederationHttpBinding	Federated security scenarios	Message security with issue token authentication
wsHttpBinding	Leveraging security standards (WS-Security)	Message security with Windows authentication

By default, every WCF binding will provide transfer security and user authentication except for BasicHttpBinding. If necessary, you can change the security settings to suit your scenario requirements.

WCF Key Security Features and Scope of WCF Security

noreply@blogger.com (Kumar S) — Wed, 5 May 2010 16:03:00 +0530

Any Service-Oriented Architecture (SOA) needs to support security features that provide auditing, authentication, authorization, confidentiality, and integrity for the messages exchanged between the client and the service. Windows Communication Foundation (WCF) provides these security features by default for any application that is built on top of the WCF framework.

Key security features include:

• Auditing - Effective auditing and logging is the key to non-repudiation. Non-repudiation guarantees that a user cannot deny performing an operation or initiating a transaction.

• Authentication - Authentication allows you to confidently identify the clients of your service. These might be end users, other services, processes, or computers. WCF supports mutual authentication, which identifies both the client and the service in tandem, to help in preventing man-in-the-middle attacks

• Authorization - Authorization determines what system resources and operations can be accessed by the authenticated user. This allows you to grant specific application and resource permissions for authenticated users.

• Confidentiality - Confidentiality, also referred to as privacy, is the process of making sure that data remains private and confidential, and that it cannot be viewed by unauthorized users. Encryption is frequently used to enforce confidentiality. Privacy is a key concern, particularly for data / messages passed across networks.

• Integrity - Integrity is the guarantee that data is protected from accidental or deliberate modification. Like privacy, integrity is a key concern, particularly for data / messages passed across networks. Integrity for data in transit is typically provided by using hashing techniques and message authentication codes.

Scope of WCF Security

The above fundamental security features are covered in the following WCF features:

• Transfer security. Responsible for providing message confidentiality, data integrity, and authentication of communicating parties.

• Authorization. Responsible for providing a framework for making authorization decisions.

• Auditing. Responsible for logging security-related events to the audit log.

WCF Security

noreply@blogger.com (Kumar S) — Wed, 5 May 2010 15:59:00 +0530

Securing your WCF service requires knowledge of the WCF security features related to auditing and logging, authentication, authorization, confidentiality, and integrity. Use behaviors and bindings to configure security for your WCF service. Bindings and behaviors allow you to configure transfer security, authentication, authorization, impersonation, and delegation as well as auditing and logging. Transfer security is the means by which WCF secures messages over the network. WCF gives you two options to implement transfer security: transport security and message security. Transport security secures the entire communication channel (e.g., by using SSL), while message security secures each message individually. WCF supports a variety of authentication options including username, Windows, and certificate authentication. Depending on your authentication method, you can choose to authorize your users by using role-based security or resource-based security. Use WCF impersonation and delegation to flow the identity and security context of your client-side original caller to the back end in order to support a granular authorization approach.

Structs in C#

noreply@blogger.com (Kumar S) — Tue, 20 Apr 2010 17:02:00 +0530

• Within a struct declaration, fields cannot be initialized unless they are declared as const or static.
• A struct may not declare a default constructor (a constructor without parameters) or a destructor.
• Structs are copied on assignment. When a struct is assigned to a new variable, all the data is copied, and any modification to the new copy does not change the data for the original copy. This is important to remember when working with collections of value types such as Dictionary.
• Structs are value types and classes are reference types.
• Unlike classes, structs can be instantiated without using a new operator.
• Structs can declare constructors that have parameters.
• A struct cannot inherit from another struct or class, and it cannot be the base of a class. All structs inherit directly from System.ValueType, which inherits from System.Object.
• A struct can implement interfaces.
• A struct can be used as a nullable type and can be assigned a null value.

Joins in LINQ Query Expressions

noreply@blogger.com (Kumar S) — Wed, 7 Apr 2010 17:44:00 +0530

As we discussed in the prevoius post a join clause takes two source sequences as input. The elements in each sequence must either be or contain a property that can be compared to a corresponding property in the other sequence. The join clause compares the specified keys for equality by using the special equals keyword. All joins performed by the join clause are equijoins. The shape of the output of a join clause depends on the specific type of join you are performing. The following are three most common join types:

1. Inner join

The following example shows a simple inner equijoin. This query produces a flat sequence of “product name / category” pairs. The same category string will appear in multiple elements. If an element from categories has no matching products, that category will not appear in the results.

var innerJoinQuery =
from category in categories
join prod in products on category.ID equals prod.CategoryID
select new { ProductName = prod.Name, Category = category.Name }; //produces flat sequence

2. Group join

A join clause with an into expression is called a group join.

var innerGroupJoinQuery =
from category in categories
join prod in products on category.ID equals prod.CategoryID into prodGroup
select new { CategoryName = category.Name, Products = prodGroup };

A group join produces a hierarchical result sequence, which associates elements in the left source sequence with one or more matching elements in the right side source sequence. A group join has no equivalent in relational terms; it is essentially a sequence of object arrays.

If no elements from the right source sequence are found to match an element in the left source, the join clause will produce an empty array for that item. Therefore, the group join is still basically an inner-equijoin except that the result sequence is organized into groups.

If you just select the results of a group join, you can access the items, but you cannot identify the key that they match on. Therefore, it is generally more useful to select the results of the group join into a new type that also has the key name, as shown in the previous example.

You can also, of course, use the result of a group join as the generator of another subquery:

var innerGroupJoinQuery2 =
from category in categories
join prod in products on category.ID equals prod.CategoryID into prodGroup
from prod2 in prodGroup
where prod2.UnitPrice > 2.50M
select prod2;

3. Left outer join

In a left outer join, all the elements in the left source sequence are returned, even if no matching elements are in the right sequence. To perform a left outer join in LINQ, use the DefaultIfEmpty method in combination with a group join to specify a default right-side element to produce if a left-side element has no matches. You can use null as the default value for any reference type, or you can specify a user-defined default type. In the following example, a user-defined default type is shown:

var leftOuterJoinQuery =
from category in categories
join prod in products on category.ID equals prod.CategoryID into prodGroup
from item in prodGroup.DefaultIfEmpty(new Product{Name = String.Empty, CategoryID = 0})
select new { CatName = category.Name, ProdName = item.Name };

from: A query expression must begin with a from clause. Additionally, a query expression can contain sub-queries, which also begin with a from clause. The from clause specifies the following:

o The data source on which the query or sub-query will be run.
o A local range variable that represents each element in the source sequence.
Both the range variable and the data source are strongly typed. The data source referenced in the from clause must have a type of IEnumerable, IEnumerable<(Of <(T>)>), or a derived type such as IQueryable<(Of <(T>)>).

let: In a query expression, it is sometimes useful to store the result of a sub-expression in order to use it in subsequent clauses. You can do this with the let keyword, which creates a new range variable and initializes it with the result of the expression you supply. Once initialized with a value, the range variable cannot be used to store another value. However, if the range variable holds a queryable type, it can be queried.

In the following example let is used in two ways:
o To create an enumerable type that can itself be queried.
o To enable the query to call ToLower only one time on the range variable word. Without using let, you would have to call ToLower in each predicate in the where clause.

class LetSample1
{
static void Main()
{
string[] strings =
{
"A penny saved is a penny earned.",
"The early bird catches the worm.",
"The pen is mightier than the sword."
};

// Split the sentence into an array of words
// and select those whose first letter is a vowel.
var earlyBirdQuery =
from sentence in strings
let words = sentence.Split(' ')
from word in words
let w = word.ToLower()
where w[0] == 'a' || w[0] == 'e'
|| w[0] == 'i' || w[0] == 'o'
|| w[0] == 'u'
select word;

// Execute the query.
foreach (var v in earlyBirdQuery)
{
Console.WriteLine("\"{0}\" starts with a vowel", v);
}

// Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
"A" starts with a vowel
"is" starts with a vowel
"a" starts with a vowel
"earned." starts with a vowel
"early" starts with a vowel
"is" starts with a vowel
*/