1
00:00.110 --> 00:00.860
خوش آمدید.

2
00:00.860 --> 00:03.710
در این ویدیو قرار است مفاهیم بسیار زیادی را ترکیب کنیم.

3
00:03.710 --> 00:07.790
ما مفهوم **generics** و مفهوم **delegate**ها را ترکیب خواهیم کرد.

4
00:07.790 --> 00:11.840
از **class**ها استفاده می‌کنیم، از حلقه‌های **for** در دل حلقه‌های **for** استفاده می‌کنیم.

5
00:11.840 --> 00:14.120
پس چیزهای زیادی در پیش داریم.

6
00:14.120 --> 00:19.370
اما مهم‌ترین چیز این است که ما یک **مکانیزم مرتب‌سازی** انعطاف‌پذیر خواهیم ساخت.

7
00:19.370 --> 00:19.910
بسیار خب.

8
00:19.910 --> 00:21.260
پس بیایید شروع کنیم.

9
00:21.260 --> 00:27.230
بنابراین، داخل **namespace**ام، یک **public delegate** ایجاد می‌کنم.

10
00:27.230 --> 00:38.800
و این **delegate** یک **int** برمی‌گرداند و نامش **Comparison of T** خواهد بود، که در آن **T X** را با **T Y** مقایسه می‌کند.

11
00:38.830 --> 00:49.270
بنابراین این **delegate** ما را قادر می‌سازد تا متدهای مختلفی ایجاد کنیم که با این اعلان مطابقت داشته باشند و سپس می‌توانند بسیار منعطف استفاده شوند.

12
00:49.300 --> 00:51.670
خواهیم دید که دقیقاً منظور چیست.

13
00:51.670 --> 00:56.680
اما این **int** در اینجا اساساً حاوی یک عدد خواهد بود.

14
00:56.680 --> 01:00.580
و اگر این عدد منفی باشد، می‌گوید: خب، **X** بزرگتر است.

15
01:00.580 --> 01:03.760
و اگر مثبت باشد، می‌گوید **Y** بزرگتر است.

16
01:03.760 --> 01:10.300
و اگر برابر باشند، **X** و **Y** یکسان هستند. بنابراین، یکسان در هر زمینه‌ای.

17
01:10.300 --> 01:14.410
یکسان در نام، یکسان در سن، یا هر چیزی که شما می‌خواهید تنظیم کنید.

18
01:14.410 --> 01:17.110
خب، من قبلاً سن و نام را گفتم.

19
01:17.110 --> 01:19.560
پس بیایید اینجا یک **class** ایجاد کنیم.

20
01:19.560 --> 01:22.350
این **class**، **Person** خواهد بود، اوکی؟

21
01:22.350 --> 01:25.020
پس یک **class** بسیار ساده به نام **Person** خواهیم داشت.

22
01:25.020 --> 01:30.780
و این یک **property** به نام **Age** از **type int** خواهد بود.

23
01:30.930 --> 01:35.940
و سپس یک **property** دیگر خواهم داشت که از **type string** خواهد بود و شامل **Name** است.

24
01:35.940 --> 01:36.630
اوکی.

25
01:36.630 --> 01:38.250
تا اینجای کار چیز خیلی خاصی نیست.

26
01:38.250 --> 01:43.790
اما سپس یک **class** دیگر خواهیم داشت: **class PersonSorter**.

27
01:43.790 --> 01:52.220
خب، کاری که این **class** باید انجام دهد این است که افراد را بر اساس یک **مقایسه** که به آن پاس می‌دهیم، **مرتب** کند.

28
01:52.220 --> 01:53.780
چطور چنین چیزی ممکن است؟

29
01:53.780 --> 01:55.220
خب، بذارید نشونتون بدم.

30
01:55.220 --> 02:07.070
ما یک متد **public void Sort** خواهیم داشت که یک **آرایه Person** می‌گیرد که من آن را **people** صدا می‌زنم، و **الگوریتم یا مکانیزم مقایسه**.

31
02:07.070 --> 02:11.280
پس **Comparison of Person comparison**.

32
02:11.280 --> 02:23.760
ما اساساً می‌گوییم که **delegate** خود را اینجا پاس می‌دهیم، یعنی **Comparison delegate** را. اما این بار نه به صورت **generic**، بلکه واقعاً می‌گوییم که می‌خواهیم از **Person** استفاده کنیم.

