آموزش linq (مقدماتی تا پیشرفته)

**ملیساا** · 13 اسفند، ۱۳۸۹

آموزش LINQ (مقدماتی تا پیشرفته)

نویسنده :: حسین احمدی

سطح :: مقدماتی - متوسط - پیشرفته

تمامی حقوق این نوشتار متعلق به سایت دات نت سورس بوده و استفاده از مطالب آن با ذکر نام نویسنده و منبع بلامانع است

در طول این مقاله قصد دارم تا شما را با Language Integrated Query یا LINQ و کاربردهای آن در زبان #C آشنا کنم. این ویژگی که به شما قابلیت اجرای کوئری های مختلف از داخل زبان #C را می دهد با ارئه نسخه 3 از زبان #C معرفی و تکمیل شد.

سر فصل های این مقاله به طور خلاصه به شرح زیر می باشد:

1. مقدمه ای بر LINQ و ویژگی های آن

2. ویژگی های جدید 3.0 #C

3. ساختار کوئری های LINQ و نحوه اجرای کوئری ها

4. آشنایی با عملگرهای استاندارد در کوئری های LINQ (بخش اول)

5. آشنایی با عملگرهای استاندارد در کوئری های LINQ (بخش دوم)

6. آشنایی با عملگرهای استاندارد در کوئری های LINQ (بخش سوم)

7. آشنایی با عملگرهای استاندارد در کوئری های LINQ (بخش چهارم)

8. LINQ to XML

9. LINQ to ADO.NET

9.1 آشنایی با مفاهیم Object Relational Mapping و LINQ to SQL

9.2 LINQ to Dataset

9.3 ADO.NET Entity Framework و LINQ to Entities

10. LINQ to Provider

11. پروژه عملی

تمامی سرفصل هایی که در بالا ذکر شد در طول این مقاله مورد بحث قرار میگیرند، ولی ممکن است که برخی از سرفصل ها تغییر کنند، برای مثال، بخش 4، به زیر بخش هایی مربوط به هر گروه از اپراتور ها تقسیم بشه. اما دسته بندی کلی مطالب به شکل بالا خواهد بود.

اما به طور خلاصه در هر کدام از این بخش ها چه مطالبی مطرح خواهد شد؟

1. در این بخش با ایجاد یک پروژه ساده مروری کوتاه بر یک کوئری ساده LINQ خواهیم داشت. همچنین با نحوه نوشتن کوئری ها قبل از ارائه LINQ آشنا خواهیم شد. در انتهای این بخش نیز با انواع Provider های موجود برای LINQ به طور خیلی خلاصه آشنا خواهیم شد.

2. بدلیل آنکه بسیاری از ویژگی های جدید معرفی شده در #C نسخه 3، جهت ایجاد کوئری های LINQ است، در این بخش با این ویژگی ها بیشتر آشنا خواهیم شد تا بعد ها بتوانیم از آنها در نوشتن کوئری های پیچیده تر استفاده کنیم.

3. در این بخش با ساختار کلی کوئری های LINQ و همچنین نحوه اجرای کوئری ها آشنا خواهیم شد.

4 الی 7. در این چهار بخش اپراتورهای استاندارد LINQ را مورد بررسی قرار خواهیم داد، برای مثال اپراتور های مربوطه برای فیل تر کردن اطلاعات، مرتب سازی، گروه بندی و ... . (به دلیل حجم زیاد این اپرداتور ها توضیحات مربوطه به چهار بخش تقسیم شده اند)

8. در این بخش ابتدا مقدمه کوتاهی بر نحوه استفاده از XML در #C خواهیم داشت و سپس با کوئری های LINQ to XML که قابلیت گرفتن کوئری از مستندات XML را به ما می دهد آشنا خواهیم شد.

9. می توان گفت که این بخش اصلی ترین بخش مورد بحث ما خواهد بود و بخش زیادی از مقاله به این بخش اختصاص خواهد داشت. در این بخش با قابلیت اجرای کوئری های LINQ بر روی بانک های SQL Server آشنا خواهیم شد.

9.1 در این بخش ابتدا با مفاهیم ORM آشنا خواهیم شد و سپس به مبحث LINQ to SQL خواهیم پرداخت که قابلیت اجرای کوئری ها بر روی بانک های SQL را به ما می دهد.

9.2 این قسمت به مفاهیم LINQ to Dataset اختصاص دارد. Dataset ها نمایشی از جداول بانک اطلاعاتی در حافظه هستند که می از کوئری های LINQ برای استخراج داده ها از Dataset ها هم استفاده کرد.

9.3 این بخش به ADO.NET Entity Framework اختصاص دارد، LINQ to Entites چیزی شبیه به LINQ to SQL است، با این تفاوت که به جای اینکه با لایه ای فیزیکی از داده سر و کار داشته باشد، از لایه ای مفهومی استفاده میکند که در این بخش به طور مفصل به این مورد خواهیم پرداخت.

