در حال بارگذاری...

اولین برنامه

قبلاً SDK را نصب کردید و یک آزمایشگاه اول را اجرا کردید. صفحه pine نشان داد. این صفحه با همان شکل برنامه می‌ماند و سؤال دیگری می‌پرسد: کدام خط داخل فایل آن کلمه را نوشت، و کدام خط‌ها چیزی ننوشتند. دوباره .NET را نصب نمی‌کنید. خط نسخهٔ صفحهٔ قبل می‌تواند همان بماند. کلاس عمومی به نام Pine را نگه دارید، Main را نگه دارید، و Console.WriteLine("pine"); را نگه دارید. صفحه‌ای که توضیح می‌دهید هنوز یک خط است، و آن خط pine است.

فایل بیش از یک خط دارد، پس حدس اول این است که هر خط فایل به یک خط صفحه تبدیل می‌شود. آن حدس غلط است و بقیهٔ این صفحه نشان می‌دهد چرا. چند خط چیزی را نام می‌گذارند. فقط یکی می‌نویسد. آکولادها آن خط‌ها را گروه می‌کنند. آن‌ها هم نمی‌نویسند. وقتی می‌توانید با فایل جلوی‌تان به خط نوشتن اشاره کنید، این صفحه تمام است. صفحهٔ بعد یادداشتی می‌گذارد که صفحه نشان نمی‌دهد. pine را عوض نمی‌کند.

the whole Pine file

csharp

using System;

public class Pine
{
    public static void Main()
    {
        Console.WriteLine("pine");
    }
}

using System نام‌های کوتاه را آماده می‌کند

اولین خط مفید using System; است. آن را به‌عنوان خط آماده‌سازی بخوانید، نه جمله‌ای که صفحه چاپ کند. نام‌ها را از فضای نام System به شکل کوتاه می‌آورد تا Console بدون مسیر بلند ظاهر شود. کلمهٔ using را روی صفحه نمی‌بینید. System را روی صفحه نمی‌بینید. اگر در آزمایش اشتباه این خط را حذف کنید، نام کوتاه Console بعداً ممکن است شکست بخورد — آن داستان کامپایل برای روز دیگر است. روی این صفحه خط می‌ماند، و صفحه pine می‌ماند چون این خط نمی‌نویسد.

خط کلاس نوع را نام می‌گذارد

خط نوع بعدی public class Pine است. آن را سه کلمه با یک کار بخوانید، نه متن صفحه. public یعنی کد دیگر اجازه دارد از این نوع استفاده کند. public را روی صفحه نمی‌بینید. class یعنی این فایل یک واحد نام‌دار تعریف می‌کند. class را روی صفحه نمی‌بینید. Pine نام آن واحد است. در این شکل آموزشی ریشهٔ نام فایل با آن نام یکی است. اگر نام این خط را عوض کنید، عادت نام فایل هم باید همراهش عوض شود. آن قاعده دربارهٔ نوع و فایل است. دربارهٔ صفحه نیست. دوباره به صفحه نگاه کنید. صفحه Pine نشان نمی‌دهد. pine نشان می‌دهد. P بزرگ و p کوچک یک کلمه نیستند. خط کلاس هرگز نامش را روی صفحه نمی‌نویسد.