33
02:23.760 --> 02:27.990
بنابراین **delegate** از **type Person** استفاده خواهد کرد.

34
02:27.990 --> 02:35.110
خب، کاری که قرار است انجام دهم این است که از طریق تک تک افراد در **آرایه** عبور کنم، اما اینجا از یک **حلقه for** استفاده خواهم کرد.

35
02:35.110 --> 02:46.780
پس **int i equals 0** و **i less than people.Length++**. اما اینجا می‌گویم **less than people.Length - 1**.

36
02:46.780 --> 02:52.090
خب چون داریم مقایسه می‌کنیم، نیازی نیست خودمان را با خودمان مقایسه کنیم. درسته.

37
02:52.090 --> 03:02.250
ما می‌دانیم چه کسی یا چه چیزی هستیم، یا نیازی نیست یک آیتم را با خودش مقایسه کنیم. پس با استفاده از این **Length - 1** از این کار اجتناب می‌کنیم.

38
03:02.250 --> 03:11.190
و با استفاده از این **for int j equals i + 1** اوکی، اوکی. پس اینجا چه خبر است.

39
03:11.190 --> 03:19.500
خب ما این **حلقه for** را اینجا داریم، این **حلقه for** بیرونی. و کاری که می‌کند این است که از صفر شروع می‌شود و فقط می‌گوید خب، از طریق همه افراد به جز نفر آخر عبور کن.

40
03:19.500 --> 03:25.140
و چرا نفر آخر نه؟ چون نفر آخر قرار است در **حلقه for** داخلی باشد. خب، **حلقه for** داخلی چیست؟

41
03:25.140 --> 03:37.080
می‌گوید، خب، بیایید از **j** شروع کنیم، هرچیزی که **i** هست، اما یکی بالاتر. پس در این حالت، صفر به علاوه یک، یک است. بنابراین **j** در ابتدا یک خواهد بود.

42
03:37.080 --> 03:42.240
و سپس می‌گوییم خب، بیایید از طریق همه افراد داخل **آرایه** عبور کنیم.

43
03:42.240 --> 03:50.210
و سپس کاری که می‌خواهیم انجام دهیم این است که اینجا، داخل این **حلقه for** دوگانه. خب، آنجا می‌خواهیم **مقایسه** کنیم.

44
03:50.210 --> 04:08.330
پس با استفاده از این **comparison** در بالا، جایی که **people در موقعیت i** و **people در موقعیت j** را پاس خواهیم داد. با انجام این کار، ما دو نفر مختلف را پاس می‌دهیم و آنها را با این صفر مقایسه می‌کنیم.

45
04:08.330 --> 04:16.560
پس می‌گوییم آیا **بزرگتر از صفر** است؟ زیرا می‌دانیم که اگر **بزرگتر از صفر** باشد، و ما باید یک پرانتز دیگر در اینجا داشته باشیم.

46
04:16.560 --> 04:30.660
به این صورت، می‌دانیم که اگر این **بزرگتر از صفر** باشد، می‌دانیم که در سن و نام یا هر چیزی که مقایسه می‌کنیم، تفاوتی وجود دارد، هر چه که **متد مقایسه** ما باشد.

47
04:30.660 --> 04:39.370
و سپس در اینجا، ما یک **Person** خواهیم داشت که به طور موقت ذخیره می‌کنیم و آن **i Person** ما خواهد بود.

48
04:39.370 --> 04:46.750
و سپس **i** را می‌گیریم و داخل آن **j Person** را قرار می‌دهیم و سپس **temp person** را در **j** قرار می‌دهیم.

49
04:46.750 --> 04:52.120
خب، در این **دستور if** چه اتفاقی می‌افتد؟ خب، در این سه خط ما داریم **سواپ** می‌کنیم (جایگزین می‌کنیم).

50
04:52.120 --> 05:02.850
خب، اول از همه اینجا داریم **i** و **j** را با استفاده از **comparison delegate** ارائه شده مقایسه می‌کنیم. **comparison delegate** هر چه که باشد، کمی بعد خواهیم دید.