10. بخش بعدی این مقاله به مبحث ایجاد Provider دلخواه برای کوئری های LINQ اختصاص دارد که یکی از مباحث پیچیده و پیشرفته LINQ می باشد. برای مثال در LINQ to SQL، کلمه SQL نشان دهنده Provider مربوطه برای کوئری های لینک است که از این Provider برای بانک های SQL Server استفاده می شود. در این بخش با نحوه ایجاد یک Provider دلخواه برای کوئری های LINQ آشنا خواهیم شد.

11. در بخش هشتم این مقاله به ایجاد یک پروژه عملی خواهیم پرداخت تا با ویژگی های کاربردی LINQ بهتر آشنا شویم. این پروژه بر اساس ساختار سه لایه پیاده سازی خواهد شد.

در طول مقاله فرض کردم که دوستان با مفاهیم زیر آشنایی دارند:

1. مقدمات زبان #C

2. برنامه نویسی شئ-گرا و مفاهیم آن

3. جنریک ها و کلاس های مجموعه ای

4. اینترفیس ها

5. طراحی و پیاده سازی بانک های اطلاعاتی در SQL Server

تمام کدهای ارائه شده در این مقاله با زبان #C نوشته می شوند. همچنین پس از اتمام مقاله نسخه PDF این مقاله به همراه کدهای #C در اختیار کاربران گل سایت دات نت سورس قرار خواهد گرفت.

موفق باشید.

**ملیساا** · 13 اسفند، ۱۳۸۹

بخش اول :: مقدمه ای بر LINQ و ویژگی های آن

بخش اول سری مقالات آموزش LINQ رو شروع میکنیم. در این بخش مقدمه ای بر LINQ خواهیم داشت و همچنین با قابلیت ها و توانایی های آن به صورت مختصر آشنا خواهیم شد.

شاید اولین سوالی که در ذهن هر یک از شما پیش بیاد این باشه که چه تعریفی می توان برای LINQ ارائه داد؟ چه کارهایی می توان با LINQ انجام داد؟ LINQ چه قابلیت هایی را در اختیار یک برنامه نویس قرار می دهد؟ به این سوالات می شود به این صورت جواب داد که LINQ شامل یکسری عملگرهای استاندارد است که به شما امکان می دهد بر روی انواع منابع داده در داخل زبان های سازگار با NET. مانند VB.NET یا #C کوئری هایی را نوشته و اجرا کنید. نام Language Integrated Query نیز به این دلیل انتخاب شده است که این کوئری ها داخل یک زبان برنامه نویسی مانند #C نوشته و اجرا می شوند. اما منابع داده ای که LINQ می تواند از آنها استفاده کند می تواند یک شئ ایجاد شده، یک فایل مستندات XML، یک بانک SQL Server و یا یک منبع دلخواه باشد. LINQ این قابلیت را دارد که با تمامی این منابع داده کار کند. علاوه بر استخراج و اجرای کوئری بر روی منابع داده نیز، بوسیله LINQ شما امکان تغییر و دستکاری یک منبع داده مانند یک بانک SQL Server را خواهید داشت. برای شروع با یک مثال کوچک شروع میکنیم:

فرض کنید که یک آرایه از نوع رشته داریم که یکسری نام را داخل آن قرار دادیم، حالا می خواهیم نام هایی که با حروف Mo شروع می شوند را جستجو کرده و به کاربر نمایش دهیم. برای اینکار باید یک آرایه ایجاد کرده و با یک دستور foreach بر روی تک تک عناصر آرایه عملیات مقایسه را انجام داده و نتیجه را به کاربر نشان دهیم:

کد: string[] names = { "Ali", "Hasan", "Mojtaba", "Hamid", "Morteza", "Reza", "Mohammad" };

foreach (string name in names)

if(name.StartsWith("Mo"))

Console.WriteLine(name);

با اجرای کد بالا تمامی نام هایی که با حروف Mo شروع می شوند در خروجی چاپ خواهند شد. اما اینکار را می توان با نوشتن یک کوئری بسیار ساده LINQ نیز انجام داد. قطعه کد زیر یک کوئری LINQ است که نام هایی که با Mo شروع می شوند را برای ما استخراج کرده و بر روی خروجی نمایش میدهد:

کد: string[] names = { "Ali", "Hasan", "Mojtaba", "Hamid", "Morteza", "Reza", "Mohammad" };

IEnumerable query = from n in names

where n.StartsWith("Mo")

select n;

foreach (string name in query)

Console.WriteLine(name);

در کد بالا دستوراتی وجود دارد که شاید با آنها نا آشنا باشید، اما نگران نباشید، در ادامه این مقاله با تک تک دستورات بالا و کاربرد هر یک آشنا خواهید شد. اما مهمترین چیزی که در دستورات بالا توجه یک برنامه نویس را به خود جلب میکند، شباهت ساختار کوئری نوشته شده با کوئری های SQL است. وقتی این کوئری اجرا می شود یک شئ از نوع اینترفیس

برای مشاهده این محتوا لطفاً ثبت نام کنید یا وارد شوید.

برای مقایسه عملگرهای LINQ با دستوراتی که قبلا" برای گرفتن کوئری ها از اشیاء استفاده می شد، به سراغ کلاس

کد: public class Person

