Dixin's Blog

Recently I am giving a series of talk on LINQ. the name “LINQ via C#” is copied from “CLR via C#”, one of my favorite books. Currently part 1 – 8 are finished, and the entire series should be 10 parts.

The contents are:

• Introducing LINQ 
  • What Is LINQ 
    • What is LINQ
    • First look of LINQ
      • LINQ to Objects
      • LINQ to SQL
      • LINQ to XML
      • LINQ to Wikipedia
    • LINQ via C#
  • LINQ Advantages Overview
    • Independency to data source
    • Strong typing
    • Query compilation
    • LINQ is far more than querying
  • LINQ Infrastructure
    • FCL and LINQ providers
    • Managed programming languages
    • CLR
• Understanding C# 3.0 Features
  • Automatic Property
  • Object Initializer And Collection Initializer
    • Object initializer
    • Collection initializer
  • Type Inference
    • Local variable type inference
    • var vs. explicit typing
    • var vs. dynamic
  • Anonymous Type
    • Compilation
    • Typing
    • Equality
  • Extension Method
    • Define an extension method for a class
    • Invocation
    • Compilation
    • Static method vs. instance method
    • Extension methods for other types
  • Lambda Expression
    • Compilation as anonymous method
      • Delegate
      • Anonymous delegate
      • Anonymous method
    • Truly anonymous method
    • The Func and Action generic delegate types
    • Compilation as expression tree
    • Type inference of lambda expression
    • Traverse expression tree
      • Built-in expression tree visitor
    • Translate expression tree
    • Convert anonymous method to expression tree
    • Convert expression tree to anonymous method
    • Convert expression tree into other stuff
  • Query Expression
    • Syntax
    • Compilation
    • Query expression vs. query method
  • Partial Method
    • From partial class to partial method
    • Compilation
• Understanding LINQ to Objects
  • Programming Paradigms
    • Declarative vs. imperative
    • Programming language paradigms
    • Declarative C#
  • Method Chaining
    • Normal interface design
    • Fluent interface design
    • Fluent extension methods
    • IEnumerable<T> Extensions
    • Method chaining in the real world
  • Query Methods
    • Restriction (Filter)
    • Projection (Mapping / binding)
    • Ordering
    • Join
    • Grouping
    • Aggregation (Folding)
    • Set
    • Other query methods
  • Iterator Pattern
    • IEnumerable and IEnumerable<T>
    • The foreach syntactic sugar
    • Special iterations
    • Prefer IEnumerable<T> than IEnumerable
    • LINQ query on IEnumerable
  • Implementing Iterator
    • Implement IEnumerable<T> and IEnumerator<T>
    • The yield syntactic sugar
    • Yield items of collection
  • Deferred Execution
    • Hot IEnumerable<T> vs. cold IEnumerable<T>
    • Eager execution vs. deferred execution
  • Query Methods Internals 
    • Eager-executing methods
    • Deferred-executing query methods
    • Optimization of query methods
  • The Design Of IEnumerable<T>
• Understanding LINQ to SQL
• Object-Relational Mapping
  • Create C# models from SQL schema
  • Implement the mapping
  • Customize the mapping
  • Work with model
    • Partial class
    • Partial method
    • INotifyPropertyChanging and INotifyPropertyChanged interfaces
  • Create SQL schema from C# models
• IQueryable<T>
  • IQueryable and IQueryable<T>
  • IQueryable and IQueryable<T> extensions
  • Table<T>
  • IEnumerable<T> extensions vs. IQueryable<T> extensions
• Expression Tree
  • Anonymous method vs. expression tree
  • Expression tree for LINQ to SQL
  • Translate expression tree to SQL
  • Expression tree types
  • Expression tree for DLR
  • Visualize expression tree while debugging
• Data Retrieving Via Query Methods
  • Supported and Unsupported query methods
  • Restriction
    • WHERE
    • AND / OR
    • LIKE
    • IN
    • IS / NOT / NULL
  • Projection
    • SELECT
    • Explicitly construct entity
    • CASE
  • Ordering
    • ORDER BY / ASC / DESC
  • Join
    • Natural join
    • INNER JOIN
    • OUTER JOIN
      • Association
    • CROSS JOIN
    • Self JOIN
  • Grouping and aggregation
    • GROUP BY / aggregate functions
    • HAVING
  • Set
    • DISTINCT
    • UNION
    • EXISTS
    • NOT EXISTS
  • Partitioning
    • TOP
    • ROW_NUMBER()
    • BETWEEN … AND
  • Concatenation
    • UNION ALL
  • Qualifiers
    • CASE / EXISTS
  • Other query methods
  • I have a dream
• Remote And Local Method Call
  • Remote method call
  • Local method call
  • Remote method recognition
• Working With Deferred Execution
  • Deferred execution and DataContext
  • Deferred execution and eager loading
    • DataLoadOptions.LoadWith()
    • DataLoadOptions.AssociateWith()
    • DataContext.DeferredLoadingEnabled
• Data Changing
• Object Identity
  • Identity of entity objects
  • Identity and DataContext
  • Identity of projected objects (non-entity objects)
• Track changes
• State change 
• Association change
• Change set
• Submit changes
• INSERT
• Work with IDENTITY column
• UPDATE
• DELETE
• Read-only DataContext
• Transaction
• Implementing transaction (BEGIN / COMMIT / ROLLBACK)
• Default transaction
• Custom transactions
• Concurrenct conflict
• Conflicts in concurrent data access
• Optimistic concurrency control
• Update check
• Time stamp
• Handle ChangeConflictException
• Merge changes to resolve conflict
• More about concurrency
• Implementing LINQ to SQL Provider
• The provider model
• Implement IQueryable<T> and IOrderedQueryable<T>
• Implement IQueryProvider
• Query method internals
• Deferred execution methods
• Eager execution methods
• Work together
• Query a collection of items (deferred execution)
• Query a single item (eager execution)
• Aggregate (eager execution)
• SQL translating and executing
• LINQ Providers
• Built-in IQueryable LINQ Providers
• LINQ to Everything
• LINQ to Objects provider
• Performance
• O/R mapping overhead
• Data retrieving overhead
• Compiled query
• Static SQL / stored procedures without translating
• Data changing overhead
• Bulk deleting / updating
• Query plan overhead
• .NET 3.5
• .NET 4.0
• Real World LINQ to SQL
• Understanding Parallel LINQ
• Functional C#
• Understanding Rx
• The Future of LINQ

This is very challenging because I do not know much about LINQ, or C#.

In this week, part 9 will be delivered, and part 10 for the next week. According to the feedback, I decided to write down the contents of the events.