چگونه کامپوننت مورد نیاز خود را بسازیم

[مجید]

فصل دوم

برنامه نویسی شیء گرا برای کامپوننت نویسان

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

• ایجاد اشیاء جدید
• اجداد و فرزندان
• کنترل دسترسی
• توزیع امکانات method ها
• اشیاء و اشاره گر ها

ایجاد اشیاء جدید
تفاوت اصلی بین کاربران کامپوننت و کامپوننت نویسان در این است که ، کاربران instance هایی از اشیاء را دستکاری می کنند ولی کامپوننت نویسان type های جدیدی از اشیاء را ایجاد می کنند. اگر برای ایجاد کامپوننت های خود برنامه ریزی می کنید ، این مفهوم اساسی برنامه نویسی شیء گرا است و داشتن درک درستی از این تفاوت بسیار مهم است.
مفهوم type ها و instance ها منحصر به اشیاء نیست. برنامه نویسان بطور مستمر با type ها و instance ها کار می کنند ، اما بصورت کلی از این واژگان استفاده نمی کنند. type یک ایده بسیار عمومی در برنامه های Object Pascal است و شما بعنوان یک برنامه نویس معمولاً متغیرها را از یک type ایجاد می کنید. این متغییر ها instance هایی از type ها هستند.
اشیاء معمولاً پیچیده تر از انواع ساده ای همچون Integer هستند، اما یک کاربر با اختصاص مقادیر مختلف به instance هایی از همان نوع ، می تواند وظایف کاملاً متفاوتی را انجام دهد.
بعنوان مثال ، کاربر روی یک فرم دو دکمه با عناوین OK و Cancel قرار می دهد . هر دو ، instance هایی از نوع TButton هستند، اما با اختصاص مقادیر مختلف در خصوصیت Caption هر کدام، تعیین خصوصیت Default و Cancel ، و رویداد OnClick متفاوت برای هر کدام ، دو عملکرد متفاوت از این دو instance یکسان بوجود می آورد.

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

دو دلیل برای مشتق کرن type جدید وجود دارد:

• تغییر پیشفرض های type برای جلوگیری از تکرار کد نویسی
• افزودن قابلیت های جدید به یک type

در هر صورت ، هدف ایجاد شیئی است که Reusable (قابل استفاده مجدد) باشد.اگر قصد دارید اشیائی را طراحی کنید ، می توانید خود را از تکرار مقدار زیادی از کار هایی را که قرار است بعداً انجام دهید نجات دهید ، تا در آینده نیز از آنها استفاده کنید. به type های اشیائ خود مقادیر پیشفرض قابل استفاده بدهید، اما آن ها را Customizable (قابل تنظیم) کنید.
بخش های زیر نگاه دقیق تری به دو دلیل بالا ارائه می کند.

تغییر پیشفرض های type برای جلوگیری از تکرار کد نویسی
وظیفه تمام برنامه ها ، جلوگیری از تکرار کار هاست. اگر کد ها را بیش از یک بار بازنویسی می کنید ،باید آن ها را در subroutine یا تابع یا DLL قرار داده تا بتوانید در برنامه های بیشتری از آن ها استفاده کنید. همین استدلال برای کامپوننت نویسی کافیست. اگر اغلب در حال تغییر یک سری خصوصیات و فرا خوانی یک سری method ها هستید ، احتمالاً باید یک نوع کامپوننت جدید ایجاد کرده تا همه این ها را بصورت پیش فرض انجام دهد. بطور مثال ، هر بار که یک برنامه جدید می سازید، یک کادر محاوره ای برای انجام یک تابع خاص نیز اضافه می کنید.اگرچه ساخت مجدد کادر محاوره ای خیلی سخت نیست ، ولی نیازی به این کار هم نیست. می توانید کادر محاوره ای را یک بار طراحی کرده و خصوصیات آن را تنظیم کرده و نتیجه آن را در پالت کامپوننت ها نصب کنید تا برای دفعات بعدی نیز قابل استفاده باشد. با این روش نه تنها جلو دوباره کاری را گرفته اید بلکه با استاندارد سازی احتمال بروز خطا را در ساخت مجدد کادر محاوره ای ، کاهش داده اید.
فصل 9 نمونه ای از تغییر خصوصیات پیش فرض یک کامپوننت را نشان می دهد.

افزودن قابلیت های جدید به یک type
دلیل دیگر برای ایجاد یک نوع جدید از کامپوننت این است که قصد دارید قابلیت های جدیدی را به کامپوننت موجود اضافه کنید. برای انجام این کار می توانید کامپوننت جدید را از یک نوع از کامپوننت های موجود (مثلاً ، ایجاد یک نوع تخصصی از ListBox) یا از یک نوع پایه انتزاعی مثل TComponent یا TControl مشتق کنید.
به عنوان یک قاعده کلی ، کامپوننت جدیدتان را از نوعی مشتق کنید که حاوی نزدیک ترین زیر مجموعه از ویژگی هایی باشد که بدنبال آن هستید. شما می توانید قابلیت هایی را به یک شیء اضافه کنید ، اما نمی توانید قابلیت هایی را از آن جذف کنید. بنابراین ، اگر کامپوننتی که مد نظر شماست خصوصیاتی دارد که شما مایل نیستید در کامپوننت شما وجود داشته باشد ، باید کامپوننتان را از جد یا والد آن کامپوننت مشتق کنید.
بطور مثال ، اگر می خواهید قابلیت هایی را به یک ListBox اضافه کنید ، باید کامپوننت خود را از TListBox مشتق کنید . اما اگر می خواهید قابلیت هایی را به ListBox استاندارد اضافه و قابلیت هایی را از آن حذف کنید ، باید کامپوننت خود را از TCustomListBox مشتق کنید که خود والد TListBox است. سپس قابلیت هایی که می خواهید دیده شود را ایجاد کنید. و در نهایت ویژگی های مد نظر خود را به آن بیافزایید.
فصل 11 مثالی از یک نوع کامپوننت سفارشی که از یک نوع انتزاعی مشتق شده است را نشان می دهد.

اعلان یک نوع کامپوننت جدید
وقتی تصمیم می گیرید یک نوع جدید کامپوننت را ایجاد کنید، باید بدانید که می خواهید آن را از چه نوعی مشتق کنید. همانطور که قابلیت های جدید را به نوعی از کامپوننت موجود اضافه می کنید، ضروریست که از قاعده زیر نیز پیروی کنید :
کامپوننت خود را از نوعی مشتق کنید که شامل بیشترین قابلیت های مد نظر شما باشد و هیچ کدام از قابلیت هایی که مایل نیستید را نیز نداشته باشد.

دلفی تعدادی از انواع کامپوننت های انتزاعی را به منظور طراحی ، برای کامپوننت نویسان ارائه کرده است تا بعنوان کامپوننت پایه از آن ها استفاده کنند. جدول 1.1 که قبلاً مشاهده کردید انواع مختلفی را که می توان با آن ها کامپوننت نویسی را شروع کرد نشان می دهد.
برای اعلان یک نوع کامپوننت جدید ، اعلان type آن را به یونیت کامپوننت ها اضافه کنید . در اینجا نمونه ای از یک اعلان ساده یک کامپوننت گرافیکی را می بینید :

type
TSampleShape = class(TGraphicControl)
end;

یک اعلان کامپوننت نهایی شده قبل از end ، شامل Property، Field و method خواهد بود. اما بدون این ها نیز یک اعلان معتبر است و می تواند نقطه شروعی برای افزودن ویژگی های کامپوننت باشد. فصل 10 مثالی از ایجاد یک کنترل گرافیکی کامل را نشان می دهد.