LINQ(LANGUAGE INTEGRATED QUERY)

What is Linq In Asp.net?

LINQ stands for Language-Integrated Query. This means we can use any relational or XML-specific features to our programming languages and runtime. It is a general approach query and provide facilities to the .NET Framework to access any kind of sources of information, not just relational or XML data. It’s a Language-Integrated Query to indicate that query is an integrated feature of the developer’s primary programming languages (for example, Visual C#, Visual Basic). Language-integrated query allows query expressions to benefit from the rich metadata, compile-time syntax checking, static typing and IntelliSense that was previously available only to imperative code.

The format of the query is more or less simillar to that of SQL. The Select, From, Where clauses are also used here with the same meaning but in different style/location/position.

For Example You Want to Select All Records From Employee Table

return from tbl_Emp in db.tbl_Emps
select tbl_Emp;
tbl_Emps is a Property Which is Automatically made by linq when You drag your table on Linq.dbml File.
I will Explain It With You A Simple Example How Can You Use to Linq In your Project or in web site.
Before It You need to know about it’s benifits and it’s working process.

LINQ has three major components:

  • LINQ to Objects
  • LINQ to ADO.NET, which includes
    • LINQ to DataSet (originally called LINQ over DataSet)
    • LINQ to Entities
    • LINQ to SQL (originally called DLinq)
  • LINQ to XML (originally called XLinq)

LINQ to Objects deals with in-memory data. Any class that implements the IEnumerable<T> interface (in theSystem.Collections.Generic namespace) can be queried with SQO.

SQO Means Standard Query Operators

LINQ to ADO.NET deals with data from external sources, basically anything ADO.NET can connect to. Any class that implements IEnumerable<T> or IQueryable<T> (in the System.Query namespace) can be queried with SQO.

LINQ to XML is a comprehensive API for in-memory XML programming. Like the rest of LINQ, it includes SQO, and it can also be used in concert with LINQ to ADO.NET, but its primary purpose is to unify and simplify the kinds of things that disparate XML tools, like XQuery, XPath, and XSLT, are typically used to do.

LINQ to Entities will bring LINQ to the ADO.NET Entity Framework, which combines an Entity Data Model with an extended version of SQL (eSQL) in yet another effort to address the data-object impedance issue. Since the Entity Framework is an ADO.NET 3.0 feature.

Benefits of LINQ:

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.

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.

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.

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.

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).

Performance in the general case doesn’t become an issue. SQL Server optimizes queries quite well these days, just like stored procs.  Of course, there are still cases where stored procs 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

Built-in security. One reason I preferred stored procs 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.

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<T> 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<T> 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


Advertisements
This entry was posted in Uncategorized. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s