کار با Thread ها در زبان سی شارپ :: آشنایی با کلاس Timer

خیلی وقت ها در برنامه ها نیاز است که کد ما در بازه های زمانی مشخص اجرا شود، برای مثال کدی که باید هر 5 ثانیه یا هر یک دقیقه یکبار اجرا شده و عملیات خاصی را انجام دهد، مانند نمایش تاریخ و ساعت در برنامه و یا بررسی ایمیل ها و مطلع کردن کاربر از ایمیل های جدید. برای شرایطی از این قبیل می توانیم از کلاس Timer که در فضای نام System.Threading قرار گرفته و وابسته به delegate ای با نام TimerCallback است استفاده کنیم. برای آشنایی بیشتر با این کلاس برنامه ای در محیط کنسول می نویسیم که زمان جاری را تا زمانی که کاربر کلیدی را فشار دهد بر روی خروجی نمایش می دهد. ابتدا یک متد با نام PrintTime به صورت زیر ایجاد می کنیم:

public static void PrintTime(object state)
{
    Console.WriteLine(DateTime.Now.ToString("hh:mm:ss"));
}

کار این متد نمایش تاریخ به صورت ساعت:دقیقه:ثانیه می باشد. دقت کنید که این متد یک پارامتر از نوع object و با نام state میگیرد. دلیل وجود این پارامتر به این خاطر است که TimerCallback که delegate مورد استفاده در کلاس Timer است متدی با این Signature قبول می کند. در قدم بعدی باید یک شئ از کلاس Timer ایجاد کنیم. علاوه بر اینکه باید TimerCallback را نیز ایجاد کنیم، کلاس Timer به عنوان سازنده به ما این اجازه را می دهد تا پارامترهای مورد نیاز برای آماده سازی Timer را به آن ارسال کنیم، مانند بازه زمانی که کد مورد نظر باید اجرا شود، شئ ای که به عنوان state در زمان فراخوانی متد مورد نظر به آن ارسال می شود و مدت زمان مکس قبل از اولین فراخوانی متد مشخص شده برای Timer. کد زیر را در متد Main می نویسیم:

static void Main(string[] args)
{
    TimerCallback callback = new TimerCallback(PrintTime);

    Timer timer = new Timer(callback, null, 0, 1000);
    Console.WriteLine("Press any key to terminate application...");
    Console.ReadKey();
}

لیست پارامترها

همانطور که مشاهده می کنید ابتدا شئ ای از روی TimerCallback ایجاد کرده، در قدم بعدی کلاس Timer را به همراه پارامتر های مورد نیاز ایجاد کردیم. پارامتر ها به ترتیب:

  1. شئ ای از نوع TimerCallback
  2. شئ ای که برای state استفاده می شود که در کد بالا مقدار null ارسال شده است
  3. مقدار زمان مکس قبل از اولین فراخوانی متد مشخص شده برای Timer
  4. بازه های زمانی برای اجرای متد PrintTime که در اینجا 1000 میلی ثانیه یا 1 ثانیه یکبار است.

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

Press any key to terminate application...
06:40:06
06:40:07
06:40:08
06:40:09
06:40:10
06:40:11

برای مشخص کردن state پارامتر دوم را می توانیم تغییر دهیم، برای نمونه کد PrintNumbers را به صورت زیر تغییر می دهیم:

public static void PrintTime(object state)
{
    Console.WriteLine(DateTime.Now.ToString("hh:mm:ss") + " {0}", state);
}

و سپس شئ مورد نظر را از متد Main به صورت زیر به سازنده Timer به عنوان پارامتر دوم ارسال می کنیم:

Timer timer = new Timer(callback, "State from Main Method!", 0, 1000);

با اجرای کد بالا خروجی به صورت زیر خواهد بود:

Press any key to terminate application...
06:42:10 State from Main Method!
06:42:11 State from Main Method!
06:42:12 State from Main Method!
06:42:13 State from Main Method!
06:42:14 State from Main Method!
06:42:15 State from Main Method!

از سری مباحث کار با Thread ها موضوع CLR ThreadPool باقی مانده که در قسمت بعد در مورد آن صحبت کرده و پس از آن کار با Task Parallel Library را شروع خواهیم کرد.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

کار با Thread ها در زبان سی شارپ :: آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

زمانی که ما برنامه های Multi-Threaded می نویسیم، برخی اوقات Thread های ایجاد شده به داده های مشترک در سطح برنامه دسترسی دارند و وظیفه ما به عنوان برنامه نویس این است که مطمئن باشیم دسترسی چند Thread به داده های مشترک باعث بروز مشکل نمی شود. برای آشنایی بیشتر با این موضوع شرایطی را در نظر بگیرید که یک متد قرار است در چندین thread مختلف به صورت جداگانه اجرا شود، بعد از شروع کار هر thread زمانبندی اجرا توسط CLR به هر thread به صورت خودکار انجام شده و ما نمی توانیم دخالتی در این موضوع داشته باشیم، ممکن است در این بین اختصاص زمان به یک thread بیش از thread دیگر انجام شود و در این بین خروجی مناسب مد نظر ما ایجاد نمی شود. برای آشنایی با این موضوع متد PrintNumbers که در زیر تعریف کردیم را در نظر بگیرید:

public static void PrintNumbers()
{
    Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
    for (int counter = 0; counter  <  10 ;  counter++)
    {
        Thread.Sleep(200*new Random().Next(5));
        Console.Write("{0},", counter);
    }
    Console.WriteLine();
}

در مرحله بعد متد Main را به صورت زیر تغییر می دهیم تا 10 thread ایجاد شده و سپس کلیه thread ها اجرا شوند:

Thread[] threads = new Thread[10];

for (int index = 0; index  <  10 ;  index++)
{
    threads[index] = new Thread(PrintNumbers);
    threads[index].Name = string.Format("Worker thread #{0}.", index);
}

foreach (var thread in threads)
{
    thread.Start();
}

Console.ReadLine();

همانطور که مشاهده می کنید کلیه thread ها به صورت همزمان اجرا می شوند، اما پس از اجرا کد بالا، خروجی برای بار اول به صورت خواهد بود، البته دقت کنید که با هر بار اجرا خروجی تغییر می کند و ممکن است برای بار اول خروجی زیر برای شما تولید نشود:

Worker thread #0. is printing numbers  >  Worker thread #1. is printing numbers  >  Worker thread #2. is printing numbers  >  Worker thread #3. is printing numbers  >  0,Worker thread #4. is printing numbers  >  0,1,1,2,3,2,Worker thread #5. is printing numbers  >  0,4,3,1,4,2,5,Worker thread #6. is printing numbers  >  5,3,Worker thread #7. is printing numbers  >  4,6,6,0,Worker thread #8. is printing numbers  >  Worker thread #9. is printing numbers  >  0,0,7,5,7,0,1,0,1,0,6,8,8,1,2,1,1,0,2,9,
7,3,2,2,9,
2,1,8,3,3,3,4,2,1,9,
4,4,4,5,3,3,5,5,5,6,2,6,6,7,6,4,4,7,7,8,9,
8,9,
7,8,9,
5,5,3,8,6,7,8,9,
6,7,8,9,
4,5,9,
6,7,8,9,

اگر برنامه را مجدد اجرا کنید خروجی متفاوتی از خروجی قبلی دریافت خواهیم کرد:

Worker thread #0. is printing numbers  >  Worker thread #1. is printing numbers  >  Worker thread #2. is printing numbers  >  Worker thread #3. is printing numbers  >  Worker thread #4. is printing numbers  >  Worker thread #5. is printing numbers  >  Worker thread #6. is printing numbers  >  0,Worker thread #7. is printing numbers  >  1,2,0,1,3,2,4,3,Worker thread #8. is printing numbers  >  Worker thread #9. is printing numbers  >  0,0,0,0,0,0,5,4,5,6,7,8,9,
6,7,8,9,
1,1,0,0,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,4,5,6,7,8,9,
3,3,3,3,3,4,4,4,4,5,6,7,8,9,
5,6,7,8,9,
5,6,7,5,6,7,8,9,
8,4,4,4,5,5,6,6,7,7,9,
5,8,8,6,9,
9,
7,8,9,

همانطور که مشاهده می کنید خروجی های ایجاد کاملاً با یکدیگر متفاوت هستند. مشخص است که در اینجا مشکلی وجود دارد و همانطور که در ابتدا گفتیم این مشکل وجود همزمانی یا Concurrency در زمان اجرای thread هاست. زمابندی CPU برای اجرای thread ها متفاوت است و با هر بار اجرا زمان های متفاوتی به thread ها برای اجرا تخصیص داده می شود. اما خوشبختانه مکانیزم های مختلفی برای رفع این مشکل و پیاده سازی Synchronizqation وجوددارد که در ادامه به بررسی راهکاری های مختلف برای حل مشکل همزمانی می پردازیم.

پیاده سازی Synchronization با کلمه کلیدی lock

اولین مکانیزم مدیریت همزمانی در زمان اجرای Thread ها استفاده از کلمه کلیدی lock است. این کلمه کلیدی به شما این اجازه را می دهد تا یک scope مشخص کنید که این scope باید به صورت synchronized بین thread ها به اشتراک گذاشته شود، یعنی زمانی که یک thread وارد scope ای شد که با کلمه کلیدی lock مشخص شده، thread های دیگر باید منتظر شوند تا thread جاری که در scope قرار دارد از آن خارج شود. برای استفاده از lock شما اصطلاحاً می بایست یک token را برای scope مشخص کنید که معمولاً این کار با ایجاد یک شئ از نوع object و مشخص کردن آن به عنوان token برای synchronization استفاده می شود. شیوه کلی استفاده از lock به صورت زیر است:

lock(token)
{
    // all code in this scope are thread-safe
}

اصطلاحاً می گویند کلیه کدهایی که در بدنه lock قرار دارند thread-safe هستند. برای اینکه کد داخل متد PrintNumbers به صورت thread-safe اجرا شود، ابتدا باید یک شئ برای استفاده به عنوان token در کلاس Program تعریف کنیم:

class Program
{
    public static object threadLock = new object();

    ....

در قدم بعدی کد داخل متد PrintNumbers را به صورت زیر تغییر می دهیم:

public static void PrintNumbers()
{
    lock (threadLock)
    {
        Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
        for (int counter = 0; counter  <  10 ; counter++)
        {
            Thread.Sleep(200 * new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
}

با اعمال تغییر بالا، زمانی که thread جدیدی قصد وارد شدن به scope مشخص شده را داشته باشد، باید منتظر بماند تا کار thread جاری به اتمام برسد تا اجرای thread جدید شروع شود. با اعمال تغییر بالا، هر چند بار که کد نوشته شده را اجرا کنید خروجی زیر را دریافت خواهید کرد:

Worker thread #0. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #1. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #2. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #3. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #4. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #5. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #6. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #7. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #8. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,
Worker thread #9. is printing numbers  >  0,1,2,3,4,5,6,7,8,9,

پیاده سازی Synchronization بوسیله کلاس Monitor

در قسمت قبل که از کلمه کلیدی lock استفاده کردیم، در حقیقت به در پشت زمینه از کلاس Monitor که در فضای نام System.Threading قرار دارد استفاده شده است. زمانی که از کلمه کلیدی lock استفاده می کنیم این کد تبدیل به کدی می شود که از Monitor برای پیاده سازی Synchronization استفاده می کند (می توان این موضوع را با ابزار ildasm.exe و مشاهده کد IL متوجه شد). نحوه استفاده از کلاس Mutex را در کد زیر که تغییر داده شده متد PrintNumbers است مشاهده می کنید:

public static void PrintNumbers()
{
    Monitor.Enter(threadLock);            
    try
    {
        Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
        for (int counter = 0; counter  <  10 ; counter++)
        {
            Thread.Sleep(200*new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
    finally
    {
        Monitor.Exit(threadLock);
    }
}

متد Enter در کلاس Monitor اعلام می کند که thread ای وارد محدوده ای شده است که باید thread-safe باشد. به عنوان پارامتر ورودی برای این متد token ایجاد شده یعنی obj را ارسال می کنیم. در قدم بعدی کل کدی که مربوط به ناحیه thread-safe است باید داخل بدنه try-catch نوشته شود و البته بخش finaly نیز برای آن نوشته شده باشد، همانطور که می دانید بخش finally قسمتی از بدنه try است که در هر صورت اجرا می شود. در قسمت finally متد Exit را با پارامتر threadLock که همان token مربوطه است فراخوانی می کنیم، یعنی thread در حال اجرا از محدوده thread-safe خارج شده است. دلیل نوشتن try-catch در کد بالا این است که در صورت وقوع خطا عملیات خروج از محدوده thread-safe در هر صورت انجام شود و thread های دیگر منتظر ورود به این محدوده نمانند. شاید این سوال برای شما بوجود بیاید که با وجود کلمه کلیدی lock چه دلیلی برای استفاده از کلاس Monitor وجود دارد؟ دلیل این موضوع کنترل بیشتر بر روی ورود thread ها و اجرای کدهای thread-safe است. برای مثال، بوسیله متد Wait در کلاس Monitor می توان مشخص کرد که یک thread چه مدت زمانی را برای ورود به ناحیه thread-safe باید منتظر بماند و همچنین متدهای Pulse و PulseAll را می توان برای اطلاع رسانی به سایر thread ها در مورد اینکه کار thread جاری به اتمام رسیده استفاده کرد. البته در اکثر موقعیت ها استفاده از کلمه کلیدی lock کافی است و نیازی به استفاده از کلاس Monitor نمی باشد.

پیاده سازی Synchronization با استفاده از کلاس Interlocked

زمانی که قصد داریم مقدار یک متغیر را تغییر دهیم یا عملگرهای ریاضی را بر روی دو متغیر اعمال کنیم، عملیات های انجام شده به دو صورت Atomic و Non-Atomic انجام می شوند. مبحث عملیات عملیات های Atomic چیزی بیش از چند خط نیاز دارد تا توضیح داده شود، اما به طور خلاصه می توان گفت که عملیات های Atomic عملیات هایی هستند که تنها در یک مرحله یا step انجام می شوند. اگر کدهای IL مرتبط به مقدار دهی متغیرها و البته عملگرهای ریاضی را بر روی بیشتر نوع های داده در دات نت مشاهده کنیم میبینیم که این عملیات ها بیشتر به صورت non-atomic هستند، یعنی بیش از یک مرحله برای انجام عملیات مربوط نیاز است که این موضوع می تواند در برنامه های Multi-threaded مشکل ساز شود. در حالت ساده می توان بوسیله مکانیزم lock عملیات synchronization را برای این عملیات ها پیاده سازی کرد:

int value = 1;
lock(token)
{
    value++;
}

اما برای شرایطی مانند مثال بالا استفاده از lock یا کلاس monitor باعث ایجاد overhead اضافی می شود که برای حل این مشکل می توان از کلاس Interlocked برای اعمال synchronization در اعمال انتساب مقدار یا مقایسه مقادیر استفاده کرد. برای مثال، زمانی که می خواهیم مقدار یک متغیر را با استفاده از کلاس Interlocked اضافه کنیم به صورت می توانیم این کار را پیاده سازی کنیم:

int myNumber = 10;
Interlocked.Increment(ref myNumber);

متد Increment در کلاس Interlocked یک مقدار به متغیر مشخص شده اضافه می کند و البته این کار در محیط Thread-Safe انجام می شود. برای کاهش مقدار می توان از متد Decrement به صورت مشابه استفاده کرد:

int myNumber = 10;
Interlocked.Decrement(ref myNumber);

همچنین برای مقایسه و مقدار دهی مقدار یک متغیر می توان از متد CompareExchange استفاده به صورت زیر استفاده کرد:

int myNumber = 10;
Interlocked.CompareExchange(ref myNumber, 15, 10);

در کد بالا در صورتی که مقدار متغیر myNumber برابر 10 باشد، مقدار آن با 15 عوض خواهد شد.

پیاده سازی Synchronization بوسیله خاصیت [Synchronization]

می دانیم که خاصیت [Synchronization] زمانی که بر روی یک کلاس قرار میگیرد، باعث می شود که کد داخل آن کلاس به صورت Thread-Safe اجرا شود. در این قسمت می خواهیم کد مربوط به متد PrintNumbers را به صورت Thread-Safe و با کمک Object Context Boundry و همچنین خاصیت [Synchronization] پیاده سازی کنیم. برای این کار ابتدا یک کلاس با نام Printer پیاده سازی کرده و متد PrintNumbers را داخل آن قرار می دهیم. دقت کنید که کلاس Printer می بایست از کلاس ContextBoundObject مشتق شده باشد و خاصیت [Synchronization] بر روی آن قرار گرفته باشد:

[Synchronization]
public class Printer : ContextBoundObject
{
    public void PrintNumbers()
    {
        Console.Write("{0} is printing numbers  >  " , Thread.CurrentThread.Name);
        for (int counter = 0; counter  <  10 ; counter++)
        {
            Thread.Sleep(200*new Random().Next(5));
            Console.Write("{0},", counter);
        }
        Console.WriteLine();
    }
}

پس از انجام تغییرات بالا متد Main را به صورتی تغییر می دهیم که از متد Print در کلاس Printer استفاده کند:

Printer printer = new Printer();

Thread[] threads = new Thread[10];

for (int index = 0; index  <  10 ; index++)
{
    threads[index] = new Thread(printer.PrintNumbers);
    threads[index].Name = string.Format("Worker thread #{0}.", index);
}

foreach (var thread in threads)
{
    thread.Start();
}

Console.ReadLine();

با انجام کارهای بالا و اجرای برنامه مشاهده خواهیم کرد که با وجود عدم استفاده از کلمه کلیدی lock یا کلاس Monitor، برنامه به صورت Thread-Safe اجرا شده و خروجی مناسب برای ما تولید می شود. در اینجا مبحث مربوط به Synchronization به اتمام رسیده و در قسمت در مورد کلاس Timer در فضای نام System.Threading صحبت خواهیم کرد.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

اشکالات

پلتفرم

منبع چارچوب دات‌نت مایکروسافت برای اجرا فقط ویندوز است. پیاده‌سازی‌های دیگری برای اجرای برنامه‌های #C در ویندوز، لینوکس،BSD یا Mac OS X وجود دارند اما هنوز کامل نیستند: Mono و DotGNU در نوامبر سال ۲۰۰۲ توسط مایکروسافت (نسخه ۱٫۰) برای پیاده‌سازی CLI برای کار در Free BSD و Mac OS X ۱۰٫۲ ارائه شد، اما نسخه‌های بعدی آن‌ها فقط قابل اجرا بر رویویندوز بود.

پیشرفت در آینده

نسخه بعدی این زبان، سی شارپ ۴ است که از اکتبر سال ۲۰۰۸ در حال ساخته شدن است. مایکروسافت لیستی از ویژگی‌های جدید سی شارپ ۴ را در کنفرانس توسعه دهندگان حرفه‌ای اعلام کرده‌است. تمرکز اصلی در ورژن بعدی روی قابلیت هماهنگی فریم ورک‌ها و نوع زبان‌هایی است که کامال پویا یا قیمتی پویا هستند، مانند dynamic language runtime و COM. ویژگی‌های زیر تاکنون اعلام شده‌اند:

پارامترهای نوع generic از نوع Covariant و contravariant

پارامترهای واسط‌های generic و deletageها می‌توانند با استفاده از کلمات out و in از دو نوع Covariant و contravariant باشند. این تعیین نوع‌ها بعداً برای تبدیل انواع به یکدیگر، چه از نوع صریح یا مجازی و چه از نوع compile-time یا run-time به کار می‌رود. به عنوان مثال، واسط IEnumerable<T> در زیر دوباره تعریف شده‌است:

interface IEnumerable < out T >
{
  IEnumerator < T > GetEnumerator();
}

بنابراین، هر کلاس مشتق شده‌ای که از IEnumerable<Derived> استفاه کرده باشد، با تمام کلاس‌های پایه که IEnumerable<Base> را دارند سازگار است. به عنوان تمرین، کد زیر نوشته شده‌است:

void PrintAll(IEnumerable < object > objects)
{
  foreach (object o in objects)
  {
    Console.WriteLine(o);
  }
}

IEnumerable < string > strings = new List < string > ();
PrintAll(strings);// IEnumerable<string> is implicitly converted to IEnumerable < object >

برای contravariance، رابط IComparer < T > به صورت زیر دوباره تعریف شده‌است:

 public interface IComparer < in T >
{
    int Compare(T x, T y);
}

بنابراین، هر کلاسی که IComparer < Base > را برای یک کلاس پایه بیان می‌کند، با IComparer < Derived > در تمام واسط‌ها و کلاس‌هایی که از آن کلاس پایه مشتق شده‌اند، سازگار است. این امر نوشتن کد زیر را میسر می‌سازد:

IComparer < object > objectComparer = GetComparer();
IComparer < string > stringComparer = objectComparer;IComparer < object > objectComparer = GetComparer();
IComparer < string > stringComparer = objectComparer;

جستجوی عضو پویا

در سامانه انواع داده‌های #C یک نوع جدید با نام شبه-نوع معرفی شده‌است که مانند System.Object رفتار می‌کند، ولی در ادامه، هر دسترسی به اعضا یا برنامه‌هایی که از این نوع استفاده می‌کنند، بدون چک شدن نوع داده‌هایشان اجازه کار دارند و تجزیه آن‌ها تا زمان اجرا به تعویق می‌افتد. به عنوان مثال:

// Returns the value of Length property or field of any object
  int GetLength(dynamic obj)
  {
    return obj.Length;
  }

  GetLength("Hello, world");// a string has a Length property,
  GetLength(new int[] { 1, 2, 3 });// and so does an array,
  GetLength(42);// but not an integer - an exception will be thrown here at run-time

صدا زده شدن‌های متد پویا، مانند پارامترهای صریح یا مجازی با مقدار نوع dynamic راه‌اندازی می‌شوند. به عنوان مثال:

 void Print(dynamic obj)
  {
     Console.WriteLine(obj);// which overload of WriteLine() to call is decided at run-time
  }

  Print(123);// ends up calling WriteLine(int)
  Print("abc");// ends up calling WriteLine(string)

جستجوی پویا تحت سه مکانیزم مشخص اجرا می‌شود: COM IDispatch برای اشیاء COM، رابط IDynamicObject DLR برای اشیاء دارای این واسط و Reflection برای بقیه اشیا؛ بنابراین هر کلاس #C می‌تواند صدا زده شدن‌های پویای خود را با اجرای IDynamicObject در نمونه‌های خود جدا کند. در مورد متدهای پویا و مشخص‌کننده صدا زدن‌ها، تجزیه و تحلیل اضافه بار مطابق انواع اصلی که به عنوان آرگومان‌ها هستند، در زمان اجرا اتفاق می‌افتد، در غیر این صورت بر اساس قوانین تجزیه و تحلیل اضافه بار #C عمل خواهد شد. به علاوه، در مواردی که در صدا زدن پویا، گیرنده خودش پویا نیست، تجزیه و اضافه بار زمان اجرا تنها به متدهایی که در زمان کامپایل به صورت گیرنده ظاهر شده‌اند، رسیدگی می‌کند. به عنوان مثال:

class Base
{
  void Foo(double x);
}

class Derived: Base
{
  void Foo(int x);
}

dynamic x = 123;
Base b = new Derived();
b.Foo(x);// picks Base.Foo(double) because b is of type Base, and Derived.Foo(int) is not exposed
dynamic b1 = b;
b1.Foo(x);// picks Derived.Foo(int)

هر مقداری که توسط دستیابی به عضو پویا برگردانده شده باشد، خودش از نوع پویا است. مقادیر نوع پویا به سایر نوع‌ها و از سایر نوع عا قابل تبدیل هستند. در نمونه کد بالا، این امر به تابع GetLength اجازه با مقدار بازگردانده شده از Length بدون هیچ صریحی به عنوان integer استفاده کند. در زمان اجرا، مقدار واقعی به نوع خواسته شده تبدیل می‌شود.

کلمه کلیدی اختیاری ref

در حال حاضر کلمه کلیدی ref برای متدهای صدا زننده اختیاری است. کد زیر را در نظر بگیرید:

void Increment(ref int x)
{
  ++x;
}

int x = 0;
Increment(ref x);

به صورت زیر هم می‌تواند نوشته شود:

void Increment(ref int x)
{
  ++x;
}

int x = 0;
Increment(x);

آرگومان‌های نام‌گذاری شده و پارامترهای اختیاری

در سی شارپ ۴ پارامترهای اختیاری ای با مقادیر پیش‌فرض موجود در ++C معرفی می‌شوند. به عنوان مثال:

void Increment(ref int x, int dx = 1)
{
  x += dx;
}

int x = 0;
Increment(ref x);// dx takes the default value of 1
Increment(x, 2);// dx takes the value 2

به علاوه، برای کامل کردن پارامترهای اختیاری، می‌توانید صریحاً نام پارامترها را در صدازدن‌های متدها تعیین کنید. این کار به شما اجازه تصویب کردن انتخابی برای هر زیر مجموعه اختیاری از پارامترهای متد را می‌دهد. تنها محدودیت موجود این است که پارامترهای نام دار باید بعد از پارامترهای بدون نام بیایند. نام پارامترها می‌توانند برای هر دو نوع پارامترهای اختیاری و ضروری تعیین شوند و می‌توانند برای بهبود خوانایی و فراخوانی دوباره آرگومان‌ها مفید باشند. به عنوان مثال:

Stream OpenFile(string name, FileMode mode = FileMode.Open, FileAccess access = FileAccess.Read) { ... }

OpenFile("file.txt");// use default values for both "mode" and "access"
OpenFile("file.txt", mode: FileMode.Create);// use default value for "access"
OpenFile("file.txt", access: FileAccess.Read);// use default value for "mode"
OpenFile(name: "file.txt", access: FileAccess.Read, mode: FileMode.Create);// name all parameters for extra readability, and use order different from method declaration

پارامترهای اختیاری inter-operating را با COMراحت تر می‌کنند. در گذشته، #C مجبور بود تمام پارامترهای متد سازنده COM را پشت سر بگذارد، حتی آنهایی را که اختیاری بودند؛ به عنوان مثال:

object fileName = "Test.docx";
object missing = System.Reflection.Missing.Value;

doc.SaveAs(ref fileName,
    ref missing, ref missing, ref missing,
    ref missing, ref missing, ref missing,
    ref missing, ref missing, ref missing,
    ref missing, ref missing, ref missing,
    ref missing, ref missing, ref missing);

با پشتیبانی از پارامترهای اختیاری، کد بالا می‌تواند به صورت زیر خلاصه بشود:

doc.SaveAs("Test.docx");

کتابخانه‌ها

جزئیات مشخصات سی شارپ، حداقل تعداد نوع‌ها و کتابخانه‌های کلاس است که کامپایلر نیاز به وجود آن‌ها دارد. عملاً، اغلب سی شارپ توسط بیشترین استفاده از CLI را می‌کند، که استاندارد شده ECMA-۳۳۵ است.

مثال Hello world

در زیر یک مثال ساده از برنامه سی شارپ آمده‌است، نسخه‌ای از مثال کلاسیک Hello World:

class ConsoleApp1
{
    static void Main()
    {
        // a first program in C#.net
        System.Console.Write("Hello, World!");
    }
}

نتیجه، چاپ شدن متن زیر در خروجی است:

Hello, world!

هر خط هدفی دارد:

class ExampleClass

در بالا، تعریف کلاس آمده‌است. هر چیزی که در بین در علامت پرانتز باشد،ExampleClass را توصیف می‌کند:

static void Main()

این یک تابع عضو کلاس را در زمان شروع اجرای برنامه اعلان می‌کند. دات نت در زمان اجرا، تابع Main را صدا می‌زند (نکته: Main ممکن است از هر جای دیگری نیز صدا زده شود، مثلاً توسط تابع ExampleClass و با کد ()Main). کلمه کلیدی static تابع را بدون داشتن نمونه‌ای از ExampleClass قابل دسترس می‌کند. هر تابع Main در هر کنسولی باید به صورت static تعریف شود. در غیر این صورت برنامه به یک نمونه نیاز خواهد داشت و هر نمونه به یک برنامه نیاز دارد. برای اجتناب از این وابستگی دایره‌ای تجزیه ناپذیر، کامپایلرهای سی شارپ در صورت Static نبودن تابع Main، یک خطا اعلام می‌کنند. کلمه کلیدی void نشان دهنده این است که تابع Main هیچ مقداری را برنمی‌گرداند.

Console.WriteLine("Hello, world!");

خط بالا، خروجی را می‌نویسد. در فضای اسم System, Console یک کلاس استاتیک است که یک میانجی بین ورودی، خروجی و خطای کنسول می‌باشد. برنامه‌ای که متدWriteLine را از کنسول صدا می‌زند، خروجی رشته «Hello, world!» را در خروجی نمایش می‌دهد.

استانداردسازی

در آگوست سال ۲۰۰۰، شرکت مایکروسافت، و Hewlett-Packard و شرکت اینتل به عنوان پشتیبان مشخصات سی شارپ را مانند CLI به سازمان استانداردسازی ECMA ارائه کردند. در دسامبر سال ۲۰۰۱، این سازمان، ECMA-۳۳۴ را با عنوان مشخصات زبان #C منتشر کرد. سی شارپ در سال ۲۰۰۳ به عنوان یک استاندارد ISO به ثبت رسید(ISO/IEC ۲۳۲۷۰). در سال ۲۰۰۲، ECMA دومین ویرایش از خصوصیات زبان سی شارپ را پذیرفت.

در ژوئن سال ۲۰۰۵، ECMA سومین ویرایش را با اضافه کردن مواردی همچون کلاس‌های partial، متدهای ناشناس، انواع nullable و Genericها منتشر کرد. در ژوئیه ۲۰۰۵، ECMA استانداردها و TRها را همراه با پردازش Fast-Track اخیر به ISO/IEC JTC پیشنهاد کرد. این روند معمولاً ۶ تا ۹ ماه زمان می‌برد. آخرین ویرایش این زبان در ۱۵ آگوست سال ۲۰۱۲ در قالب Framework ۴٫۵ارائه گردید

کارایی

با توجه به توابع موجود در چارچوب دات‌نت امکان استفاده از این توابع وجود دارد که می‌توان گفت برای هر کاری شرکت مایکروسافت تابعی پیش‌بینی کرده؛ که این امکان را ایجاد می‌کند که به فایل اصلی پروژه هیچ فایل کتابخانی را اضافه نکنید (هم به صورت دستی یا خود کامپایلر). این موضوع خود باعث ایجاد فایل‌های خروجی با حجم بسیار کم می‌شود. این موضوع در بسیاری از موارد بسیار اهمیت دارد. برنامه‌های سی شارپ، همچون تمام برنامه‌های نوشته شده در چارچوب دات‌نت و سایر محیط‌های ماشینی مجازی مانند جاوا، نیازمند منابع سامانه و حافظه بیشتری نسبت به برنامه‌های نوشته شده با سایر زبان‌ها مانند سی پلاس پلاس است و هم چنین سرعت کمتری نیز دارد. هر چند تعریف زبان سی شارپ و CLI تحت استانداردهای ISO و ECMA استاندارد شده‌اند،CLI تنها قسمتی از Base Class Library (BCL) مایکروسافت می‌باشد که شامل کلاس‌های غیر استاندارد استفاده شده در برنامه‌های #C نیز می‌شود. از این گذشته، بعضی از قسمت‌های BCL تحت حق امتیاز مایکروسافت هستند که ممکن است پیاده‌سازی کامل framework را مختل کند، زیرا تنها بخش‌های استاندارد دارای حق محافظت RAND در برابر مدعیان را دارند.

پیاده‌سازی‌ها

متداول‌ترین کامپایلر سی شارپ، Microsoft Visual C# می‌باشد.

کامپایلرهای سی شارپ
  • پروژه Microsoft Rotor (در حال حاضر به عنوان Shared Source Common Language Infrastructure شناخته می‌شود) (ثبت شده فقط برای استفاده آموزشی و تحقیقی) یک پیاده‌سازی منبع اشتراکی از CLR Runtime را فراهم می‌آورد و یک کامپایلر سی شارپ، و یک زیرمجموعه از کتابخانه]] CLI Framework مورد نیاز.
  • پروژه Mono یک اوپن سورس از کامپایلر سی شارپ است، یک پیاده‌سازی اوپن سورس کامل از CLI شامل کتابخانه‌های Framework مورد نیاز که در ECMA ظاهر شده‌اند، و یک پیاده‌سازی کامل نزدیک به بقیه کتابخانه‌های اختصاصی کلاس چارچوب دات‌نت مایکروسافت.
  • پروژه DotGNU نیز یک اوپن سورس از کامپایلر سی شارپ است، که پیاده‌سازی آن بسیار نزدیک به Common Language Infrastructure می‌باشد و کتابخانه‌های framework مورد نیاز موجود در ECMA و زیر مجموعه‌ای از کلاس‌های کتابخانه‌ای شخصی مایکروسافت در دات نت و دات نت ۲ را دربردارد.

کاملاً شبیه به پروژه Mono.

نام زبان

اسم سی شارپ از علامت موسیقی شارپ گرفته شده‌است که در موسیقی بیان گر این است که متن نوشته شده باید نیم قدم از خط بالاتر باشد. مطابق با ECMA-۳۳۴، بخش ۶، مخفف‌ها و اختصارها، نام زبان به صورت «#C» نوشته می‌شود(«کلمه لاتین C (U+۰۰۴۳) به همراه علامت عددی #(U+۰۰۲۳)») که به صورت «سی شارپ» تلفظ می‌شود. علامت «#» نباید با علامت شارپدر موسیقی(♯، U+266F) که در یک صفحه کلید استاندارد وجود ندارد اشتباه گرفته شود. پسوند شارپ، توسط بسیاری دیگر از زبان‌های دات نت مانند #J، #A و #F نیز به کار رفته‌است. پیاده‌سازی اولیه از زبان ایفل تحت دات نت نیز #Eiffel نام داشت که الان زبان ایفل را به‌طور کامل پشتیبانی می‌کند. هم چنین این پسوند بعضی وقت‌ها در کتابخانه‌ها نیز به کار می‌رود، مانند #Gtk، #Cocoa و#Qt.

کلمات اختصاری به کار رفته در این متن

منبع

آشنایی با #C قسمت 1
آشنایی با #C قسمت 2
آشنایی با #C قسمت 3

ویژگی‌های جدید در سی شارپ  ۳٫۰

این ورژن از سی شارپ در تاریخ ۱۹ نوامبر سال ۲۰۰۷ به عنوان بخشی از چارچوب دات‌نت ۳٫۵ عرضه شد؛ که شامل ویژگی‌های جدید الهام شده از زبان‌های برنامه‌نویسی اصلی (Functional) مانند Haskell و ML، و الگوی LINQ برای CLR است. در حال حاضر توسط هیچ موسسه استانداردسازی تأیید نشده‌است.

معرفی لینک

لینک (به انگلیسی: Language Integrated Query)(مخفف انگلیسی: LINQ) یک زبان پرس و جوی قابل انعطاف و همه منظوره برای بسیاری از انواع منبع داده‌ها است (مثل انتخاب اشیاء شناور، سندهای XML، بانک‌های اطلاعاتی و…) که در ویژگی‌های سی شارپ ۳ جمع شده‌اند. سینتکس زبان به زحمت از SQL گرفته شده‌است، برای مثال:

int[] array = { 1, 5, 2, 10, 7 };

// Select squares of all odd numbers in the array sorted in descending order
IEnumerable&lt;int&gt; query = from x in array
                         where x % 2 == 1
                         orderby x descending
                         select x * x;

مقدار دهی به اشیاء

Customer c = new Customer(); c.Name = "James";

عبارت بالا می‌تواند به صورت زیر نوشته شود:

Customer c = new Customer { Name="James" };

مقدار دهی Collection

MyList list = new MyList();
list.Add(1);
list.Add(2);

عبارت بالا می‌تواند به صورت زیر نوشته شود:

MyList list = new MyList { 1, 2 };

فرض کنید که اجزای MyList و System.Collections.IEnumerable دارای متد عمومی Add هستند.

انواع داده‌ای بی نام

var x = new { FirstName="James", LastName="Frank" };

سی شارپ ۲٫۰ توابع بی نام را معرفی کرد. سی شارپ ۳٫۰ هم انواع بی نام را معرفی می‌کند. با استفاده از این ویژگی برنامه نویسان قادر خواهند بود به صورت Inline انواع دلخواه خود را ایجاد کنند. به نمونه زیر توجه کنید:

static void Main(string[] args)
{
    var anonymousType = new { Name = string.Empty, Age = 0 };
}

کد ارائه شده، یک نوع بی نام را تعریف می‌کند که از طریق متغیر ضمنی محلی به نام anonymousType در اختیار قرار می‌گیرد.

چرا Anonymous types؟ انواع بی نام بهترین گزینه برای تولید Entity Typeها می‌باشند. همان‌طور که گفته شد Entity Typeها فقط حاوی داده‌ها هستند؛ بنابراین به بهترین نحو می‌توان داده‌های دریافت شده از کاربر را در انواع بی نام بسته‌بندی کرد.

نتیجه نوع متغیر محلی

var x = new Dictionary < string, List < float >> ();

کد بالا با کد زیر قابل تعویض می‌باشد:

Dictionary < string, List < float >> x = new Dictionary < string, List < float >> ();

این ویژگی تنها یک ntactic sugarراحت برای کوتاه‌تر بیان کردن متغیرهای محلی نمی‌باشد، بلکه برای تعریف متغیرهای بی نام لازم نیز است.

عبارات لامبدا

عبارات لامبدا یک راه کوتاه برای نوشتن مقادیر توابع بی نام کلاس اول را فراهم می‌کنند. دو مثال زیر را در نظر بگیرید:

listOfFoo.Where(delegate(Foo x) { return x.Size > 10; })
listOfFoo.Where(x = > x.Size > 10);

در مثال‌های فوق، عبارات لامبدا صرفاً یک نوع سینتکس برای delegateهای بی نام با مقادیر دارای بازگشت هستند. هر چند با توجه به نوع متن استفاده می‌شوند، کامپایلر سی شارپ می‌تواند لامبداها را به ASTها نیز تبدیل کند تا بعداً در زمان اجرا نیز بتوانند پردازش شوند. در مثال فوق، اگر listOfFoo یک مجموعه ساده داخل حافظه نباشد، ولی یک پوشه در اطراف جدول بانک اطلاعاتیمی‌باشد. این تکنیک می‌تواند برای بهینه کردن اجرا، برای ترجمه بدنه لامبدا به عبارت معادل آن در SQL استفاده شود. در هر یک از دو راه فوق، خود عبارت لامبدا دقیقاً شبیه کد به نظر می‌رسد، بنابراین روش استفاده در زمان اجرا، برای کاربر ناپیدا می‌باشد.

یکی از ویژگی‌هایی که سی شارپ ۲٫۰ ارائه کرد، توانایی تعریف توابع به صورت Inline بود که این ویژگی با عنوان توابع بی نام (anonymous methods) شناخته می‌شود. توابع بی نام در پاره‌ای مواقع بسیار مفیدند. اما نحو(syntax) به‌کارگیری آن‌ها دشوار می‌باشد. عبارات لامبدا ویژگی توابع بی نام را دارند اما با نحو ساده‌تری در سی شارپ ۳٫۰ معرفی شده‌اند. به نمونه زیر توجه کنید:

static void Main(string[] args)
{
   (int x) = > x + 1;// explicitly typed parameter
   (y, z) = > y * z;// implicitly typed parameter
}

تعریف عبارات لامبدا از نحو (syntax) خاصی پیرو می‌کند. همان‌طور که در کد بالا مشاهده می‌کنید، پارامترهای تابع هم به صورت صریح و هم به صورت ضمنی قابل بیان‌اند. کلمه return به صورت ضمنی حذف شده‌است. تابع معادل عبارت لامبدای اول به صورت زیر است:

int Fn(int x)
{
    return x+1;
}

لیست پارامترها و بدنه عبارت لامبدا توسط => از هم جدا می‌شوند. در صورتی که تعریف عبارت لامبدا بیشتر از یک خط کد باشد می‌توان بدنه آن را با استفاده از {} نشان داد.

static void Main(string[] args)
{
    (int x) = > { x + 1; return x * x; };
}

خواص خودکار

کامپایلر به‌طور خودکار یک متغیر نمونه خصوصی و قرار دهنده و قرار گیرنده مناسب تولید می‌کند، مانند:

public string Name { get; private set; }

توابع بسط داده شده

توابع بسط داده شده حالتی از سینتکس Suger هستند که امکان اضافه کردن متد جدید به کلاس موجود را بیرون از حوزه تعریف آن فراهم می‌کنند. در این مثال، تابع بسط داده شده یک تابع ایستا است که قابل فراخوانی توسط تابع مشابه می‌باشد. گیرنده فراخوانی مقید به اولین پارامتر تابع تحت عنوان this می‌باشد:

public static class StringExtensions
{
    public static string Left(this string s, int n)
    {
        return s.Substring(0, n);
    }
}

string s = "foo";
s.Left(3);// same as StringExtensions.Left(s, 3);

زبان سی شارپ کلمه کلیدی sealed را برای این منظور ارائه کرد که امکان ارث بری از یک کلاس را صلب کند. یعنی با اضافه شدن این کلمه کلیدی به ابتدای تعریف کلاس، امکان ارث بری از آن غیرممکن می‌شود. سی شارپ ۳٫۰ ویژگی جدیدی را در اختیار برنامه نویسان قرار می‌دهد به این صورت که می‌توان هر نوع کلاسی حتی کلاس‌های مهر شده با Sealed را با استفاده از Extension methodsبسط داد.

توابع جزئی

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

آرایه‌های نوع ضمنی

آرایه‌ها را نیز می‌توان با استفاده از کلمه کلیدی var تعریف کرد.

static void Main(string[] args)
{
    var a = new[] { 1, 10, 100, 1000 };// int[]
    var b = new[] { 1, "one", 2 };// Error
}

پیش پردازنده

ویژگی «دستورها پیش پردازنده» سی شارپ (اگرچه آن‌ها به واقع یک پیش پردازنده نیستند) مبنی بر دستورها پیش پردازنده C است که به برنامه‌نویس اجازه تعریف سمبلهایی را می‌دهند. برخی از این دستورها عبارتند از: #if، #region، #define. راهنماهایی نظیر #region تذکراتی به ویرایش‌گرها برای code folding می‌دهند.

توضیحات کد

توضیحات تک خط با استفاده از دو اسلش تعریف می‌شوند(//) و توضیحات چند خطی با /* شروع و به */ تمام می‌شوند.

public class Foo
{
// a comment
    public static void Bar(int firstParam) {}//Also a comment
}

public class FooBar
{
    /* a comment */
    public static void BarFoo(int firstParam) {}  /* Also a comment */

توضیحات چند خطی هم چنین می‌توانند با /* شروع و با */ تمام شوند.

public class Foo
{
    /* A Multi-Line
       comment  */
    public static void Bar(int firstParam) {}
}

سامانه مستندسازی XML

سامانه مستندسازی #C بسیار شبیه به جاوا است، اما مبنی بر XML. دو شیوه مستندسازی در حال حاضر به وسیله کامپایلر #C پشتیبانی می‌شود.

توضیحات تک خطی، که معمولاً در تولیدکننده کد Visual Studioپیدا می‌شوند، با استفاده از/// شروع می‌شوند.

public class Foo
{
/// < summary > A summary of the method. < /summary >
/// < param name="firstParam" > A description of the parameter. < /param >
/// < remarks > Remarks about the method. < /remarks >
    public static void Bar(int firstParam) {}
}

توضیحات چند خطی، که در نسخه ۱٫۰ تعریف شدند، اما در نسخه ۱٫۱ پشتیبانی از آن‌ها وجود نداشت با /* شروع و به */ ختم می‌شوند:

public class Foo
{
    /** < summary > A summary of the method. < /summary >
     *  < param name="firstParam" > A description of the parameter. < /param >
     *  < remarks>Remarks about the method. < /remarks > */
    public static void Bar(int firstParam) {}
}

نکته:در اینجا یک ملاک سخت در مورد استفاده از فضاهای خالی در سندهای XML هنگام استفاده از /**وجود دارد:

/**
 * < summary >
 * A summary of the method. < /summary > */

نوع دیگری از کد بالا ارائه خواهد شد:

/**
 * < summary >
   A summary of the method. < /summary > */

سینتکس سندسازی توضیحات XML در یک ضمیمه بی قاعده از استاندارد ECMA از سی شارپ وجود دارد. یک استاندارد مشابه قوانینی برای پردازش توضیحات و تبدیل آن‌ها به متون Plain در XML را با کمک قوانین CLI فراهم می‌کند. این به هر IDE در سی شارپ و دیگر ابزار گسترش دهنده امکان پیدا کردن هر نمادی را در کدها می‌دهد.

(CLR(Common Language Runtime

بخش مرکزی چارچوب دات‌نت، محیط اجرایی Runtime می‌باشد که اصطلاحاً به آن CLR یا .NET Runtime می‌گویند. کدهایی که تحت کنترل CLR اجرا می‌شوند اغلب به عنوان کدهای مدیریت شده نامیده می‌شوند.

اگر چه، پیش از این که کدها (همه زبان‌های چارچوب دات‌نت) به وسیله CLR اجرا شوند، بایستی مورد کامپایل قرار گیرند. در چارچوب دات‌نت عمل کامپایل در دو مرحله صورت می‌گیرد:

  1. کامپایل سورس کد به MSIL.
  2. کامپایل MSIL به کد مختص پلتفرم به وسیله CLR

یک نکته قابل توجه، اشتراک زبان میانی مایکروسافت با کد بایت جاوا(Bytecode)است. ایده این اشتراک از آنجا سرچشمه گرفت که چون Bytecode یک زیان سطح پایین با یک دستور زبان ساده می‌باشد (که به جای متن مبتنی بر کدهای عددی است)، می‌تواند به سرعت به کدهای بومی(Native) ترجمه شود.

برخی ویژگی‌های MSIL

  • شیءگرایی و بکارگیری واسط‌ها
  • تمایز فراوان بین انواع مقداری و ارجاعی
  • تعیین Strong Type (این نوع داده دیگر معتبر نیست)
  • مدیریت خطا از طریق به‌کارگیری Exception
  • بکارگیری صفات

 

منبع

 

آشنایی با #C قسمت 1
آشنایی با #C قسمت 2
آشنایی با #C قسمت 3

سی شارپ (به انگلیسی: #C )یک زبان برنامه نویسی همگردان، سطح بالا، شیءگرا، ساخت یافته، رویداد محور، تابعی، دستوری و جنریک است که توسط شرکت مایکروسافت در سال 2000 میلادی از خانوادهٔ زبان‌های چارچوب دات‌نت معرفی شد. زبان #C همچنین از خانواده زبان‌های برنامه‌نویسی سی نیز است.

زبان #C، یک زبان برنامه‌نویسی چند الگویی و منظم شده مدل‌های تابعی، اَمری، عمومی، شیءگرا و جز گرا و در بستر چارچوب دات نتمی‌باشد. این زبان توسط شرکت مایکروسافت و جزئی از دات نت به وجود آمد و بعداً استانداردهای ECMA و ISO را نیز دربر گرفت. #C یکی از ۴۴ زبان برنامه‌نویسی است که توسط زمان اجرای زبان مشترک از چارچوب دات‌نت پشتیبانی می‌شوند و در همه جا به وسیلهمایکروسافت ویژوال استودیو شناخته می‌شود.

زبان #C با قدرت و در عین حال سطح بالایی خود توانسته توجه بسیاری از برنامه نویسان را به خود جلب کند.

این زبان برپایه سادگی، مدرن بودن، همه منظوره و شئ گرا بودن ساخته شد. آندرس هجلزبرگ، طراح زبان برنامه‌نویسی دلفی، سرپرستی تیم طراحان زبان #C را بر عهده داشت. این زبان دارای دستوری شیءگرا مشابه ++C است و به شدت از زبان‌های جاوا و دلفینیازمندمدرکتأثیر پذیرفته‌است. در ابتدا نام این زبان COOL بود که مخفف C like Object Oriented Language بود، هر چند در ژوئیه ۲۰۰۰م، زمانی کهمایکروسافت پروژه را عمومی اعلام کرد، اسم آن به #C تغییر پیدا کرد.

اهداف طراحی زبان

  • استاندارد ECMA این اهداف طراحی زبان را برای #C برآورده می‌سازد:
  • #C یک زبان برنامه‌سازی ساده، مدرن، برای اهداف عمومی و شیءگرا است.
  • به دلیل اهمیت داشتن موضوع نیرومندی و دوام و بهره‌وری برنامه‌نویس، زبان دارای چک‌کننده Strong Type، چک‌کننده مرزهای آرایه، تشخیص حالت‌هایی که یک متغیر مقداردهی اولیه نشده‌است، قابلیت انتقال کدها و Garbage Collection خودکار است.
  • این زبان برای استفاده در اجزای توسعه نرم‌افزار برای دستیابی به مزایای سامانه‌های توزیعی در نظر گرفته شده‌است.
  • قابلیت انتقال برنامه‌نویس بسیار مهم است، خصوصاً برای آن دسته از برنامه‌نویسانی که با زبان‌های C و C++ آشنا هستند.
  • پشتیبانی از این زبان برای بین‌المللی شدن بسیار مهم است.
  • زبان #C برای نوشتن برنامه‌ها برای سامانه‌های تعبیه شده و میزبان در نظر گرفته شده‌است، سیستم‌عامل‌های پیچیده بسیار بزرگ گرفته تا توابع اختصاصی بسیار کوچک.
  • هر چند برنامه‌های نوشته شده با #C طوری هستند که از لحاظ حافظه و پردازنده مورد نیاز مقرون به صرفه باشند، ولی خود زبان از لحاظ اندازه و کارایی به خوبی زبان‌های C و اسمبلی نیست.

تاریخچه #C

در سال ۱۹۹۹م، شرکت سان مایکروسیستمز اجازه استفاده از زبان برنامه‌نویسی جاوا را در اختیار شرکت مایکروسافت قرار داد تا در سیستم‌عامل خود از آن استفاده کند. جاوا در اصل به هیچ پلت فرم یا سیستم‌عاملی وابسته نبود، ولی مایکروسافت برخی از مفاد قرار داد را زیر پا گذاشت و قابلیت مستقل از سیستم‌عامل بودن جاوا را از آن برداشت. شرکت سان پرونده‌ای علیه مایکروسافتدرست کرد و مایکروسافت مجبور شد تا زبان شیءگرای جدیدی با کامپایل جدید که به ++C شبیه بود را درست کند. در طول ساخت دات نت، کلاس‌های کتابخانه‌ای با زبان و کامپایلر SMC نوشته شدند. در سال ۱۹۹۹ آندرس هلزبرگ گروهی را برای طراحی زبانی جدید تشکیل داد که در آن زمان نامش Cool بود و همانند C بود با خواص شیءگرایی. مایکروسافت در نظر داشت اسم این زبان را تا آخر COOL قرار دهد، ولی به دلیل مناسب نبودن برای اهداف تجاری این کار را نکرد. در ارائه و معرفی رسمی چارچوب دات‌نت در PDC در سال ۲۰۰۰ این زبان به #C تغییر نام یافت و کتابخانه کلاس‌ها و runtime در ای‌اس‌پی‌دات‌نت به #C منتقل شدند. مدیر و سرپرست طراحان در مایکروسافت آندرس هلزبرگ بود که تجربه قبلی او در طراحی Framework و زبان‌های برنامه سازی++Borland، دلفی، Turbo Pascal، ویژوال سی++ به آسانی در دستورالعمل‌های #C قابل رویت است و به همان خوبی در هسته CLR.

ویژگی‌های #C

برخی از تفاوت‌های زبان #C با زبان‌های C و ++C عبارتند از:

  • هیچ تابع یا متغیر سراسری(Global) وجود ندارد، تمام متدها و اعضا بایستی در داخل کلاس‌ها تعریف شوند. این امر ممکن است، هر چند برای استفاده از متغیرها و توابع عمومی باید از متدها و متغیرها در کلاس‌های عمومی استفاده کرد.
  • متغیرهای عمومی، بر خلاف زبان‌های C و ++C، نمی‌توانند بلاک‌های پیوستی را در بر بگیرند.
  • #C دارای یک نوع داده بولی است (bool). برخی از عبارت‌ها مانند while و if که شرطی هستند، نیازمند یک عبارت نوع بولی هستند. همان‌طور که ++C نیز دارای نوع داده بولی است، این نوع داده به راحتی می‌تواند به یا از Integerها تبدیل شود، و عبارتی مانند (if(a نیازمند این امر است که a از یک نوع قابل تبدیل به bool یا اشاره گر باشد. کامپایلر #C برنامه‌نویس را در این شرایط مجبور به استفاده از عباراتی می‌کند که به درستی یک مقدار bool را برمی‌گردانند؛ بنابراین دستوری مانند (if(a = b باعث بروز خطا می‌شوند. (به جای = بایستی از == استفاده شود)
  • در سی شارپ، اشاره گرهای به حافظه بایستی فقط در داخل بلوکهای unsafe استفاده شوند و برنامه در این حالت برای اجرا نیاز به اجازه از کاربر دارد. بیشتر دسترسی شی از طریق شی امن است که یا همیشه در حال اشاره به شی صحیح موجود است یا یک مقدار Null دارد. اشاره گری به شی به درد نخور یا بلاک حافظه رندم غیرممکن است. اشاره گر نا امن می‌تواند به نمونه‌ای از value-type، آرایه، رشته یا بلاکی که حافظه به آن داده شده‌است اشاره نماید. کدی که به عنوان نا امن علامت نخورده باشد، هنوز می‌تواند اشاره گرها را از سامانه بازیابی یا در آن ذخیره کند ولی نمی‌تواند مرجع جدیدی به آن‌ها اختصاص دهد.
  • حافظه ساماندهی شده نمی‌تواند صریحاً آزاد شود، ولی به‌طور خودکار به عنوان به درد نخور تلقی می‌شود. انتخاب آدرس‌های به درد نخور حافظه نفوذ ناپذیر است. هم چنین #C با استفاده از عبارات، پشتیبانی مستقیمی از پایان اجباری می‌کند (پشتیبانی از اصطلاح Resource Acquisition Is Initialization).
  • وراثت چندگانه از کلاس‌ها در این زبان پشتیبانی نمی‌شود. البته یک کلاس امکان ارث بری از تعداد نامحدود واسط‌ها را دارد. پشتیبانی نکردن از وراثت چندگانه به دلیل اهداف معماری این زبان در CLI و برای جلوگیری از پیچیدگی است. در عوض می‌توان از اینترفیس‌های مختلف استفاده کرد. یعنی برای یک کلاس که احتمالاً فرزند کلاسی دیگر است (ارث برده) می‌توان چندین اینترفیس را پیاده‌سازی (Implement) نمود.
  • #C بسیار typesafe تر از ++C است. تنها تبدیلات ضمنی مثل تبدیل نوع داده کوچکتر به بزرگتر یا تبدیل نوع مشتق شده به نوع پایه به‌طور پیش‌فرض و بدون خطا صورت می‌پذیرد. هیچ تبدیل ضمنی ای میانBooleanها و Integerها وجود ندارد و هر تبدیل user-defined بایستی به صراحت با یکی از کلمات explicit یا implicit نشانه گذاری شود. تبدیل b به a در حالتی که a یک Integer و b یک double باشد در زبان C++ مجاز است اما در #C به یک خطای زمان کامپایل منجر می‌شود (بایستی به صورت explicit تعریف شود)
  • اعضای Enumeration در داخل محدوده شخصی خود قرار دارند.
  • #C قابلیت syntactic sugar را برای توابع متداول، اکسسورها و ماجول‌های کسول شده در یک کلاس به صورت ویژگی‌ها قرار داده‌است.

اکسسورها که خاصیت نیز گفته می‌شوند در زبان #C قادر به کنترل دسترسی اعضا و معتبرسازی داده‌ها هستند.

  • تمام انواع بازتابی(Reflection) و بازیابی(Recovery) قابل استفاده‌است.
  • در حال حاضر (۳ ژوئن ۲۰۰۸) دارای ۷۷ کلمۀ رزرو شده‌ ( کلمۀ کلیدی ) است.

ساختمان داده (ساختار و ذخیره‌سازی داده) در #C

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

رشته‌ها

در C یا ++C ساختار رشته به صورت ارایه‌ای از نوع char بود که امکان اضافه کردن به رشته را محدود می‌کرد به دلیل ثابت بودن طول در آغاز تعریف ولی در #C دو نوع متفاوت رشته وجود دارد؛ که یکی به صورت آرایه‌ای با طول ثابت ۲۵۶(در عمل ۲۵۵)موجوداست (به صورت پیش فرض) و در صورتی که با کمبود جا روبرو شود فضای جدید (بزرگتر) یافته و به ان انتقال می‌دهد؛ ولی در نوع دوم رشته‌ها از لیست پیوندی استفاده می‌شود.

سامانه یکپارچه شده

#C دارای یک سامانه نوع یکپارچه‌است که به آن CTS می‌گویند. این بدان معناست که تمام انواع، شامل موارد اصلی مانند Integerها، مشتق شده از System.Object هستند. به عنوان مثال، هر نوع یک متد به نام ToString() را به ارث می‌برد. بخاطر کارایی، انواع اولیه (و انواع مقداری) به‌طور داخلی فضایی برای آن‌ها بر روی پشته در نظر گرفته می‌شود.

انواع داده

CTS داده‌ها را به دو نوع تقسیم می‌کند:

  • نوع مقداری (Value Type)
  • نوع مرجعی (Refrence Type)

انواع داده‌ای توده ساده‌ای از داده می‌باشند. نمونه‌های انواع داده‌ای نه هویت مرجعی دارند و نه مفاهیم مقایسه مراجع را. برای مقایسه برابری یا عدم برابری انواع داده‌ای، خود مقدار داده‌ها را با یکدیگر مقایسه می‌کنیم مگر اینکه عملگرهای مشابه دوباره تعریف شده باشند. مقادیر داده‌های مرجعی همیشه یک مقدار پیش‌فرض دارند و همیشه می‌توانند ایجاد یا کپی شوند. یکی دیگر از محدودیت‌های انواع داده‌ای این ات که آن‌ها نمی‌توانند از یکدیگر مشتق شوند (ولی می‌توانند اشتراکاتی داشته باشند) و هم چنین نمی‌توانند در سازنده مقدار دهی اولیه شوند. مثالی از انواع داده‌ای، بعضی از انواع اولیه مانند int و float و char و System.DateTime می‌باشند. در مقابل، انواع مرجعی مفهوم تعریف مرجعی را دارند (که در آن هر نمونه از نوع مرجع، به‌طور ذاتی از دیگر نمونه‌ها جدا می‌شود، حتی اگر داده هر دو نمونه یکی باشد). این دقیقاً نمونه مشابه مقایسه تساوی یا عدم تساوی داده‌های مرجعی است، که در آن آزمایش برای مرجع‌ها از داده‌ای‌ها سریع تر است. در کل نه همیشه امکان تعریف نمونه مرجعی وجود دارد و نه امکان کپی یا نمایش مقادیر مقایسه دو نمونه؛ ولی به هر حال انواع مرجعی خاص می‌توانند این اعمال را از طریق سازنده‌های عمومی یا اجرای واسط‌های مشابه (مثل ICloneable یا IComparable) انجام دهند. نمونه‌هایی از انواع مرجعی، اشیاء، System.String و Sysmet.Array می‌باشند. هر دو نوع داده قابلیت انعطاف توسط تعریف به وسیله کاربر را دارند. در واقع وقتی ما نوع داده‌ای را به تابع ای ارسال می‌کنیم، آدرس داده نیز فرستاده می‌شود. البته این امر پیش‌فرض است ولی برای داده‌های مثل آرایه، رشته‌ای، آدرس فرستاده می‌شود و ارسال از نوع مرجع می‌شود

Boxing و UnBoxing

Boxing عمل تبدیل مقدار نوع داده‌ای به نوع مرجع مشابه آن می‌باشد.

مثال:

int foo = 42;// Value type...
object bar = foo;//foo is boxed to bar.

UnBoxing عمل تبدیل نوع مرجع به نوع داده‌ای می‌باشد. مثال:

int foo = 42;// Value type.
object bar = foo;// foo is boxed to bar.
int foo2 = (int)bar;// Unboxed back to value type.

#C به برنامه‌نویس با استفاده از کلمه کلیدی Struct اجازه می‌دهد تا انواع مقداری User-defined را ایجاد کند. از دیدگاه برنامه‌نویسی، آن‌ها کلاس‌های سبک وزن به نظر می‌رسند. برخلاف کلاس‌ها (که بر روی heap قرار می‌گیرند) و شبیه به انواع اولیه استاندارد مانند انواع مقداری Structها نیز بر روی پشته قرار می‌گیرند. آن‌ها همچنین می‌توانند قسمتی از یک شئ باشند، یا در یک آرایه مرتب شوند، بدون حافظه غیر مستقیمی که به‌طور معمول برای انواع کلاس تخصیص می‌یابد.

ویژگی‌های جدید در سی شارپ ۲٫۰

ویژگی‌های جدید در #C چارچوب دات‌نت SDK ۲٫۰ (مطابق با سومین ویرایش استاندارد ECMA-۳۳۴):

کلاسهای partial

کلاس‌های Partial اجازه اجرای کلاس‌ها از بیش از یک سورس فایل را می‌دهند. این امر اجازه می‌دهد تا کلاس‌های بسیار بزرگ را قطعه قطعه کنیم و همچنین برای زمانی که برخی قسمت‌های یک کلاس به‌طور خودکار تولید می‌شوند مفید است.

file.cs:

public partial class MyClass
{
    public MyClass()
    {
// implementation
    }
}

file2.cs:

public partial class MyClass
{
    public void SomeMethod()
    {
// implementation
    }
}

Genericها

genericها یا نوع‌های پارامتری شده یا چندریختی‌های پارامتری یک ویژگی جدید چارچوب دات‌نت ۲٫۰ است که به وسیله #C پشتیبانی می‌شود. برخلاف Templateهای سی پلاس پلاس، در این انواع به جای اینکه نمونه‌سازی توسط کامپایلر انجام شود، در زمان اجرا صورت می‌گیرد، بنابراین می‌توانند چند زبانه باشند در حالی که ++C نمی‌تواند. آن‌ها دارای ویژگی‌هایی هستند که به‌طور مستقیم توسط Templateهای ++C پشتیبانی نمی‌شوند مانند نوع محدودیت‌ها در پارامترهای Generic با استفاده از رابط‌ها(Interface). سی شارپ از پارامترهای‌های Generic بدون نوع پشتیبانی نمی‌کند. بر خلاف genericهای جاوا، generic‌های دات نت برای پارامتری کردن انواع داده‌ای در اشیاء ماشین مجازی CLI، از مفاهیم شیءگرایی استفاده می‌کنند که اجازه بهینه‌سازی و حفاظت انواع اطلاعات را می‌دهد.

کلاس‌های static

کلاس‌ها به صورت Static قابل تعریف نیستند مگر اینکه تمام اعضای آن‌ها Static باشند؛ که این امر بسیار شبیه به مفهوم مدل در زبانهای رویه‌ای است. (زبان رویه‌ای: یک زبان برنامه‌نویسی که در آن عنصر اصلی برنامه‌نویسی یک زیربرنامه‌است. مانند زبان‌های C، پاسکال و…)

یک شکل جدید از تکرارکننده با استفاده از سازنده توابع

یک شکل جدید از iterator(تکرارکننده)، با استفاده از ساختار yield return بسیار شبیه به yield زبان Python.

// Method that takes an iterable input (possibly an array) and returns all even numbers.
public static IEnumerable&lt;int&gt; GetEven(IEnumerable&lt;int&gt; numbers)
{
    foreach (int i in numbers)
    {
        if (i % 2 == 0) yield return i;
    }
}

Delegateهای ناشناس

Delegate یک شی می‌باشد که حاوی یک یا چند اشاره گر به توابع می‌باشد؛ که با Invoke کردن آن تمامی توابع اشاره شده داخل آن اجرا می‌شوند.

Delegateهای ناشناس که عملکردهای محدودی را در #C به وجود می‌آورند. کد کنار بدنه Deletage ناشناس، دسترسی کامل برای خواندن یا نوشتن در متغیرهای عمومی، پارامترهای توابع و اعضای کلاسهای دارای محدوده Deletage را دارد ولی پارامترهای out و ref را پشتیبانی نمی‌کند. برای مثال:

int SumOfArrayElements(int[] array)
{
    int sum = 0;
    Array.ForEach(       array,
        delegate(int x)
        {
            sum += x;
        }
  );
    return sum;
}

Delegate covariance and contravariance

تبدیل گروه‌های متد به نوع Deletage در برگشت دارای covariant و در انواع پارامترها دارای contravariant هستند.

اکسسورهای یک خاصیت(get و set) می‌توانند دارای سطح دسترسی متفاوتی باشند

مثال:

string status = string.Empty;
public string Status
}
    get { return status; }// anyone can get value of this property,
    protected set { status = value; }// but only derived classes can change
it
}

نکته مهم: سطح دسترسی خاصیت نمی‌تواند بالاتر از سطح دسترسی اکسسورها باشد. به عنوان مثال private بودن خاصیت و public بودن اکسسور باعث بروز خطا می‌شود.

نوع داده Nullable

نوع داده Nullable (که با یک علامت سؤال قابل تشخیص است: int? i = null;)اجازه تخصیص مقدار null را برای انواع داده‌ای می‌دهد. این امر باعث بهبودی فعل و انفعال با پایگاه داده SQL می‌شود. در این حالت نوع ستونی INTEGER NULL در SQL به‌طور مستقیم به int? در سی شارپ تبدیل می‌شود.

داده‌های Nullable در آخرین لحظات اوت ۲۰۰۵ اضافه شدند چند هفته مانده به اتمام کار اداری و برای بهبود زبان. متغیر Null در حقیقت خالی نیست، بلکه نمونه‌ای است از struct Nullable<T> با ویژگی HasValue مساوی false. وقتی در برنامه قرار می‌گیرد، خود به خود نمونه خالی در آن قرار می‌گیرد، نه مقدار خود آن، در نتیجه اشاره گر مقصد همیشه غیر Null می‌باشد، حتی برای مقادیر Null. کد زیر نضص بالا را مشخص می‌کند:

int? i = null;
object o = i;
if (o == null)
    Console.WriteLine("Correct behaviour - runtime version from September 2005 or later");
else
    Console.WriteLine("Incorrect behaviour - pre-release runtime (from before September 2005)»);

وقتی درون شی ای کپی می‌شود، نمونه Nullable به صورت تشریفاتی در آن قرار می‌گیرد و در نتیجه مقادیر و منابع Null با هم برابر می‌شوند. در گذشته این خاصیت دارای مجادله بود تا زمانی که علاوه بر چارچوب دات‌نت ۲، به هسته CLR نیز مجهز شد و همه تکنولوژی‌ها نظیر سی شارپ، ویژوال بیسیک، مایکروسافت اس‌کیوال سرور ۲۰۰۵ و مایکروسافت ویژوال استودیو ۲۰۰۵ را شامل شد.

Coalesce Operator

مقدار اولین عملوندی که null نباشد را برمی‌گرداند. (یا null، برای زمانی که تمام عملوندها null باشند)

object nullObj = null;
object obj = new Object();
return nullObj ?? obj;// returns obj

کاربرد اصلی این عملگر در قرار دادن یک مقدار nullable در یک مقدار non-nullable با استفاده از یک دستورالعمل ساده‌است.

int? i = null;
int j = i ?? 0; /* Unless i is null, initialize j to i. Else (if i is null), initialize j to 0. */

 

منبع

آشنایی با #C قسمت 1
آشنایی با #C قسمت 2
آشنایی با #C قسمت 3

برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

علاوه بر مواردی که تا کنون پیرامون برنامه نویسی Parallel در دات نت آموختیم امکان نوشتن کوئری های LINQ به صورت Parallel نیز وجود دارد. این قابلیت بوسیله یکسری Extension Method که برای این موضوع تعریف شده امکان پذیر است و اصطلاحاً به کوئری های LINQ که به صورت Parallel اجرا می شوند PLINQ گفته می شود.
اما شیوه اجرای کوئری ها به صورت Parallel چگونه است؟ زمانی که شما از متدهای مربوطه برای اجرای کوئری ها به صورت Parallel استفاده می کنید، PLINQ کوئری مورد نظر را آنالیز کرده و تصمیم میگیرد که اجرای کوئری به صورت Parallel بر روی Performance برنامه شما تاثیر منفی می گذارد یا خیر.

کوئری که به صورت Parallel اجرا نشود اصطلاحاً Sequentional گفته می شود و PLINQ به صورت هوشمند نوع اجرای مناسب را برای کوئری شما انتخاب می کند، این موضوع به این معنی است که درخواست اجرای کوئری به صورت Parallel لزوماً تضمینی بر اجرای آن به صورت Parallel نیست و تصمیم این موضوع با آنالیزوری است که کوئری را تحلیل می کند.
متدهای مورد نیاز برای اجرای کوئری ها به صورت Parallel در کلاسی به نام ParallelEnumerable که در فضای نام System.LINQ قرار گرفته تعریف شده اند. در زیر ابتدا نگاهی به این متدها می اندازیم:

  1. متد AsParallel: این متد مشخص می کند که کوئری های بعد از این متد می بایست به صورت Parallel اجرا شوند.
  2. متد WithCancellation: مشخص می کند که در زمان اجرای کوئری به صورت دائم می بایست وضعیت token مشخص شده بررسی شده و در صورت درخواست Cancel کردن کوئری، روند اجرای آن متوقف شود.
  3. متد WithDegreeOfParallelism: مشخص می کند که چه تعداد پردازشگر باید برای اجرای کوئری تخصیص داده شود.
  4. متد ForAll: برای خروجی وضعیتی را فعال می کند که خروجی قبل از ادغام و بازگرداندن آن به Thread اصلی می بایست به صورت Parallel مورد پردازش تکمیلی قرار گیرد، دقیقاً مانند زمانی که نتیجه خروجی یک کوئری LINQ بوسیله دستور foreach مورد پردازش قرار می گیرد.

برای اینکه به صورت عملی با نحوه نوشتن کوئری های LINQ به صورت Parallel آشنا شویم مثال زیر را در نظر بگیرید:

static void Main(string[] args)
{
    Task.Factory.StartNew(ProcessData);

    Console.ReadKey();
}

public static void ProcessData()
{
    var source = Enumerable.Range(1, 1000000).ToArray();

    var evenNumbers = (from number in source where number%2 == 0 orderby number descending select number).ToArray();

    Console.WriteLine("Found {0} even numbers in source.", evenNumbers.Length);
}

در مثال بالا و در متد ProcessData، ابتدا بوسیله متد Range از کلاس Enumerable یک آرایه از اعداد 1 تا 1000000 ایجاد کردیم و در قدم بعدی بوسیله یک کوئری LINQ اعداد زوج را بدست آوردیم و در نهایت در خروجی تعداد اعداد زوج که بوسیله کوئری استخراج شده اند را در خروجی نمایش دادیم. اما اگر بخواهیم کوئری بالا به صورت Parallel اجرا شود می بایست بوسیله کوئری LINQ را به صورت زیر تغییر دهیم و از متد AsParallel استفاده کنیم:

var evenNumbers = (from number in source.AsParallel() where number%2 == 0 orderby number descending select number).ToArray();

همانطور که مشاهده می کنید، بعد از نوشتن منبع یعنی source از متد AsParallel برای اجرای کوئری به صورت Parallel استفاده شده است.

Cancel کردن یک کوئری PLINQ

برای اینکه به کاربر قابلیت کنسل کردن کوئری ها را بدهیم از متد WithCancellation استفاده می کنیم، در ابتدا باید یک شئ از CancellationTokenSource ایجاد کنیم:

private static CancellationTokenSource tokenSource = new CancellationTokenSource();

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

static void Main(string[] args)
{
    Task.Factory.StartNew(ProcessData);
    Console.CancelKeyPress += (sender, eventArgs) = &gt;
    {
        eventArgs.Cancel = true;
        tokenSource.Cancel();
    };
    Console.ReadKey();
}

و در نهایت کد مربوط به کوئری را به صورت زیر تغییر می دهیم:

public static void ProcessData()
{
    var source = Enumerable.Range(1, 1000000).ToArray();

    int[] evenNumbers;

    try
    {
        evenNumbers = (from number in source.AsParallel().WithCancellation(tokenSource.Token) where number%2 == 0 orderby number descending select number).ToArray();
        Console.WriteLine("Found {0} even numbers in source.", evenNumbers.Length);
    }
    catch (OperationCanceledException ex)
    {
        Console.WriteLine(ex);
    }

}

همانطور که مشاهده می کنید در قسمت کوئری و بعد از متد AsParallel از متد WithCancellation برای مشخص کردن token تعریف شده که بواسطه آن کوئری را کنسل می کنیم استفاده کردیم. همچنین قسمت کوئری اصلی را داخل بدنه try..catch گذاشتیم، زیرا در صورت فراخوانی متد Cancel برای شئ tokenSource، کوئری به صورت خودکار خطای OperationCanceledException را تولید می کند (با این مکانیزم در قسمت قبلی آموزش آشنا شدیم.)

با اتمام این بخش مباحث مرتبط با TPL در دات نت نیز به پایان رسید، البته مطالب مرتبط با TPL بسیار گسترده بوده و شاید برای پوشش کل مباحث مرتبط نیاز به نوشتن صدها صفحه مطلب باشد، اما کلیت موضوع را سعی کردیم در این سری مطالب مطرح کنیم.

در قسمت بعدی که قسمت نهایی سری مطالب Asynchronous Programming است با کلمات کلیدی async و await که روش ساده تری برای نوشتن برنامه های Asynchronous در اختیار ما قرار می دهند آشنا می شویم.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ

 

 

برنامه نویسی Parallel در سی شارپ و آشنایی با کلاس Task در سی شارپ

در قسمت قبل گفتیم که بوسیله کلاس Parallel و متدهای For و ForEach عملیات پردازش بر روی مجموعه ها را به صورت Parallel انجام دهیم. اما بحث Parallel Programming به همین جا ختم نمی شود و راه های دیگری نیز برای برنامه نویسی Parallel وجود دارد. یکی از این روش ها استفاده از کلاس Task است که این کلاس نیز در فضای نام System.Threading.Tasks قرار دارد. حالت های مختلفی برای استفاده از این کلاس وجود دارد که ساده ترین آن استفاده از خصوصیت Factory و متد StartNew است که در زیر نمونه ای از نحوه ایجاد یک Task را مشاهده می کنید:

 
Task.Factory.StartNew(()  = &gt;
{
    Console.WriteLine("Task Started in Thread {0}", Thread.CurrentThread.ManagedThreadId);
    for (int i = 1; i  &lt; =  100; i++)
    {
        Console.WriteLine(i);
        Thread.Sleep(500);
    }
});

بوسیله کد بالا، یک Task جدید ایجاد شده که اعداد 1 تا 100 را در یک thread جداگانه در خروجی چاپ می شود. دقت کنید که بعد از اجرای برنامه شناسه Thread ای که Task در آن اجرا می شود با شناسه Thread اصلی برنامه متفاوت است. راهکار بعدی ایجاد یک شئ از روی کلاس Task و ارجرای آن است، در کد زیر Task بالا را به صورت ایجاد شئ ایجاد می کنیم:

 
Task task = new Task(()  = &gt;
{
    Console.WriteLine("Task Started in Thread {0}", Thread.CurrentThread.ManagedThreadId);
    for (int i = 1; i  &lt; = 100; i++)
    {
        Console.WriteLine(i);
        Thread.Sleep(500);
    }
});
 
task.Start();
Console.ReadKey();

زمانی که Task جدیدی ایجاد می کنید بوسیله متد Start که برای کلاس Task تعریف شده است می توانید عملیات اجرای Task را شروع کنید. یکی از خصوصیت های تعریف شده در کلاس Task، خصوصیت IsCompleted است که بوسیله آن می توان تشخیص داد که Task در حال اجراست یا خیر:

 
Task task = new Task(()  = &gt;
{
    Console.WriteLine("Task Started in Thread {0}", Thread.CurrentThread.ManagedThreadId);
    for (int i = 1; i &lt; =  100; i++)
    {
        Console.WriteLine(i);
        Thread.Sleep(500);
    }
});
 
task.Start();
while (!task.IsCompleted)
{
                 
}

دریافت خروجی از کلاس Task

می توان برای کلاس Task یک خروجی مشخص کرد، فرض کنید می خواهیم Task ای بنویسیم که میانگین حاصل جمع اعداد 1 تا 100 را حساب کرده و به عنوان خروجی بازگرداند. برای اینکار باید از کلاس Task که یک پارامتر جنریک دارد استفاده کنیم. ابتدا یک متد به صورت زیر تعریف می کنیم:

 
public static int CalcAverage()
{
    int sum = 0;
 
    for (int i = 1; i &lt; = 100; i++)
    {
        sum += i;
    }
 
    return sum/100;
}

در قدم بعدی می بایست یک Task جنریک از نوع int تعریف کنیم و به عنوان سازنده نام متد تعریف شده را به آن ارسال کنیم:

 
Task &lt; int &gt;  task = new Task &lt; int &gt; (CalcAverage);
task.Start();
 
Console.WriteLine("Average: {0}", task.Result);

در کلاس بالا بعد از Start کردن Task، بوسیله خصوصیت Result می توانیم نتیجه خروجی از Task را بگیریم، دقت کنید که زمانی که می خواهیم مقدار خروجی را از Task بگیریم، برنامه منتظر می شود تا عملیات Task به پایان برسد و سپس نتیجه در خروجی چاپ می شود.

به این موضوع توجه کنید که بوسیله متد StartNew نیز می توان Task هایی که پارامتر خروجی دارند تعریف کرد:

 
var task = Task.Factory.StartNew &lt; int &gt; (CalcAverage);

کد بالا دقیقاً کار نمونه قبلی را انجام می دهد، فقط به جای ایجاد شئ Task و فراخوانی آن، از متد StartNew استفاده کردیم.

ارسال پارامتر به Task ها

یکی از قابلیت های Task ها امکان ارسال State به متدی است که قرار است به عنوان Task اجرا شود. برای مثال، فرض کنید در مثال قبلی که Task ایجاد شده حاصل میانگین را حساب کرده و به عنوان خروجی بر میگرداند می خواهیم عدد شروع و پایان را مشخص کنیم، برای اینکار ابتدا یک کلاس به صورت زیر تعریف می کنیم:

 
public class TaskParameters
{
    public int Start { get; set; }
    public int Finish { get; set; }
}

در ادامه کد متد CalcAverage را به صورت زیر تغییر می دهیم:

 
public static int CalcAverage(object state)
{
    var parameters = (TaskParameters) state;
    int sum = 0;
 
    for (int i = parameters.Start; i &lt; = parameters.Finish; i++)
    {
        sum += i;
    }
 
    return sum/100;
}

در قدم بعدی باید روند ساخت شئ Task را به گونه ای تغییر دهیم که پارامترهای مورد نظر به عنوان state به متد CalcAverage ارسال شوند، برای اینکار به عنوان پارامتر دوم سازنده کلاس Task شئ ای از نوع TaskParameters به صورت زیر ارسال می کنیم:

 
Task &lt; int &gt; task = new Task &lt; int &gt; (CalcAverage, new TaskParameters()
{
    Start = 100,
    Finish = 1000
});

با انجام تغییرات بالا، توانستیم شئ ای را به عنوان State به Task ارسال کنیم، همچنین توجه کنید که امکان ارسال State بوسیله متد StartNew در خصوصیت Factory نیز وجود دارد. در این بخش با کلاس Task آشنا شدیم، در قسمت بعدی با نحوه متوقف کردن Task ها در زمان اجرا و کلاس CancellationToken آشنا می شویم.

منبع


قسمت اول آموزش-برنامه نویسی Asynchronous – آشنایی با Process ها، Thread ها و AppDomain ها

قسمت دوم آموزش- آشنایی با ماهیت Asynchronous در Delegate ها

قسمت سوم آموزش-آشنایی با فضای نام System.Threading و کلاس Thread

قسمت چهارم آموزش- آشنایی با Thread های Foreground و Background در دات نت

قسمت پنجم آموزش- آشنایی با مشکل Concurrency در برنامه های Multi-Threaded و راهکار های رفع این مشکل

قسمت ششم آموزش- آشنایی با کلاس Timer در زبان سی شارپ

قسمت هفتم آموزش-آشنایی با CLR ThreadPool در دات نت

قسمت هشتم آموزش- مقدمه ای بر Task Parallel Library و کلاس Parallel در دات نت

قسمت نهم آموزش- برنامه نویسی Parallel:آشنایی با کلاس Task در سی شارپ

قسمت دهم آموزش-برنامه نویسی Parallel در سی شارپ :: متوقف کردن Task ها در سی شارپ – کلاس CancellationToken

قسمت یازدهم آموزش- برنامه نویسی Parallel در سی شارپ :: کوئری های Parallel در LINQ

قسمت دوازدهم آموزش- آشنایی با کلمات کلیدی async و await در زبان سی شارپ

قسمت سیزدهم آموزش- استفاده از متد WhenAll برای اجرای چندین Task به صورت همزمان در سی شارپ