{

public Person() { }

public Person(string firstName, string lastName, int age)

{

this.FirstName = firstName;

this.LastName = lastName;

this.Age = age;

}

public string FirstName { get; set; }

public string LastName { get; set; }

public int Age { get; set; }

public override string ToString()

{

return string.Format("FirstName: {0}\n{LastName: {1}\nAge: {2}", this.FirstName, this.LastName, this.Age);

}

کلاس بالا شامل سه فیلد، دو متد سازنده و متد override شده ToString است. در قدم بعدی ما یک لیست از اشیاء Person ایجاد میکنیم. (

کد: List persons = new List()

{

new Person() { FirstName = "Ali", LastName = "Jamali", Age = 42 },

new Person() { FirstName = "Hosein", LastName = "Ahmadi", Age = 23 },

new Person() { FirstName = "Mohamamd", LastName = "Sadeghi", Age = 17 },

new Person() { FirstName = "Reza", LastName = "Jamali", Age = 24 },

new Person() { FirstName = "Nima", LastName = "Karami", Age = 18 }

};

حال می خواهیم از مجموعه بالا تمامی افرادی که سنشان زیر 20 سال است را انتخاب کرده و در خروجی نمایش دهیم. کلاس

کد: List query = persons.FindAll(delegate(Person p) { return p.Age

foreach (Person person in query)

{

Console.WriteLine(person.ToString());

}

با اجرای کد بالا، متد FindAll شئ جدیدی از نوع

کد: IEnumerable query = from p in persons

where p.Age

select p;

foreach (Person person in query)

{

Console.WriteLine(person.ToString());

}

حال اگر بخواهیم شرط را تغییر بدهیم، بطوریکه علاوه بر سن افراد، نام آنها نیز مورد مقایسه قرار بگیرد کافیست کوئری خود را به صورت زیر تغییر دهیم:

کد: IEnumerable query = from p in persons

where p.Age

select p;

تا اینجای مقاله در کوئری هایی که نوشتیم تنها از عملگر where برای فیل تر سازی اطلاعات استفاده کردیم، در LINQ عملگرهای دیگری برای مرتب سازی نتایج، گروه بندی، ادغام و ... وجود دارد که در بخش های بعدی این مقاله به تفصیل در مورد آنها صحبت خواهیم کرد.

اما یکی از قابلیت های جالب در نوشتن کوئری های LINQ که در محیط Visual Studio 2008 به چشم می آید قابلیت IntelliSense در نوشتن Query ها است که نوشتن آن ها را بسیار آسان می کند. همانگونه که شما وقتی شئ ای از نوع string ایجاد می کنید و می توانید به وسیله IntelliSense به تمامی متدهای آن دسترسی داشته باشید، در کوئری های LINQ نیز عملیات به همین گونه است. شما در هنگام نوشتن کوئری ها به تمامی متد هایی که برای یک شئ تعریف شده است دسترسی دارید مانند متد StartWith کلاس string که در کوئری های بالا از آن استفاده کردیم.

اما در بالا گفتیم که LINQ قابلیت کار با چندین منبع داده را دارد که در زیر به طور خلاصه به بررسی هر یک از این منابع می پردازیم:

1. LINQ to Object: قابلیت اجرای کوئری ها بر روی اشیاء موجود در حافظه را برای ما فراهم میکند. مانند کوئری بالا که بر روی لیست افراد

2. LINQ to XML: قابلیت اجرای کوئری ها بر روی مستندات XML را فراهم میکند. همچنین عملگرهایی را در اختیار شما قرار میدهد که به XPath وابسته بوده و به شما این امکان را می دهد در داخل مستندات XML حرکت کرده و گره های مختلف را مورد پیمایش قرار دهید. LINQ to XML از ویژگی های فضای نام System.Xml و System.Xml.Linq استفاده میکند. مخصوصا" Reader و Writer برای اجرای کوئری های. دو کلاسی که نقش مهمی را در LINQ to XML بازی می کنند، کلاس های XElement و XAttribute هستند. XElement نمایش دهنده المان های XML هستند و LINQ to XML از آنها برای ایجاد گره های مربوط به المان و فیل تر سازی اطلاعات استفاده می کند. هر XElement شامل یکسری صفات برای هر المان XML است که این صفات بوسیله کلاس XAttribute مشخص می شوند. مثال های زیر خلاصه ای از نحوه استفاده از امکانات LINQ to XML را نشان می دهد:

کاربرد کلاس XElement را در کد زیر مشاهده میکنید:

کد: XElement x = new XElement(

"Person",

new XElement("FirstName", "Hosein"),

new XElement("LastName", "Ahmadi"));

حاصل قطعه کد بالا تگ های XML ایجاد شده زیر است:

کد:

Hosein

Ahmadi

حال اگر بخواهیم از XAttribute نیز در کلاس XElemet استفاده کنیم، کد بالا را به صورت زیر تغییر می دهیم:

کد: XElement x = new XElement("Person",

new XAttribute("PersonID","10"),

new XElement("FirstName", "Hosein"),

new XElement("LastName", "Ahmadi"));

حال المان ایجاد شده توسط کد بالا به صورت زیر خواهد بود:

کد:

Hosein

Ahmadi

اما قدرت اصلی LINQ to XML در این قسمت معلوم می شود که میتوانیم پارامتر های ورودی جهت قرار گیری در المان XML تعریف شده را توسط یک Query انتخاب کنیم:

کد: string[] names = { "Hosein", "Hamid", "Reza", "Mohammad", "Hadi" };

XElement x = new XElement("SelectedNames",

from n in names

where n.StartsWith("H")

select new XElement("Name", n));

المان ایجاد شده توسط کد بالا به صورت زیر است:

کد:

Hosein

Hamid

Hadi

در بخش های بعدی مقالات به طور مفصل در باره LINQ to XML صحبت خواهیم کرد.

3. LINQ to ADO.NET: این بخش در رابطه با اجرای کوئری های LINQ بر روی پایگاه های داده مانند SQL Server و همچنین دستکاری داده های آنان است. خود این بخش را می توان به سه بخش LINQ to SQL، LINQ to DataSet و LINQ to Entities تقسیم بندی کرد که هر کدام مبحث کاملی را می طلبند. به دلیل اینکه حجم مطالب مربوط به این بخش بسیار زیاد بوده و همچنین نیاز به آشنایی با مفاهیم پایه ای مانند ORM را دارد، توضیحات کامل در بخش مربوطه مطرح خواهند شد. تنها موردی که در اینجا می توان به آن اشاره کرد این است که در LINQ to SQL و LINQ to Entities برای موجودیت های بانک (جداول) در داخل برنامه اشیاء ای ایجاد می شوند که این اشیاء به واسطه یکسری Attribute ها توانایی تقابل با بانک و جداول مربوطه را دارند. کوئری های که برای خواندن اطلاعات از جدول به صورت کوئری های LINQ نوشته می شوند، به کوئری های SQL تبدیل شده و به سرویس SQL فرستاده می شوند تا نتایج مورد نظر گرفته شده و به کاربر نمایش داده شود. برای مثال کلاس زیر نمایش معادل یک جدول از بانک SQL است که در زبان #C بصورت یک کلاس تعریف شده است:

کد: [Table(Name = "Person.Contact")]

public class Contact

{

[Column(DBType = "nvarchar(50) not null")]

public string FirstName;

[Column(DBType = "nvarchar(50) not null")]

public string LastName;

[Column(DBType = "nvarchar(50) not null")]

public string EmailAddress;

}

به استفاده از Attribute ها برای Map کردن جدول به صورت یک شئ توجه کنید. بوسیله LINQ to SQL می توان از روی این شئ بر روی جدول معادل در بانک اطلاعاتی کوئری هایی را اجرا کرد و یا رکورد هایی را دستکاری کرد.

مطالبی که تا اینجا بیان شد، خلاصه ای از توانایی ها و ویژگی های LINQ بود که در ادامه این مقاله با تفصیل در مورد هر یک از این ویژگی ها بحث خواهیم کرد. در بخش بعد در مورد ویژگی های جدید 3.0 #C که کاربرد های فراوانی در LINQ دارند بحث خواهیم کرد. این ویژگی ها به شرح زیر هستند:

1. Implicity Typed Variables

2. Anonymous Types

3. Object Initialization

4. Lamda Experssions **

5. Automatic Implemented Properties

6. Extension Methods

موفق باشید.

**ملیساا** · 13 اسفند، ۱۳۸۹

بخش دوم :: آشنایی با ویژگی های جدید #C نسخه 3.0

در ادامه مقالات آموزشی LINQ به بررسی ویژگی های جدید 3.0 #C خواهیم پرداخت و در بخش های بعدی با نحوه استفاده از این ویژگی ها در کوئری LINQ آشنا خواهیم شد. به دلیل اینکه مقالاتی در این باره داخل سایت وجود دارد،

فقط در مورد Lamda Expressions به صورت کامل توضیح خواهیم داد و بر روی سایر وِیژگی ها به صورت خیلی مختصر بحث خواهیم کرد. ویژگی هایی که در این مقاله بررسی خواهیم کرد به شرح زیر است:

1. Implicity Typed Variables

2. Lamda Expressions

3. Extension Methods

4. Anonymous Types

1. اولین ویژگی که میخواهیم در مورد آن بحث کنیم ویژگی Implicity Typed Variables است. این ویژگی به شما این امکان رو میده تا انتخاب نوع داده تعریفی داخل کد را به عهده کامپایلر بزارید. برای مثال قطعه کد زیر رو در نظر بگیرید،

کد: int i = 25

یک متغییر int تعریف کردیم و مقدار آن را مساوی 25 قرار دادیم، در #C نسخه 3.0 با استفاده از کلمه کلیدی var انتخاب نوع متغییر را به عهده کامپایلر بزاریم. انتخاب نوع بر اساس مقداری که داخل متغییر در هنگام تعریف رخته می شود

(Initialization) انتخاب می شود:

کد:

var i = 12;

var s = "Welcome";

var d = 2.6;

در کد های بالا، متغیر i از نوع int، متغیر s از نوع string و متغیر d از نوع double در نظر گرفته می شود. فقط نکته ای که باید در نظر بگیرید این است که هنگام استفاده از کلمه var باید متغییر مقدار دهی اولیه شود. در غیر این صورت با

پیغام خطا مواجه خواهید شد.

2. ویژگی بعدی Lamda Expressions هستند، این عبارات چیزی معادل Anonymous methods در نسخه های قبلی #C هستند. در بخش قبلی درباره متد FindAll کلاس جنریک

مقایسه عناصر لیست را میگیرد. این کار در نسخه های قبلی در دو حالت امکان پذیر بود. یکی تعریف یک متد و ارسال متد به عنوان پارامتر به متد FindAll:

کد:

static void Main(string[] args)

{

List list = new List() { 7, 9, 3, 1, 5, 6, 7 };

List query = list.FindAll(Compare);

foreach (int i in query)

Console.WriteLine(i);

}

static bool Compare(int a)

{

return a > 5;

}

همانطوری که در کد بالا مشاهده میکنید، متدی با عنوان Compare تعریف شده و به عنوان پارامتر به متد FindAll جهت مقایسه فرستاده می شود. اما روش بعدی استفاده از Anonymous Methods که با استفاده از کلمه کلیدی

delegate می توان از آن استفاده کرد:

کد:

static void Main(string[] args)

{

List list = new List() { 7, 9, 3, 1, 5, 6, 7 };

List query = list.FindAll(delegate(int a) { return a > 5; });

foreach (int i in query)

Console.WriteLine(i);

}

کاربر دیگه Anonymous Methods در استفاده از Event ها است که میتوان کد مربوط به یک Event را با استفاده از Anonymous Methods به صورت درجا تعریف کرد:

حالت اول:

کد:

public Form1()

{

InitializeComponent();

button1.Click += Button1_Click;

}

public void Button1_Click(object sender, EventArgs e)

{

MessageBox.Show("Welcome to C# world");

}

و با استفاده از Anonymous Methods:

کد:

public Form1()

{

InitializeComponent();

button1.Click += delegate(object sender, EventArgs e)

{

MessageBox.Show("Welcome To C#");

};

}

اما از Lambda Expressions چگونه می توان استفاده کرد. عبارات Lambda همان کار Anonymous Methods را انجام می دهند با این تفاوت که دیگر نیازی به تعیین نوع پارامترهای ورودی تابع مورد نظر نیست! برای روش تر شدن قضیه به

همان مثال متد FindAll توجه کنید، در کد زیر ما همان کد را با عبارات Lambda پیاده سازی میکنیم:

کد:

List query = list.FindAll(delegate(int a) { return a > 5; }); // anonymous methods with delegate keyword

List query = list.FindAll((n) => { return n > 5; }); // anonymous methods with Lambda Expressions

در کد بالا، در خط اول با استفاده از کلمه کلیدی delegate و در خط دوم با استفاده از Lambda Expressions، متد بی نام مورد نظر را پیاده سازی کردیم. تفاوت موجود در ساختار ها، عدم نیاز به تعیین نوع پارامتر های ورودی متد و

استفاده از عملگر

مثال دیگر همان تعیین متد مورد نظر برای ایونت Click کنترل Button است که در کد زیر با استفاده از عبارات Lambda آن را پیاده سازی کردیم:

کد:

button1.Click += (sender, e) =>

{

MessageBox.Show("Welcome To C#");

};

نکات:

* در صورتی که تعداد پارامتر های ورودی یکی باشد، می تواند پرانتز ها را حذف کرد، اما در صوروتی که تعداد پارامترها بیش از یکی باشد، باید آنها را داخل پرانتز قرار داد.

کد:

List query = list.FindAll(n => { return n > 5; });

button1.Click += (sender, e) =>

{

MessageBox.Show("Welcome To C#");

};

* در صورتی که تعداد دستورات داخل بدنه متد تنها یک دستور باشد، می توان از نوشتن {} خودداری کرد:

کد:

button1.Click += (sender, e) => MessageBox.Show("Welcome To C#");

* در صورتی که متد مورد نظر، مقداری را برگرداند (مانند متد FindAll) و تعداد دستورات داخل بدنه متد تنها یک دستور باشد که حاصل را برمیگرداند، با حذف {} ها باید کلمه کلیدی return را نیز حذف کرد:

کد:

List query = list.FindAll(n => n > 5); // valid

List query = list.FindAll(n => return n > 5); // wrong

یکی از کاربرد های مهم عبارات Lambda در نوشتن کوئری های LINQ است که در بخش های بعدی مقالات با آنها بیشتر آشنا خواهیم شد.

3. یکی دیگر از ویژگی های جدید نسخه 3 زبان #C، متدهای توسعه یا Extension Methods هستند. این قابلیت به شما این امکان را می دهد تا به کلاس های موجود، متد های مورد نیاز خودتان را اضافه کنید. برای مثال، نوع داده int را فرض کنید. می خواهیم به این نوع داده، متدی با نام Negative را اضافه کنیم تا منفی عددی که داخل آن ذخیره شده است را برای ما برگرداند. برای این کار باید یک کلاس static ایجاد کرده و داخل آن متد های توسعه مورد نظر خود را بنویسیم. توجه کنید که خود متد توسعه نیز باید از نوع int باشد. برای درک بهتر این موضوع به کد زیر توجه کنید:

کد:

class Program

{

static void Main(string[] args)

{

int myInt = 25;

Console.WriteLine(myInt.Negative());

}

static class Extensions

{

public static int Negative(this int i)

{

return -i;

}

با قطعه کد بالا، در داخل کلاس Extensions، ما یک متد با نام Negative برای نوع داده int تعریف کردیم. ساختار نوشتن متدهای Extensions مانند نوشتن سایر متدها می باشد، با این تفاوت که اولین پارامتر ورودی این تابع، نشان دهنده یک Instance از نوع داده ای است که می خواهیم متد مورد نظر به آن اضافه شود. همچنین این متد ها همیشه باید به صورت Static نوشته شوند. در بخش بالای کد و داخل متد Main ما از این متد استفاده کردیم. توجه کنید که متدهای توسعه تنها از طریق Instance های ایجاد شده از روی یک نوع داده قابل دستری هستند. نحوه نمایش متد های توسعه با سایر متدها، در Intellisence محیط VS فرق دارد. در کنار این متد ها، یک فلش آبی رنگ به سمت پایین وجود دارد که نشان دهنده یک متد توسعه است.

4. ویژگی بعدی که در مورد آن صحبت خواهیم کرد نوع های بی نام یا Anonymous Types هستند. این نوع ها با کمک کلمه کلیدی var تعریف شده و می توانند دارای یکسری خصوصیات باشند. برای مثال، می توانیم یک نوع بدون نام که دارای خصوصیات FirstName و LastName باشد را تعریف کنیم، بدون اینکه نیازی به تعریف یک کلاس جدید باشد. به مثال زیر توجه کنید:

کد:

var myAnonymousType = new { FirstName = "Hosein", LastName = "Ahmadi" };

Console.WriteLine(myAnonymousType.FirstName + myAnonymousType.LastName);

با استفاده از کد بالا یک نوع بدون نام ایجاد شد. انتخاب نام این نوع به عهده کامپایلر است. اگه به کد IL ایجاد شده توسط کامپایلر نگاهی بندازیم می بینیم که خود کامپایلر نامی برای این نوع در نظر میگیره:

کد:

.method private hidebysig static void Main(string[] args) cil managed

{

.entrypoint

.maxstack 3

.locals init (

[0] class f__AnonymousType0`2 myAnonymousType)

L_0000: nop

L_0001: ldstr "Hosein"

L_0006: ldstr "Ahmadi"

L_000b: newobj instance void f__AnonymousType0`2::.ctor(!0, !1)

L_0010: stloc.0

L_0011: ldloc.0

L_0012: callvirt instance !0 f__AnonymousType0`2::get_FirstName()

L_0017: ldloc.0

L_0018: callvirt instance !1 f__AnonymousType0`2::get_LastName()

L_001d: call string [mscorlib]System.String::Concat(string, string)

L_0022: call void [mscorlib]System.Console::WriteLine(string)

L_0027: nop

L_0028: ret

}

نکته قابل توجه دیگر اینجاست که اگه دو نوع بدون نام دارای خواص یکسان باشند، می توانند به صورت Implicit به یکدیگر Cast شوند، َمثال:

کد:

var myAnonymousType1 = new { FirstName = "Hosein", LastName = "Ahmadi" };

var myAnonymousType2 = new { FirstName = string.Empty, LastName = string.Empty };

myAnonymousType2 = myAnonymousType1;

Console.WriteLine(myAnonymousType2.FirstName + myAnonymousType2.LastName);

نوع های بدون نام کابردهای زیادی در کوئری های LINQ دارن که در بخش های بعدی با آنها آشنا خواهیم شد.

این چهار ویژگی، مهمترین ویژگی هایی بودند که در کوئری های LINQ کاربرد دارند، چندین ویژگی جدید دیگر نیز به نسخه 3 زبان #C اضافه شده اند که در اینجا تنها به ذکر نام آنها اکتفا کرده و دوستان می توانند برای توضیحات اضافی به مقاله هایی که دوستان دیگر داخل سایت قرار دادند مراجعه کنند:

1. Automatic Implemented Properties

2. Object Initialization

3. Collection Initialication

در بخش بعدی مقالات آموزشی LINQ، در مورد ساختار کوئری های LINQ و همچنین نحوه اجرای کوئری ها صحبت خواهیم کرد.

موفق باشید.

**ملیساا** · 13 اسفند، ۱۳۸۹

بخش سوم :: ساختار کوئر های LINQ و نحوه اجرای کوئری ها

بخش سوم آموزش LINQ رو با هم شروع میکنیم. در این بخش از سری مقالات آموزشی، درباره ساختار کوئری های LINQ و همچنین نحوه اجرای کوئری های صحبت خواهیم گرد.

مباحث این بخش به شرح زیر می باشند:

1. ساختار کوئری های LINQ و اجزای تشکیل دهنده هر کوئری

2. استفاده از ساختار کوئری و ساختار متد در نوشتن کوئری ها

3. استفاده از Anonymous Types در نوشتن کوئری های LINQ

4. آشنایی با مفهوم Deferred Query Execution (نحوه اجرای کوئر ها)

خوب، تو اولین مرحله می خواییم با ساختار و اجزای تشکیل دهنده یک کوئری آشنا بشیم. اگه بخواییم ساختار کلی یک کوئری LINQ رو نمایش بدیم، ساختار یک کوئری LINQ به صورت زیر می باشد:

کد: from in

[query standard operators]

select

همانطور که در بالا مشاهده میکنید کوئری های LINQ از بخش های مختلفی تشکیل شده اند. (قسمت هایی که داخل قرار گرفته توسط کاربر تعیین شده و اجباری می باشند و قسمت هایی که داخل [] قرار گرفته اند اختیاری می باشند، باقی اجزاء که داخل نشانه ای قرار نگرفته اند بخش های پیش فرض کوئری های LINQ هستند)

from: تمامی کوئری های LINQ با کلمه کلیدی from آغاز می شوند. این کلمه نشان دهنده آغاز یک کوئری LINQ است.

: این قسمت نمایش دهنده یکی از عناصر موجود در data source ایست که می خواهیم از آن کوئری بگیریم. انتخاب نام برای این قسمت آزاد است و می توان هر نامی را برای آن انتخاب کرد. برای مثال اگر لیستی داشته باشیم که عناصر موجود در آن از نوع int باشند، زمان اجرای کوئری element از نوع int در نظر گرفته خواهد شد.

in: بخش بعدی یک کوئری LINQ کلمه کلیدی in است و نوشتن آن در تمام کوئری های LINQ اجباریست، بوسیله این کلمه که قبل از نام data_source می آید، تعیین می کنیم که کوئری بر روی کدام منبع داده باید اجرا شود.

: در این بخش نام منبع داده ای که می خواهیم کوئری بر روی آن اجرا شود را می نویسیم.

: این بخش حاوی تمامی operator های استاندارد LINQ است که برای عملیات فیل تر کردن اطلاعات، مرتب سازی، گروه بندی و یا ادغام از آنها استفاده می شوند. درباره اپراتور های استاندارد LINQ در بخش بعدی صحبت خواهیم کرد.

select: این کلمه کلیدی بعد از بخش اپراتور های استاندارد می آید و نوشتن آن در تمام کوئری های LINQ اجباری است. این کلمه نشان دهنده به پایان رسیدن یک کوئری LINQ است و وظیفه انتخاب عناصر مورد نظر از منبع داده را دارد.

: این قسمت نوع عناصر موجود در لیست ایجاد شده توسط کوئری را تعیین میکند، می توان نوع خروجی های کوئری را به طور دلخواه تعیین کرد.

برای درک بهتر هر یک از بخش های بالا با یک مثال جلو میریم:

کد: int[] nums = { 4, 1, 7, 5, 9, 6, 2 };

var query = from n in nums

where n > 4

select n.ToString();

foreach (string s in query)

Console.Write(s);

همانطور که گفته شد، کوئری با کلمه کلیدی from آغاز می شو، n در کوئری بالا نشان دهنده یکی از عناصر موجود در منبع داده است که از آن برای عملیات های فیل تر کردن استفاده می کنیم، بعد از n، کلمه کلیدی in و بعد از آن منبع داده مورد نظر است که در این کوئری منبع داده مورد نظر ما آرایه nums است. در بخش بعدی از اپراتور استاندارد where که برای فیل تر کردن اطلاعات استفاده می شود، استفاده کردیم، برای فیل تر سازی اطلاعات، از n که در خط اول کوئری تعریف کردیم استفاده کردیم، در خط بعدی هم بعد از کلمه کلیدی select نوع عناصر موجود در query را تعیین می کنیم. در اینجا با استفاده از متد ToString تعیین کردیم که عناصر موجود در کوئری از نوع string باشند. اگر به جای ()n.ToString، تنها n را می نوشتیم، عناصر موجود در لیست برگردانده شده توسط کوئری از نوع int در نظر گرفته می شد.

گرفتن کوئری از منابع داده به دو صورت امکان پذیر است.

1. استفاده از کوئری های LINQ

2. استفاده از متدهای کوئری و Lambda Expressions

در مورد روش اول در بخش های قبلی صحبت کردیم. در روش دوم از Extension Method هایی استفاده می کنیم که در net. نسخه 3.5 اضافه شده اند. استفاده از این Method ها برای نوشتن کوئری انعطاف پذیری بیشتری رو در نوشتن کوئری ها به ما میدن. نوشتن کوئری بالا با استفاده از متد های کوئری به صورت زیر است:

کد: int[] nums = { 4, 1, 7, 5, 9, 6, 2 };

var query = nums.Where(n => n > 4).Select(n => n.ToString());

foreach (string s in query)

Console.Write(s);

برای مشاهده این محتوا لطفاً ثبت نام کنید یا وارد شوید.

**ملیساا** · 13 اسفند، ۱۳۸۹

بخش چهام :: عملگرهای استاندارد LINQ

در این بخش درباره عملگرهای استانداردی که در LINQ برای ایجاد کوئری ها می تونیم از اونها استفاده کنیم صحبت خواهیم کرد. در بخش های قبلی با یکی از این عملگر ها به نام where آشنا شدیم که وظیفه فیل تر سازی اطلاعات در کوئری های LINQ رو داره. در این بخش به طور مفصل در باره تک تک این عملگرها بحث خواهیم کرد.

کلا" دو دسته از عملگرهای استاندارد در LINQ وجود دارند، اپراتورهای استانداری که بر روش اشیاء ای از نوع اینترفیس

کد زیر مثالی در باره استفاده از عملگرهای استاندارد LINQ است:

کد: string myStr = "This text is only for test";

string[] words = myStr.Split(' ');

var query = from word in words

group word.ToLower() by word.Length into gr

orderby gr.Key

select new { Length = gr.Key, Words = gr };

foreach (var obj in query)

{

Console.WriteLine(obj.Length);

foreach (string word in obj.Words)

{

Console.WriteLine(word);

}

در کد بالا، ابتدا رشته ای تعریف شده و کلمات رشته داخل یک آرایه قرار میگیرند. سپس با یک کوئری LINQ کلمات به ترتیب طول مرتب شده و دسته بندی می شن، بعد از دسته بندی حروف با یک دستور foreach مقادیر خروجی نمایش داده می شن. عملگرهایی که در بالا استفاده شده است، یکی عملگر group by برای دسته بندی خروجی و یکی هم عملگر orderby برای مرتب سازی خروجی می باشد. خروجی کد بالا به صورت زیر خواهد بود:

کد: 2

is

3

for

4

this

text

only

test

در ادامه به بررسی هر یک از عملگرهای LINQ خواهیم پرداخت:

1. عملگرهای مرتب سازی :: اولین دسته از عملگرهایی که بررسی خواهیم کردیم مربوط به مرتب سازی خروجی کوئری می باشد. این عملگرها عبارتند از:

OrderBy: که عملیات مرتب سازی لیست به صورت صعودی را انجام می دهد. (LINQ Syntax = orderby)

OrderByDescending: عملیات مرتب سازی لیست به صورت نزولی را انجام می دهد. (LINQ Syntax = orderby -- descending)

ThenBy: عملیات مربت سازی ثانویه را به صورت صعودی انجام می دهد (--,-- LINQ Syntax = orderby)

ThenByDescending: عملیات مرتب سازی ثانویه به صورت نزولی انجام می دهد (LINQ Syntax = orderby --,-- descending)

Reverse: ترتیب خروج کوئری را برعکس می کند (این عملگر معادلی در ساختار LINQ ندارد)

در ادامه با ارائه یک مثال با هر یک از عملگر های بالا بیشتر آشنا خواهیم شد. (مثال هم به صورت کوئری های LINQ و هم با استفاده از متدهای موجود زده خواهند شد)

استفاده از عملگر OrderBy:

کد: int[] numbers = { 4, 1, 6, 5, 2, 8, 3, 7, 9 };

IEnumerable query = from n in numbers

orderby n

select n;

IEnumerable query2 = numbers.OrderBy(n => n); // query using OrderBy extention method

foreach (int number in query)

Console.WriteLine(number);

output:

1

2

3

4

5

6

7

8

9

استفاده از عملگر OrderByDescending:

کد: int[] numbers = { 4, 1, 6, 5, 2, 8, 3, 7, 9 };

IEnumerable query = from n in numbers

orderby n descending

select n;

IEnumerable query2 = numbers.OrderByDescending(n => n);

foreach (int number in query)

Console.WriteLine(number);

output:

9

8

7

6

5

4

3

2

1

استفاده از عملگر ThenBy: (برای مثال این بخش از کلاس Person که در بخش اول نوشتیم استفاده می کنیم)

کد: List persons = new List()

{

new Person() { FirstName = "Hosein", LastName = "Ahmadi", Age = 23 },

new Person() { FirstName = "Hamid", LastName = "Asgari", Age = 27 },

new Person() { FirstName = "Reza", LastName = "Karimi", Age = 42 },

new Person() { FirstName = "Mohammad", LastName = "Zamani", Age = 31 },

new Person() { FirstName = "Reza", LastName = "Ahmadi", Age = 26 },

new Person() { FirstName = "Ali", LastName = "Kiani", Age = 17 },

new Person() { FirstName = "Saman", LastName = "Skandari", Age = 25 },

new Person() { FirstName = "Karim", LastName = "Heydari", Age = 19 }

};

var query = from p in persons

orderby p.FirstName, p.Age

select p;

var query2 = persons.OrderBy(n => n.FirstName).ThenBy(n => n.Age);

foreach (Person p in query2)

{

Console.WriteLine(p.ToString());

Console.WriteLine("--------------------");

}

output:

FirstName: Ali

LastName: Kiani

Age: 17

--------------------

FirstName: Hamid

LastName: Asgari

Age: 27

--------------------

FirstName: Hosein

LastName: Ahmadi

Age: 23

--------------------

FirstName: Karim

LastName: Heydari

Age: 19

--------------------

FirstName: Mohammad

LastName: Zamani

Age: 31

--------------------

FirstName: Reza

LastName: Ahmadi

Age: 26

--------------------

FirstName: Reza

LastName: Karimi

Age: 42

--------------------

FirstName: Saman

LastName: Skandari

Age: 25

--------------------

ThenByDescending: