How Deferred Execution Works

Query operators provide deferred execution by returning decorator sequences.

Calling where merely consts the decorator wrapper sqequence, holding a reference to the input sequence, the lambda expression and any other arguments supplied.
---- c# 3.0 In a Nutshell

When query operator acutally querying the array through the where decorator

LINQ Comprehension Queries

Besides Lamda Express in Queries, c# provides a syntactic shortcut for writing LINQ queries : Comprehension Query, this statement always starts with a from clause and ends with eithere a select or group clause.

Extention Methods(C# 3.0)

Extension Methods : extend new methods without altering the definition of the original type. the extension method must be a static method of a static class, where the this midifier is applied to the first parameter.



class Program
{
static void Main(string[] args)
{
Console.WriteLine("foo".IsCapitalized());
Console.ReadLine();
}
}
public static class StringHelper
{
public static bool IsCapitalized(this string s)
{
if (string.IsNullOrEmpty(s)) return false;
return char.IsUpper(s[0]);
}
}

Nullable types

sting s = null;

int? i = null // ok nullable type


translates to:


Nullable i = new Nullable()

Anonymous Methods

To write an anonymous method, include the delegate keyword followed by a parameter declarationa dn then a method body:

First create a delegate Transformer:

delegate int Transformer (int i);

• Transformer square = delegate(int x){return x * x;};
• this statement can be simplied to :
• Transformer square = (int x ) => {return x * x;}
• OR
• Transformer squere = x => x* x;

call square:

Console.WriteLine(square(5));

partial classes and parital methods (C# 3.0)

Partial classes can't have the same members and constructor can't have the exactly same arguments. And must reside in the same assembly.

partial class may contain partial methods, the partial method must be void and are implicitly private.

3.0 Object Initializers

Simply the process to initialize:



public class Bunny
{
public string Name;
public bool LikeCarrots;
public Bunny(string n)
{
this.Name = n;
}
}



Bunny b1 = new Bunny { Name = "stupid", LikeCarrots = false };
Bunny b2 = new Bunny("foo") { LikeCarrots = true };

Passing by value vs Passing by ref

Passing by Values has two situations , it's by default (no parameter modifider)

1) passing by value type

2)passing by reference type

Passing by Reference has two situations one param modifier is ref, another is out

Stack vs Heap

Stock is a block of memory for storing local variable. The storage automatically grows and shrinks as a function is entered and exited.

Heap is a block of memory in which objects reside.Whenever a new object is created, it is allocated on the heap, and reference to that object is returned. During a program's execution, the heap starts filling up as new objects are created. The runtime has a garbage collector that periodically deallocates objects from the heap, so your computer does not runt out of memory. An object is eligible for dealocation as soon as nothing references it.

------ C#3.0 In A Nutshell by Joseph & Ben

Best statement value types vs reference types

Value types comprise most build-in types(all numeric types, the char type and bool type), custom struct and enum types

Reference typs comprose all class, array, string delegate and inferface types.

Value types content is simply a value,
Reference type comtains Reference and object, when assigning a reference type variable copies the reference, not the object instance. This allows multiple variables to refer to the same object.
Reference type can be assigned null, value type can't.
Value type takes exactly the sum of memory of their fields takes.
Reference type takes object plus and reference memory, object meeory takes the sum of fields memory plus Oject metadata memory.

Stream XML Fragments from an XmlReader

http://msdn2.microsoft.com/en-us/library/bb387035.aspx

yield return iterator

IL creates a state engine to retain their state and don't have to go through the pain of maintaining state in coding:


private static IEnumerable GetData()
{
for (int i=0; i <5; i++)
yield return i ;
}

when call GetData() function, will receive a new incremented integer.

Load xml into XElement and loop through xElement

string url = Server.MapPath("Books.xml");
XElement x = XElement.Load(url, LoadOptions.PreserveWhitespace);
IEnumerable<xelement> authors = x.Descendants("author");
foreach (XElement author in authors)
{
Response.Write(author.Value + "<br />");
}
Here is XML file :

<?xml version="1.0" encoding="utf-8" ?><books><book><title>LINQ in Action</title><author>Fabrice Marguerie</author><author>Steve Eichert</author><author>Jim Wooley</author><publisher>Manning</publisher></book></books>

