خوش آمدید.
در این ویدیو قرار است مفاهیم بسیار زیادی را ترکیب کنیم.
ما مفهوم **generics** و مفهوم **delegate**ها را ترکیب خواهیم کرد.
از **class**ها استفاده می‌کنیم، از حلقه‌های **for** در دل حلقه‌های **for** استفاده می‌کنیم.
پس چیزهای زیادی در پیش داریم.
اما مهم‌ترین چیز این است که ما یک **مکانیزم مرتب‌سازی** انعطاف‌پذیر خواهیم ساخت.
بسیار خب.
پس بیایید شروع کنیم.
بنابراین، داخل **namespace**ام، یک **public delegate** ایجاد می‌کنم.
و این **delegate** یک **int** برمی‌گرداند و نامش **Comparison of T** خواهد بود، که در آن **T X** را با **T Y** مقایسه می‌کند.
بنابراین این **delegate** ما را قادر می‌سازد تا متدهای مختلفی ایجاد کنیم که با این اعلان مطابقت داشته باشند و سپس می‌توانند بسیار منعطف استفاده شوند.
خواهیم دید که دقیقاً منظور چیست.
اما این **int** در اینجا اساساً حاوی یک عدد خواهد بود.
و اگر این عدد منفی باشد، می‌گوید: خب، **X** بزرگتر است.
و اگر مثبت باشد، می‌گوید **Y** بزرگتر است.
و اگر برابر باشند، **X** و **Y** یکسان هستند. بنابراین، یکسان در هر زمینه‌ای.
یکسان در نام، یکسان در سن، یا هر چیزی که شما می‌خواهید تنظیم کنید.
خب، من قبلاً سن و نام را گفتم.
پس بیایید اینجا یک **class** ایجاد کنیم.
این **class**، **Person** خواهد بود، اوکی؟
پس یک **class** بسیار ساده به نام **Person** خواهیم داشت.
و این یک **property** به نام **Age** از **type int** خواهد بود.
و سپس یک **property** دیگر خواهم داشت که از **type string** خواهد بود و شامل **Name** است.
اوکی.
تا اینجای کار چیز خیلی خاصی نیست.
اما سپس یک **class** دیگر خواهیم داشت: **class PersonSorter**.
خب، کاری که این **class** باید انجام دهد این است که افراد را بر اساس یک **مقایسه** که به آن پاس می‌دهیم، **مرتب** کند.
چطور چنین چیزی ممکن است؟
خب، بذارید نشونتون بدم.
ما یک متد **public void Sort** خواهیم داشت که یک **آرایه Person** می‌گیرد که من آن را **people** صدا می‌زنم، و **الگوریتم یا مکانیزم مقایسه**.
پس **Comparison of Person comparison**.
ما اساساً می‌گوییم که **delegate** خود را اینجا پاس می‌دهیم، یعنی **Comparison delegate** را. اما این بار نه به صورت **generic**، بلکه واقعاً می‌گوییم که می‌خواهیم از **Person** استفاده کنیم.
بنابراین **delegate** از **type Person** استفاده خواهد کرد.
خب، کاری که قرار است انجام دهم این است که از طریق تک تک افراد در **آرایه** عبور کنم، اما اینجا از یک **حلقه for** استفاده خواهم کرد.
پس **int i equals 0** و **i less than people.Length++**. اما اینجا می‌گویم **less than people.Length - 1**.
خب چون داریم مقایسه می‌کنیم، نیازی نیست خودمان را با خودمان مقایسه کنیم. درسته.
ما می‌دانیم چه کسی یا چه چیزی هستیم، یا نیازی نیست یک آیتم را با خودش مقایسه کنیم. پس با استفاده از این **Length - 1** از این کار اجتناب می‌کنیم.
و با استفاده از این **for int j equals i + 1** اوکی، اوکی. پس اینجا چه خبر است.
خب ما این **حلقه for** را اینجا داریم، این **حلقه for** بیرونی. و کاری که می‌کند این است که از صفر شروع می‌شود و فقط می‌گوید خب، از طریق همه افراد به جز نفر آخر عبور کن.
و چرا نفر آخر نه؟ چون نفر آخر قرار است در **حلقه for** داخلی باشد. خب، **حلقه for** داخلی چیست؟
می‌گوید، خب، بیایید از **j** شروع کنیم، هرچیزی که **i** هست، اما یکی بالاتر. پس در این حالت، صفر به علاوه یک، یک است. بنابراین **j** در ابتدا یک خواهد بود.
و سپس می‌گوییم خب، بیایید از طریق همه افراد داخل **آرایه** عبور کنیم.
و سپس کاری که می‌خواهیم انجام دهیم این است که اینجا، داخل این **حلقه for** دوگانه. خب، آنجا می‌خواهیم **مقایسه** کنیم.
پس با استفاده از این **comparison** در بالا، جایی که **people در موقعیت i** و **people در موقعیت j** را پاس خواهیم داد. با انجام این کار، ما دو نفر مختلف را پاس می‌دهیم و آنها را با این صفر مقایسه می‌کنیم.
پس می‌گوییم آیا **بزرگتر از صفر** است؟ زیرا می‌دانیم که اگر **بزرگتر از صفر** باشد، و ما باید یک پرانتز دیگر در اینجا داشته باشیم.
به این صورت، می‌دانیم که اگر این **بزرگتر از صفر** باشد، می‌دانیم که در سن و نام یا هر چیزی که مقایسه می‌کنیم، تفاوتی وجود دارد، هر چه که **متد مقایسه** ما باشد.
و سپس در اینجا، ما یک **Person** خواهیم داشت که به طور موقت ذخیره می‌کنیم و آن **i Person** ما خواهد بود.
و سپس **i** را می‌گیریم و داخل آن **j Person** را قرار می‌دهیم و سپس **temp person** را در **j** قرار می‌دهیم.
خب، در این **دستور if** چه اتفاقی می‌افتد؟ خب، در این سه خط ما داریم **سواپ** می‌کنیم (جایگزین می‌کنیم).
خب، اول از همه اینجا داریم **i** و **j** را با استفاده از **comparison delegate** ارائه شده مقایسه می‌کنیم. **comparison delegate** هر چه که باشد، کمی بعد خواهیم دید.
و سپس می‌گوییم اگر آنها به اصطلاح برابر نیستند، یعنی اگر یکی از آنها از دیگری بزرگتر باشد، کاری که می‌کنیم این است که **people[i]** و **people[j]** را اگر در **ترتیب اشتباه** باشند، **سواپ** می‌کنیم.
ما فقط مطمئن می‌شویم که ترتیب درست باشد.
خب، این یک **مکانیزم سواپ** است.
این یک الگوریتم غیرمعمول برای استفاده نیست.
خب اگر به آن فکر کنید، ما این **متغیر موقت** را ایجاد می‌کنیم که فرض کنید آن **Person** است.
و اجازه دهید در واقع **آرایه Person** را ایجاد کنم. شاید اینطوری برای شما راحت‌تر باشد که متوجه شوید قضیه چیست.
خب من اینجا یک **آرایه Person** ایجاد می‌کنم که آن را **people** صدا می‌زنم.
و من سه نفر در آن دارم. **Alice** را دارم، **Bob** را دارم و **Charlie** را دارم. **Alice** ۳۰ سالشه، **Bob** ۲۵ سالشه و **Charlie** ۳۵ سالشه. اوکی.
خب من آن سه نفر را در آن قرار می‌دهم.
و اگر به این **آرایه people** نگاه کنیم، می‌دانیم که در **people[0]** ما **Alice** را داریم، اوکی. و سپس در **people[1]** ما **Bob** را داریم. و سپس در **people[2]** ما **Charlie** را داریم.
بسیار خب. پس بیایید فقط این‌ها را بگیریم و برای درک بهتر اینجا قرار دهیم.
پس من فقط می‌گویم **i**، **صفر** است. پس حلقه‌ی بیرونی **Alice** است و **j** **یک** است، اوکی. **صفر به علاوه یک**، یک است.
پس حلقه‌ی داخلی **Bob** است.
خب حالا **الگوریتم مقایسه** هرچیزی که باشه، در اولین تکرار، **Alice** را با **Bob** مقایسه خواهیم کرد.
و در تکرار دوم، **Alice** را با **Charlie** مقایسه خواهیم کرد.
و در تکرار سوم، **Bob** را با **Charlie** مقایسه خواهیم کرد.
و در صورتی که هرچیزی که **الگوریتم مرتب‌سازی** ما باشد که قرار است استفاده کنیم، اگر سن باشد یا اگر حروف الفبا باشد. خب اگر نام‌ها را مقایسه کنیم، بر اساس حروف الفبا است. اوکی.
**Alice** با **A** شروع می‌شود، **Bob** با **B** شروع می‌شود، **Charlie** با **C** شروع می‌شود. پس می‌بینید که ترتیب تقریباً یکسان باقی می‌ماند.
پس اینجا ما فقط داریم مقایسه می‌کنیم. آیا یکی از آنها از دیگری بزرگتر است، با هر چیزی که الگوریتم مقایسه ما باشد.
و اگر اینطور باشد، می‌گوییم خب، بیایید آن **Person** را بگیریم. فرض کنید **Alice** را می‌گیریم. و سپس در موقعیت **Alice**، **Bob** را قرار می‌دهیم.
اوکی.
خب این کاریه که این خط انجام می‌ده.
و سپس در خط بعدی می‌گوییم خب. اما حالا در موقعیت **Bob**، جایی که **Bob** قبلاً بود، **Alice** را قرار می‌دهیم.
خب این کاریه که این **الگوریتم swap** انجام می‌ده. و اینطوری مرتب می‌کنه.
خب فقط افراد را جابجا می‌کند تا در نهایت ترتیب درستی داشته باشند، هر چه که الگوریتم مقایسه‌ای باشد که ما قصد فعال‌سازی یا ساختنش را داریم.
خب حالا بیایید واقعاً از **PersonSorter** که ایجاد کردیم استفاده کنیم تا این را بهتر بفهمیم، جایی که واقعاً این مرتب‌ساز (sorter) در حال اجرا است.
پس **new PersonSorter()** و من از این مرتب‌ساز برای مرتب‌سازی استفاده می‌کنم. و حالا باید **people** را پاس دهم.
پس **آرایه Person** که **people** خواهد بود و باید **متد مقایسه** را پاس دهم زیرا **comparison** یک **delegate** است.
پس بیایید یک **متد مقایسه** ایجاد کنیم.
و من یکی را خارج از **static void main** ایجاد خواهم کرد. یک **static int CompareByAge** ایجاد می‌کنم.
و حالا قرار است **person** را در آن بگیریم و در واقع **person X**. و قرار است آن را با **person Y** مقایسه کنیم.
و حالا می‌توانیم جلو برویم و **x.Age.CompareTo(y.Age)** را برگردانیم. خب ما فقط داریم دو **سن** یک نفر را با نفر دیگر مقایسه می‌کنیم.
خب حالا می‌توانیم از این متد **CompareByAge** همینجا در متد **Sort** استفاده کنیم.
خب ما داریم یک **متد** را به یک **متد** پاس می‌دهیم چون این چیزی است که در متد **Sort** تعریف کردیم. ما گفتیم خب، متدی را به من پاس بده که با **اعلان** این **delegate** مطابقت داشته باشد.
پس این **delegate** که در اینجا می‌گوید هر **type**ی و هر **type** دیگری از همان **type** را به من بده، واضح است، اما من آن دو را **مقایسه** خواهم کرد.
حالا این **سن** را مقایسه می‌کند.
می‌بینید، اگر **کمتر از صفر** باشد، **Instance** **کمتر از value** است.
پس **instance** که یعنی **x.Age** **کمتر از** هر چیزی که **y** هست، **y.Age** است.
و اگر **صفر** باشد، برابر هستند.
و اگر **بزرگتر از صفر** باشد، به این معنی است که **y** **بزرگتر از x** است. خب این کاریه که این **CompareTo** انجام می‌ده.
اوکی.
خب حالا اگر بخواهیم این را مرتب کنیم و اجرا کنیم تا در واقع نتایج را ببینیم، به یک **حلقه for each** در اینجا نیاز داریم.
پس **برای هر person در people** ما **نام person** و همچنین **سن** را نمایش خواهیم داد، اوکی.
پس **person.Name** و **person.Age**.
خب قبل از اینکه این را اجرا کنیم، بیایید از **Console.ReadKey()** استفاده کنیم تا برنامه‌مان در حال اجرا بماند.
و سپس می‌بینیم که مرتبش کرد. گفت: **Bob**، **Alice**، **Charlie**.
این به این دلیله که **Bob** از همه کوچکتره. او ۲۵ سالشه، **Alice** ۳۰ سالشه و **Charlie** ۳۵ سالشه.
حالا کاری که می‌توانیم انجام دهیم این است که جلوتر برویم و یک **الگوریتم مرتب‌سازی** دیگر ایجاد کنیم.
خب می‌گوییم یا نه، **الگوریتم مرتب‌سازی** تغییر نمی‌کند، اما ما نه بر اساس **سن** بلکه بر اساس **نام** مقایسه می‌کنیم.
و سپس می‌گوییم، بیایید دو نفر را با هم مقایسه کنیم و **x.Name.CompareTo(y.Name)** را برمی‌گردانیم.
اوکی.
خب می‌بینید این دوباره **کمتر از صفر** است.
این **instance** قبل از **string B صفر** قرار می‌گیرد. آنها یکسان هستند و **بزرگتر از صفر** است. این **instance** بعد از **string B** یا **string b** قرار می‌گیرد.
اساساً قرار است آنها را بر اساس **ترتیب الفبایی** مقایسه کند.
خب بیایید در واقع یک **Person** دیگر اینجا اضافه کنیم تا کمی واضح‌تر شود.
و این **Dennis** خواهد بود. **سن**.
خب، من هم ۳۵ سالمه، اما نزدیکم به ۳۶ سالگی، پس بیایید در این مثال من رو ۳۶ ساله فرض کنیم.
و حالا بیایید یک **مقایسه** دیگر انجام دهیم.
پس یک بار دیگر **مرتب‌سازی** می‌کنم. اما این بار قرار است **people** را بر اساس **CompareByName** مرتب کنم و بقیه چیزها ثابت می‌مانند.
بیایید دوباره آن را اجرا کنیم و خواهیم دید.
ابتدا بر اساس **سن** مقایسه می‌کنیم.
پس می‌بینیم که **Bob** را داریم، **Alice** را داریم، **Charlie** را داریم، سپس **Dennis** را داریم، و سپس بر اساس **نام** مقایسه می‌کنیم یا بر اساس **نام** مرتب می‌کنیم.
پس **Alice**، **Bob**، **Charlie**، **Dennis** را داریم.
پس **A, B, C, D**. می‌بینید، اوکی؟ خب، خیلی چیزها در این کد در حال رخ دادن است، اما واقعاً ارزشمند است.
و من واقعاً توصیه می‌کنم که روی این مسلط شوید، به خصوص این قسمت مربوط به **swapping** (جابجایی).
و اگر کمکتان کند و اگر متوجه نمی‌شوید، مثلاً فرض کنید متوجه نمی‌شوید.
کاری که توصیه می‌کنم انجام دهید تا خودتان موضوع را بفهمید، استفاده از **breakpoint**ها است.
می‌توانید مرحله به مرحله از طریق کد عبور کنید، تک تک خطوط کد را اجرا کنید و مقدار را مقایسه کنید و به مقادیر نگاه کنید.
به هر کاری که کد انجام می‌دهد نگاه کنید تا واقعاً بفهمید در هر لحظه چه اتفاقی می‌افتد، و مقادیر هر یک از آیتم‌ها چیست.
اوکی، پس این یک ترفند کوچک خوب برای شماست و شما را در ویدیوی بعدی می‌بینم.