51
05:02.850 --> 05:15.570
و سپس می‌گوییم اگر آنها به اصطلاح برابر نیستند، یعنی اگر یکی از آنها از دیگری بزرگتر باشد، کاری که می‌کنیم این است که **people[i]** و **people[j]** را اگر در **ترتیب اشتباه** باشند، **سواپ** می‌کنیم.

52
05:15.570 --> 05:19.980
ما فقط مطمئن می‌شویم که ترتیب درست باشد.

53
05:19.980 --> 05:22.500
خب، این یک **مکانیزم سواپ** است.

54
05:22.500 --> 05:26.610
این یک الگوریتم غیرمعمول برای استفاده نیست.

55
05:26.790 --> 05:34.200
خب اگر به آن فکر کنید، ما این **متغیر موقت** را ایجاد می‌کنیم که فرض کنید آن **Person** است.

56
05:34.200 --> 05:41.040
و اجازه دهید در واقع **آرایه Person** را ایجاد کنم. شاید اینطوری برای شما راحت‌تر باشد که متوجه شوید قضیه چیست.

57
05:41.040 --> 05:45.270
خب من اینجا یک **آرایه Person** ایجاد می‌کنم که آن را **people** صدا می‌زنم.

58
05:45.270 --> 05:55.040
و من سه نفر در آن دارم. **Alice** را دارم، **Bob** را دارم و **Charlie** را دارم. **Alice** ۳۰ سالشه، **Bob** ۲۵ سالشه و **Charlie** ۳۵ سالشه. اوکی.

59
05:55.040 --> 05:56.720
خب من آن سه نفر را در آن قرار می‌دهم.

60
05:56.720 --> 06:16.330
و اگر به این **آرایه people** نگاه کنیم، می‌دانیم که در **people[0]** ما **Alice** را داریم، اوکی. و سپس در **people[1]** ما **Bob** را داریم. و سپس در **people[2]** ما **Charlie** را داریم.

61
06:16.450 --> 06:22.870
بسیار خب. پس بیایید فقط این‌ها را بگیریم و برای درک بهتر اینجا قرار دهیم.

62
06:22.870 --> 06:33.430
پس من فقط می‌گویم **i**، **صفر** است. پس حلقه‌ی بیرونی **Alice** است و **j** **یک** است، اوکی. **صفر به علاوه یک**، یک است.

63
06:33.430 --> 06:35.800
پس حلقه‌ی داخلی **Bob** است.

64
06:35.800 --> 06:43.000
خب حالا **الگوریتم مقایسه** هرچیزی که باشه، در اولین تکرار، **Alice** را با **Bob** مقایسه خواهیم کرد.

65
06:43.000 --> 06:46.660
و در تکرار دوم، **Alice** را با **Charlie** مقایسه خواهیم کرد.

66
06:46.660 --> 06:52.570
و در تکرار سوم، **Bob** را با **Charlie** مقایسه خواهیم کرد.

67
06:52.570 --> 07:02.580
و در صورتی که هرچیزی که **الگوریتم مرتب‌سازی** ما باشد که قرار است استفاده کنیم، اگر سن باشد یا اگر حروف الفبا باشد. خب اگر نام‌ها را مقایسه کنیم، بر اساس حروف الفبا است. اوکی.

68
07:02.580 --> 07:09.930
**Alice** با **A** شروع می‌شود، **Bob** با **B** شروع می‌شود، **Charlie** با **C** شروع می‌شود. پس می‌بینید که ترتیب تقریباً یکسان باقی می‌ماند.

69
07:09.930 --> 07:17.640
پس اینجا ما فقط داریم مقایسه می‌کنیم. آیا یکی از آنها از دیگری بزرگتر است، با هر چیزی که الگوریتم مقایسه ما باشد.

70
07:17.640 --> 07:29.630
و اگر اینطور باشد، می‌گوییم خب، بیایید آن **Person** را بگیریم. فرض کنید **Alice** را می‌گیریم. و سپس در موقعیت **Alice**، **Bob** را قرار می‌دهیم.

71
07:29.630 --> 07:30.230
اوکی.

72
07:30.230 --> 07:31.820
خب این کاریه که این خط انجام می‌ده.

73
07:31.820 --> 07:38.120
و سپس در خط بعدی می‌گوییم خب. اما حالا در موقعیت **Bob**، جایی که **Bob** قبلاً بود، **Alice** را قرار می‌دهیم.

74
07:38.150 --> 07:43.310
خب این کاریه که این **الگوریتم swap** انجام می‌ده. و اینطوری مرتب می‌کنه.

75
07:43.310 --> 07:54.050
خب فقط افراد را جابجا می‌کند تا در نهایت ترتیب درستی داشته باشند، هر چه که الگوریتم مقایسه‌ای باشد که ما قصد فعال‌سازی یا ساختنش را داریم.

76
07:54.050 --> 08:04.790
خب حالا بیایید واقعاً از **PersonSorter** که ایجاد کردیم استفاده کنیم تا این را بهتر بفهمیم، جایی که واقعاً این مرتب‌ساز (sorter) در حال اجرا است.

77
08:04.790 --> 08:12.740
پس **new PersonSorter()** و من از این مرتب‌ساز برای مرتب‌سازی استفاده می‌کنم. و حالا باید **people** را پاس دهم.

78
08:12.740 --> 08:20.440
پس **آرایه Person** که **people** خواهد بود و باید **متد مقایسه** را پاس دهم زیرا **comparison** یک **delegate** است.

79
08:20.440 --> 08:22.990
پس بیایید یک **متد مقایسه** ایجاد کنیم.

80
08:22.990 --> 08:31.960
و من یکی را خارج از **static void main** ایجاد خواهم کرد. یک **static int CompareByAge** ایجاد می‌کنم.

81
08:31.960 --> 08:42.630
و حالا قرار است **person** را در آن بگیریم و در واقع **person X**. و قرار است آن را با **person Y** مقایسه کنیم.

82
08:42.630 --> 08:57.210
و حالا می‌توانیم جلو برویم و **x.Age.CompareTo(y.Age)** را برگردانیم. خب ما فقط داریم دو **سن** یک نفر را با نفر دیگر مقایسه می‌کنیم.

83
08:57.210 --> 09:02.520
خب حالا می‌توانیم از این متد **CompareByAge** همینجا در متد **Sort** استفاده کنیم.

84
09:02.520 --> 09:14.820
خب ما داریم یک **متد** را به یک **متد** پاس می‌دهیم چون این چیزی است که در متد **Sort** تعریف کردیم. ما گفتیم خب، متدی را به من پاس بده که با **اعلان** این **delegate** مطابقت داشته باشد.

85
09:14.820 --> 09:24.450
پس این **delegate** که در اینجا می‌گوید هر **type**ی و هر **type** دیگری از همان **type** را به من بده، واضح است، اما من آن دو را **مقایسه** خواهم کرد.

86
09:24.480 --> 09:27.090
حالا این **سن** را مقایسه می‌کند.

87
09:27.090 --> 09:30.840
می‌بینید، اگر **کمتر از صفر** باشد، **Instance** **کمتر از value** است.

88
09:30.840 --> 09:38.310
پس **instance** که یعنی **x.Age** **کمتر از** هر چیزی که **y** هست، **y.Age** است.

89
09:38.310 --> 09:41.100
و اگر **صفر** باشد، برابر هستند.

90
09:41.100 --> 09:47.790
و اگر **بزرگتر از صفر** باشد، به این معنی است که **y** **بزرگتر از x** است. خب این کاریه که این **CompareTo** انجام می‌ده.

91
09:47.910 --> 09:48.750
اوکی.

92
09:48.750 --> 09:57.860
خب حالا اگر بخواهیم این را مرتب کنیم و اجرا کنیم تا در واقع نتایج را ببینیم، به یک **حلقه for each** در اینجا نیاز داریم.

93
09:57.860 --> 10:05.390
پس **برای هر person در people** ما **نام person** و همچنین **سن** را نمایش خواهیم داد، اوکی.

94
10:05.390 --> 10:11.510
پس **person.Name** و **person.Age**.

95
10:11.510 --> 10:18.100
خب قبل از اینکه این را اجرا کنیم، بیایید از **Console.ReadKey()** استفاده کنیم تا برنامه‌مان در حال اجرا بماند.

96
10:18.100 --> 10:23.140
و سپس می‌بینیم که مرتبش کرد. گفت: **Bob**، **Alice**، **Charlie**.