LINQ to XML

1) functional construction:

2) context-free XML creation

3)simplified names


RSS --- Really Simple Syndication--- a format for distributing and gathering content from sources across the web, including newspapers, magaxines, and blogs:

XML API class hierarchy:
XObject --> XNode --> XContainer-->
XDocument vs XElement

XDocment is complete xml doc.

Partial Classes in ASP.NET

Partial classes split class into multiple physical files. Compiler treats all these partial classes as a single type.
partial keyword applies to classes, structs and interfaces but not enums

pessimistic concurrency vs optimistic concurrency

locks another user to make changes until the record is released --- pessimistic concurrency
allow user to make changes to the same record -- optimistic concurrency

My Practices coding

namespace LINQtoSQL
{
public partial class PublisherMgr : System.Web.UI.Page
{
Table tbPublisher;
DataContext publisherDataContext;
protected void Page_Load(object sender, EventArgs e)
{
SqlConnection conn = new SqlConnection(DataAccess.GetAdventureConnection());
publisherDataContext = new DataContext(conn);
tbPublisher = publisherDataContext.GetTable();
gvPublisher.DataSource = from pub in tbPublisher orderby pub.PublisherName select pub;
gvPublisher.DataBind();
}
protected void btnSave_Click(object sender, EventArgs e)
{
Publisher newPub = new Publisher();
newPub.PublisherId = Guid.NewGuid();
newPub.PublisherName = txtPublisher.Text;
tbPublisher.InsertOnSubmit(newPub);
publisherDataContext.SubmitChanges();
gvPublisher.DataSource = from pub in tbPublisher orderby pub.PublisherName select pub;
gvPublisher.DataBind();
}
}
}



namespace LINQtoSQL
{
static public class DataAccess
{
static public IQueryable GetDataAccess()
{
string connectionString = ConfigurationSettings.AppSettings["connectionString"].ToString();
SqlConnection connection = new SqlConnection(connectionString);
DataContext dataContext = new DataContext(connection);
IQueryable books = from book in dataContext.GetTable() select book;
return books;
}
static public string GetAdventureConnection()
{
return ConfigurationSettings.AppSettings["connectionString"].ToString();
}
static public string GetNorthwindConnection()
{
return ConfigurationSettings.AppSettings["connectionStringNorthwind"].ToString();
}
}
}


namespace LINQtoSQL
{
[Table(Name="dbo.Book")]
public class Book
{
[Column(Name="BookId", IsPrimaryKey=true)]
public Guid BookId { get; set; }
[Column(Name="Isbn")]
public string Isbn { get; set; }
[Column (Name="Notes")]
public string Notes { get; set; }
[Column(Name="PageCount")]
public Int32 PageCount { get;set; }
[Column (Name="Price")]
public decimal Price {get;set;}
[Column (Name="PublicationDate")]
public DateTime PublicationDate { get; set; }
[Column (Name="Summary")]
public string Summary{get;set;}
[Column (Name="Title")]
public string Title{get;set;}
[Column (Name="SubjectId")]
public Guid SubjectId { get; set; }
[Column (Name="PublisherId")]
public Guid PublishId { get; set; }
}
[Table(Name = "dbo.Subject")]
public class Subject
{
[Column(Name="SubjectId",IsPrimaryKey=true)]
public Guid SubjectId { get; set; }
[Column(Name="Description")]
public string Description { get; set; }
}
[Table(Name = "dbo.Publisher")]
public class Publisher
{
[Column(Name="PublisherId", IsPrimaryKey=true)]
public Guid PublisherId { get; set; }
[Column(Name="PublisherName")]
public string PublisherName { get; set; }
}
}

Debug tool --- Query Visualizer tool

Download from:

http://weblogs.asp.net/scottgu/archive/2007/07/31/linq-to-sql-debug-visualizer.aspx

and copy SqlServerQueryVisualizer.dll paste to file://program/ Files\Microsoft Visual Studio 9.0\Common7\Packages\Debugger\Visualizers

restart VS 2008 , you are good to debug LINQ Expression

Standend query operators samples

Besides where, select, here are SelectMany, Selecting Indeces, Distinst...

SelectMany:

