LINQ via C # Series

LINQ via C #

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 shocould be 10 parts. the contents are: introducing LINQ what is LINQ

LINQ via C # events posters Design

10 LINQ via C # events have been held successfully. each event is a pure English speaking technical talk. I designed some posters for the events, with no enough time to design for each event. LINQ via C # Part 4 in Part 3, Lambda expression of C # is introduced...
Introducing LINQ (1) What is LINQ

[LINQ via C # series] This LINQ series is from my 10 parts of LINQ via C # talks. and the poster designs for the events are here. what is LINQ here is the roadmap. net and C #: Date. net Framework clr c # ide introduced features February 13th, 2002...
Introducing LINQ (2) advancements Overview

[LINQ via C # series] According to msdn: LINQ is one of Microsoft's most exciting, powerful new development technologies. independent to data source this sample mentioned in Part 1 is working on items in. net array: var Results = from number in source...
Understanding C #3.0 features (1) Automatic Property

[LINQ via C # series] as the fundamental of LINQ, this chapter will explain the new language features of C #3.0, all of which are syntactic sugars. this part is about the automatic property. in C #2.0 a property can be declared like this: public class...
Understanding C #3.0 features (2) object initializer and collection initializer

[LINQ via C # series] Take this person type as an example: public class person {public string name {Get; set;} public int age {Get; Set ;}} object initializer in C #2.0 we create an person instance and initialize it like this: person...

Understanding C #3.0 features (3) type inference

[LINQ via C # series] The "var" keyword has been introduced from the beginning. it is a new language feature called type inference in C #3.0. local variable type inference consider the local variable declaration and initialization: typename A = B; since...

Understanding C #3.0 features (4) Anonymous type

[LINQ via C # series] This feature provides a way to create an instance without declare the type: var mark = new {name = "mark", age = 18 }; since the type name is unknown at this time when writing code, this is called a anonymous type. compilation...

Understanding C #3.0 features (5) Extension Method

[LINQ via C # series] extension method is a fancy and powerful syntactic sugar in C #3.0. extension methods are very important when writing functional style C # code. define an extension method for a class when we define an extension method for a type...

Understanding C #3.0 features (6) Lambda expression

[LINQ via C # series] Lambda expression is another powerful syntactic sugar making C # functional. in this post, "Lambda expression" simply means "C # Lambda expression ". the native concept of Lambda expression will be introduced in the later lambda calculus...
Understanding C #3.0 features (7) query expression

[LINQ via C # series] This kind of code has been introduced again and again: var positive = from number in source where number> 0 orderby number descending select number. tostring (cultureinfo. invariantculture); this is called the query expression...

Understanding C #3.0 features (8) partial Method

[LINQ via C # series] The is a very simple feature. from partial class to partial method partial class is introduced by C #2.0. with the partial keyword, the definition of one type is able to be divided into several files. for example, if creating...
Understanding LINQ to objects (1) Programming Paradigm

[LINQ via C # series] declarative. imperative this post mentioned that LINQ introduced new programming constructs to C #. take a look at the samples in the beginning post: int [] source = new int [] {0,-5, 12,-54, 5,-67, 3, 6}; List <int...
Understanding LINQ to objects (2) method chaining

[LINQ via C # series] It is obvious the where (), orderby (), select () can be invoked fluently: int [] source = new int [] {0, 1,-2, 3, 24, 6, 3}; var Results = source. where (item => item> 0 & item <10 ). orderby (item => item )...
Understanding LINQ to objects (3) query methods

[LINQ via C # series] After understanding the programming paradigm and why LINQ query methods can be chaining, this post shows the details of LINQ query methods. methods like where (), orderby (), orderbydescending (), and select () are exhibited again...
Understanding LINQ to objects (4) iterator Pattern

[LINQ via C # series] According to Wikipedia: iterator pattern is a design pattern in which iterators are used to access the elements of an aggregate object sequentially without exposing its underlying representation. an iterator object encapsulates...
Understanding LINQ to objects (5) Implementing iterator

[LINQ via C # series] iterator pattern is the core pattern of LINQ to objects implementation. to filter, order, or project the data items of a data collection, of course the code need to go through the collection and figure out the results. the previous...

Understanding LINQ to objects (6) deferred execution

[LINQ via C # series] One post at the beginning of this series mentioned that deferred execution is a important advancement of LINQ. the following code show how is the execution deferred: ienumerable <int> source = enumerable. range (-2, 5 );...
Understanding LINQ to objects (7) query methods Internals

[LINQ via C # series] This post explains how are the LINQ to objects standard query methods implemented. once again, it will be exhibited that iterator pattern is the core pattern of LINQ to objects query. the first thing need to emphasize is, not all...

Understanding LINQ to objects (8) the design of ienumerable <t>

[LINQ via C # series] currently in. net, iterator pattern is implemented via ienumerable <t> and ienumerator <t> (or ienumerable and ienumerator): namespace system. colleich {// represents a collection which can be iterated. public interface...

Understanding LINQ to SQL (1) object-relational mapping

[LINQ via C # series] According to Wikipedia, object-relational mapping is: A Programming Technique for converting data between incompatible type systems in relational databases and object-oriented programming languages. this is the LINQ to SQL sample...
Understanding LINQ to SQL (2) iqueryable <t>

[LINQ via C # series] the core of LINQ to objects is ienumerable <t>: query methods are designed for ienumerable <t> as extension methods, like where (), select (), etc .; query methods are designed to be fluent, LINQ to objects queries can be...
Understanding LINQ to SQL (3) Expression Tree

[LINQ via C # series] In LINQ to objects, Lamda expressions are used everywhere as anonymous method, like where (): public static ienumerable <tsource> where <tsource> (this ienumerable <tsource> source, func <tsource, bool> predicate...
Understanding LINQ to SQL (4) Data retrieving via query methods

[LINQ via C # series] After understanding: Object Model generating from SQL Server schema query method chaining on iqueryable <t> SQL are translated from Expression Tree, which is required by iqueryable <t> now it is time to take a deeper look...
Understanding LINQ to SQL (5) remote and local method call

[LINQ via C # series] Since LINQ to SQL is translating C # methods into SQL, all the C # methods are required to make sense in SQL. according to msdn: A local method call is one that is executed within the object model. A remote method call is one that...

Understanding LINQ to SQL (6) working with deferred execution

[LINQ via C # series] similar with LINQ to objects, LINQ to SQL supports deferred execution when possible. for example: Using (northwinddatacontext database = new northwinddatacontext () {iqueryable <Category> source = database. categories ;...
Understanding LINQ to SQL (7) data changing

[LINQ via C # series] After understanding how to retrieve data with LINQ to SQL, now take a look at data change (create (insert)/update/delete ). object Identity when changing data queried by LINQ to SQL, one common confusion for LINQ to SQL beginners...
Understanding LINQ to SQL (8) Transaction

[LINQ via C # series] database data changing cannot be talked about without transactions. implementing transaction (begin/commit/rollback) the previous post has shown that, when invoking submitchanges (), the translated SQL (insert/update/delete...
Understanding LINQ to SQL (9) Concurrent conflict

[LINQ via C # series] conflicts are very common when concurrently accessing the same data. conflicts in Concurrent Data access the following code presents the concurrent conflict scenario: Action <int, Action <Category> updatecategory...
Understanding LINQ to SQL (10) Implementing LINQ to SQL provider

[LINQ via C # series] So far LINQ to SQL data CRUD (creating/retrieving/updating/deleting) has been explained. this post takes a deeper look at the internal implementation of LINQ to SQL query. the Provider Model unlike ienumerable/ienumerable <t>...
Understanding LINQ to SQL (11) Performance

[LINQ via C # series] LINQ to SQL has a lot of great features like strong typing query compilation deferred execution declarative paradigm Etc ., which are very productive. of course, these cannot be free, and one price is the performance. o/R Mapping...