97
10:23.140 --> 10:29.110
این به این دلیله که **Bob** از همه کوچکتره. او ۲۵ سالشه، **Alice** ۳۰ سالشه و **Charlie** ۳۵ سالشه.

98
10:29.110 --> 10:34.510
حالا کاری که می‌توانیم انجام دهیم این است که جلوتر برویم و یک **الگوریتم مرتب‌سازی** دیگر ایجاد کنیم.

99
10:34.510 --> 10:41.290
خب می‌گوییم یا نه، **الگوریتم مرتب‌سازی** تغییر نمی‌کند، اما ما نه بر اساس **سن** بلکه بر اساس **نام** مقایسه می‌کنیم.

100
10:41.290 --> 10:49.470
و سپس می‌گوییم، بیایید دو نفر را با هم مقایسه کنیم و **x.Name.CompareTo(y.Name)** را برمی‌گردانیم.

101
10:49.680 --> 10:50.100
اوکی.

102
10:50.100 --> 10:53.070
خب می‌بینید این دوباره **کمتر از صفر** است.

103
10:53.070 --> 11:00.750
این **instance** قبل از **string B صفر** قرار می‌گیرد. آنها یکسان هستند و **بزرگتر از صفر** است. این **instance** بعد از **string B** یا **string b** قرار می‌گیرد.

104
11:00.750 --> 11:06.180
اساساً قرار است آنها را بر اساس **ترتیب الفبایی** مقایسه کند.

105
11:06.190 --> 11:12.550
خب بیایید در واقع یک **Person** دیگر اینجا اضافه کنیم تا کمی واضح‌تر شود.

106
11:12.550 --> 11:16.510
و این **Dennis** خواهد بود. **سن**.

107
11:16.510 --> 11:23.530
خب، من هم ۳۵ سالمه، اما نزدیکم به ۳۶ سالگی، پس بیایید در این مثال من رو ۳۶ ساله فرض کنیم.

108
11:23.530 --> 11:27.580
و حالا بیایید یک **مقایسه** دیگر انجام دهیم.

109
11:27.580 --> 11:37.740
پس یک بار دیگر **مرتب‌سازی** می‌کنم. اما این بار قرار است **people** را بر اساس **CompareByName** مرتب کنم و بقیه چیزها ثابت می‌مانند.

110
11:37.740 --> 11:39.990
بیایید دوباره آن را اجرا کنیم و خواهیم دید.

111
11:39.990 --> 11:42.990
ابتدا بر اساس **سن** مقایسه می‌کنیم.

112
11:42.990 --> 11:50.160
پس می‌بینیم که **Bob** را داریم، **Alice** را داریم، **Charlie** را داریم، سپس **Dennis** را داریم، و سپس بر اساس **نام** مقایسه می‌کنیم یا بر اساس **نام** مرتب می‌کنیم.

113
11:50.160 --> 11:53.340
پس **Alice**، **Bob**، **Charlie**، **Dennis** را داریم.

114
11:53.340 --> 12:02.110
پس **A, B, C, D**. می‌بینید، اوکی؟ خب، خیلی چیزها در این کد در حال رخ دادن است، اما واقعاً ارزشمند است.

115
12:02.110 --> 12:09.280
و من واقعاً توصیه می‌کنم که روی این مسلط شوید، به خصوص این قسمت مربوط به **swapping** (جابجایی).

116
12:09.280 --> 12:16.180
و اگر کمکتان کند و اگر متوجه نمی‌شوید، مثلاً فرض کنید متوجه نمی‌شوید.

117
12:16.180 --> 12:24.250
کاری که توصیه می‌کنم انجام دهید تا خودتان موضوع را بفهمید، استفاده از **breakpoint**ها است.

118
12:24.250 --> 12:31.030
می‌توانید مرحله به مرحله از طریق کد عبور کنید، تک تک خطوط کد را اجرا کنید و مقدار را مقایسه کنید و به مقادیر نگاه کنید.

119
12:31.660 --> 12:39.730
به هر کاری که کد انجام می‌دهد نگاه کنید تا واقعاً بفهمید در هر لحظه چه اتفاقی می‌افتد، و مقادیر هر یک از آیتم‌ها چیست.

120
12:39.730 --> 12:45.490
اوکی، پس این یک ترفند کوچک خوب برای شماست و شما را در ویدیوی بعدی می‌بینم.