var authors = SampleData.Books.SelectMany(book => book.Authors);

equal expression:

var authors = from book in SampleData.Books
from author in book.Authors
select author.LastName

you can't write
var authors = from book in SampleData.Books SelectMany ........

select index:


var books = SampleData.Books
.Select((book, index) => new { index, book.Title })
.OrderBy(book => book.Title);
foreach (var bk in books)
{
Response.Write(bk.Title + bk.index);
}

Example Query expression & Operator

Which method you prefer???

string[] books =
{ "Funny Stories", "All your base are belong to us", "C# on Railjs", "Bonjour mon Amoue" };
// Operator:
GridView1.DataSource =
books
.Where(book => book.Length > 10)
.OrderBy(book => book)
.Select(book => book.ToUpper());
// query expression
GridView1.DataSource = from book in books where book.Length > 10 orderby book select book;
GridView1.DataBind();

Deferred query execution

The query operators is that they execute not when constructed but when ecumerated (in other words, when MoveNext is called on its enumerator)

LINQ sample:

var numbers = new List();
numbers.Add(1);
var query = from n in numbers select n * 10;
numbers.Add(10);
foreach (int i in query)
{
Console.WriteLine(i);
}
Console.ReadLine();


The number 10 is added into the query result, this is called lazy evalution or deferred.
This feature seperate the query construction from query execution

Iterator yield return sample code

using System.Collections.Generic;

protected void Page_Load(object sender, EventArgs e)
{
foreach (var v in OneTwoThree())
{
Response.Write(v);
}
}
private IEnumerable OneTwoThree()
{
Response.Write("return 1");
yield return 1;
Response.Write("return 2");
yield return 2;
Response.Write("return 3");
yield return 3;
}

IEnumerable two usage generic && non-generic

The non-generic type'System.Collections.IEnumerable' cannot be used with type arguments. error message: ask you add using System.Collections.Generic

LINQ Sample

var processes =
Process.GetProcesses().Where(process => process.WorkingSet64 > 20 * 1024 * 1024)
.OrderByDescending(process => process.WorkingSet64)
.Select(process => new { Id = process.Id, Name = process.ProcessName });

foreach (var obj in processes)
{
Response.Write(obj.Id +" & "+ obj.Name +"
");
}

Anonymous types

Sample code:
var v1 = new {FirstName ="Bin", LastName="Zeng" }

The conpilers consider anonymous types that is specified within the same program with properties of the same names and types in the same order to be the same type.

Linitations:

Write Extension methods

Extension Methods: allow us to add new methods to existing CLR type.

simple example:

string customerName ="you foo";
if(Customer.IsValid(customerName))
{}


now by adding extending methods
string customerName = "you foo";

if(custimerName.IsValid())
{}

Lambda Expressions

Lambda Expressions a writing anonymous methods:

IEnumerable <person> results = people.Where(p => p.LastName == "Zeng");

Convent to inline methods:

IEnumerable <Person> results = people.Where( delegate (Person p){return p.LastName = ="Zeng";}
) ;


IEnumerable<Person> advanceResults = people.Where(p => p.LastName == "Zeng")
.OrderBy(p => p.FirstName)
.Take(2);

Object and collection initializers

Object initializers:
var data = new ProcessData {Id = 123, Name ="CurrentProcess",Memory = 12345567};
Collectiopn initializers:
var digits = new List {0,1,2,3,4,5};

for example:
foreach (var process in Process.GetProcesses())
{

processes.Add(new ProcessData { Id = process.Id, Name = process.ProcessName, Memory = process.WorkingSet64 });
}


yeah yeah yeah so easy now !!!!!!!!!!!!!!!!!!!!!!

C# 3.0 Language enhancements

1) Auto-implemented properties: This feature allows 3.0 compiler that creates anonymous private variables to contain each of the values that the individual property will be using:

for example:

public Int Id {get;set;} none private int _id


2)Implicitly typed local variables:

for example:

var Processes = new List<ProcessData>();

before:
List Processes = new List<ProcessData>()

In this case we no longer have to write the types of local variables twice, The compiler infers the types automatically. This means that even though we use a simplified syntax, we still get alll the benefits fo strong types, such as compile-time validation and IntelliSense.