نویسه‌ای بعد از آن خط آکولاد باز { است. آکولاد بستهٔ متناظر بعداً در فایل بدن کلاس را تمام می‌کند. هرچه بین آن آکولادهاست متعلق به کلاس Pine است. آکولادها حصارند. به C# می‌گویند این واحد از کجا شروع و کجا تمام می‌شود. حصار متن صفحه نیست. کنار pine علامت { یا } نمی‌بینید. اگر آکولاد باز را حذف کنید، فایل خراب است و کامپایلر به‌جای سکوت خطا می‌نویسد. آن خطا موضوع این صفحه نیست. این صفحه هر دو آکولاد را نگه می‌دارد و صفحه pine می‌ماند.

خط Main جایی است که runtime شروع می‌کند

خط بعدی public static void Main() است. وقتی از مردم می‌پرسند برنامه از کجا شروع می‌شود به این خط اشاره می‌کنند، و دربارهٔ شروع درست می‌گویند. اگر بگویند صفحه Main نشان می‌دهد اشتباه‌اند. runtime هنگام اجرای پروژه به‌دنبال متدی با این شکل می‌گردد. از این خط شروع به اجرا می‌کند. شروع کردن همان نوشتن نیست. کلمه‌های روی خط دستورهایی دربارهٔ نحوهٔ شروع‌اند. کلمه‌هایی برای صفحه نیستند.

کلمه‌ها را یکی‌یکی بردارید و هر کدام را با صفحه چک کنید. public دوباره یعنی متد از بیرون قابل شروع است. static یعنی runtime می‌تواند این متد را بدون ساختن شیء اول شروع کند. هنوز با شیءها آشنا نشده‌اید، پس فقط این کافی است که در این شکل آموزشی static لازم است و چاپ نمی‌شود. void یعنی این متد مقداری به فراخواننده برنمی‌گرداند. روی این صفحه داستان فراخواننده نیست و void روی صفحه نیست. Main نامی است که runtime در این شکل جستجو می‌کند. صفحه هنوز آن چهار حرف را نشان نمی‌دهد. پرانتزها فهرست پارامتر را علامت می‌زنند. روی این صفحه فهرست خالی است. پرانتز خالی هم چاپ نمی‌شود.

پس خط Main می‌تواند هم‌زمان دو جور درست باشد. runtime از آنجا شروع کرد. صفحه حتی یک کلمه از آن خط نگرفت. اگر چشم‌تان روی Main می‌ماند چون وسط فایل است، جایشان را عوض کنید. کلمه‌ای که از صفحه به یاد دارید pine است و pine روی این خط نوشته نشده.

خط درونی pine می‌نویسد

داخل Main، بین آکولادهای خودش، یک خط دیگر هست. آن خط Console.WriteLine("pine"); است. همین خط صفحه را می‌نویسد. در فایل تورفتگی دارد تا ببینید داخل Main نشسته. تورفتگی فاصله است. فاصله‌ها هم روی صفحه نوشته نمی‌شوند. runtime این خط درونی را اجرا می‌کند چون داخل متدی است که برنامه از آنجا شروع می‌شود. صفحه از آنچه این خط درونی می‌نویسد استفاده می‌کند. از نام متد بیرونی استفاده نمی‌کند.

خط درونی را از چپ بخوانید. Console کمک‌کنندهٔ صفحه‌ای است که این دوره استفاده می‌کند. WriteLine یعنی این را بنویس، بعد خط را تمام کن. بخش داخل پرانتز چیزی است که نوشته می‌شود. داخل پرانتز کلمهٔ pine بین گیومهٔ دوتایی نشسته. گیومه‌ها pine را به‌عنوان متن علامت می‌زنند. بخشی از متن نیستند. در ذهن گیومه‌ها را بردارید و کلمه‌ای که می‌ماند pine است، و همان کل صفحه است. گیومه‌ها را در فایل نگه دارید. بدون گیومه کامپایلر pine را آن literal متنی نمی‌داند. سمی‌کالن پایان دستور را برای C# تمام می‌کند. سمی‌کالن را روی صفحه نمی‌بینید. pine را می‌بینید، و بعد خط تمام می‌شود چون WriteLine تمامش کرده.

اینجا همان خط نوشتن را جدا می‌بینید تا خط‌های دیگر پنهانش نکنند.

only this line writes the screen

csharp

Console.WriteLine("pine");

هیچ‌چیز در فرمان dotnet run کلمهٔ pine را انتخاب نمی‌کند. فرمان فقط پروژه را شروع می‌کند. کلمه از گیومه‌ها می‌آید. اگر گیومه‌ها کلمهٔ دیگری داشتند، صفحه آن کلمه را نشان می‌داد و این صفحه آن کار را نمی‌کند. گیومه‌های این صفحه pine دارند، پس صفحه pine است. یک خط. بدون خط دوم. بدون گیومه روی صفحه. بدون کلمهٔ Main. بدون کلمهٔ Pine.

📊 Which line the screen shows

خط	صفحه
`using System;`	چیزی از این خط نیست
`public class Pine`	چیزی از این خط نیست
`public static void Main()`	چیزی از این خط نیست
`Console.WriteLine("pine")`	`pine`

مردم چه چیزی را اشتباه می‌خوانند

اشتباه معمول این است که فایل را از بالا بخوانند و فرض کنند آشناترین کلمه خروجی است. Main مهم به نظر می‌رسد، و مهم است، چون runtime این شکل را بدون آن شروع نمی‌کند. اهمیت خروجی نیست. می‌توانید با انگشت خط Main را بپوشانید و خط نوشتن هنوز Console.WriteLine("pine"); است. نمی‌توانید خط نوشتن را بپوشانید و هنوز صفحه را توضیح دهید. اشتباه دیگر این است که بگویید صفحه Pine نشان می‌دهد چون کلاس Pine نام دارد. صفحه از کلمه بین گیومه‌ها استفاده می‌کند و آن کلمه با p کوچک نوشته شده. اشتباه سوم شمردن خط‌هاست. فایل چند خط و چند آکولاد نشان می‌دهد. صفحه یکی نشان می‌دهد. آکولادها، کلمه‌های public و static و void، نام Main، نام Pine، و using System; همه بعد از اجرا هنوز در فایل‌اند. اجرا آن‌ها را پاک نمی‌کند. چاپشان هم نمی‌کند.

صفحه از یک خط می‌آید

می‌توانید انگشت روی Console.WriteLine("pine"); بگذارید و بگویید صفحه از این خط می‌آید. می‌توانید انگشت روی public static void Main() بگذارید و بگویید runtime از آنجا شروع می‌کند و کلمهٔ Main روی صفحه نیست. می‌توانید انگشت روی public class Pine بگذارید و بگویید این نام با نوع آموزشی یکی است و با صفحه یکی نیست. صفحهٔ بعد یادداشتی در فایل می‌گذارد. یادداشت برای کسی است که فایل را می‌خواند. صفحه هنوز pine خواهد بود، چون یادداشت WriteLine دوم نیست.
عادت‌های باقی‌ماندهٔ Java با System.out.println("mint") را هنگام تمرین خط نوشتن C# از این صفحه دور نگه دارید. ساختن مسیرهای ASP.NET را از این صفحه دور نگه دارید. دانستن dotnet --version به‌عنوان کلمهٔ صفحه را از این صفحه دور نگه دارید — خط نسخه اثبات نصب بود، نه خروجی این برنامه. وقتی می‌توانید خط نوشتن را نام ببرید و حدس‌های غلط از Main و Pine را رد کنید، First Program کارش را کرده و اگر ادامه دهید برای C# Comments آماده‌اید.

🧠 دانش خود را بیازمایید

آماده شروع

دانش خود را بیازمایید

خود را با این آزمون تعاملی به چالش بکشید و ببینید موضوع را چقدر خوب درک کرده‌اید

❓

سوالات

🎯

70%

برای قبولی

♾️

∞

زمان

🔄

∞

تلاش‌ها

📝 دستورالعمل‌ها

هر سوال را با دقت بخوانید
بهترین پاسخ را برای هر سوال انتخاب کنید
می‌توانید آزمون را هر چند بار که می‌خواهید تکرار کنید
پیشرفت شما در بالا نمایش داده می‌شود