مقایسه تجربی Entity Framework و NHibernate

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

نگاشت کلاس ها

در NHibernate برای انجام عمل Mapping کلاس ها، (با صرف نظر از کتابخانه های کمکی) به ازای هر کلاس باید یک فایل نگاشت XML و برای تنظیم آن نیز یک فایل XML نوشته شود. زمانی که یک دیتابیس داریم و می خواهیم کلاس های مدل خود را بسازیم NHibernate ابزاری برای این کار ندارد (با صرف نظر از ابزارهای کمکی) و باید نگاشت را به صورت دستی انجام داد. اما با استفاده از کتابخانه های کمکی مثل Fluent NHibernate می توان بدون نوشتن حتی یک خط کد XML نگاشت کلاس ها و تنظیم NHinernate را به خوبی انجام داد. ابزارهای Designer متعددی هم در حال حاضر برای نگاشت یک دیتابیس موجود برای NHibernate ساخته شده اند.

در Entity Framework انجام عمل Mapping با استفاده از Designer قدرتمند ویژوال استادیو به راحتی قابل انجام است و (با صرف نظر از نسخه جدید EF) این Designer فقط زمانی که یک دیتابیس وجود داشته باشد به کار می آید. شما می توانید ابتدا دیتابیس خود را بسازید و با Import کردن جدول های مورد نظر خود به صورت ویژوال عملیات Mapping را انجام دهید. سپس EF از روی آن، کلاس های دامین شما را با ارتباط های مناسب خواهد ساخت. در نسخه بعدی EF شما می توانید از روش هایی شبیه به Fluent NHibernate و Castle ActiveRecord برای ساختن کلاس های دامین خود و سپس نگاشت آن ها به یک دیتابیس استفاده کنید.

انجام پرس و جو

Entity Framework دو روش را برای ایجاد و اجرای کوئری ها به شما می دهد. یک روش، دستوراتی کاملاً شبیبه به SQL دارد به نام Entity SQL Language و روش دیگر روش محبوب LINQ to Entitis است که اکثراً از این روش استفاده می کنند. روش اول کاملاً شبیه به استفاده از زبان SQL است، فقط در اینجا به جای استفاده از نام جداول اطلاعاتی از نام کلاس ها و به جای نام فیلدها از نام پراپرتی ها استفاده می کنید. در روش دوم شما تمام قدرت LINQ را برای بدست آوردن نتایج از کلاس های دامین پروژه خود خواهید داشت.

در NHibernate برای کوئری گرفتن انتخاب های بیشتری دارید. این موضوع می تواند هم خوب باشد و هم بد! خوب است چون شما می توانید بر اساس نیاز خود و کاری که می خواهید انجام دهید یک روش را انتخاب کنید و بد است چون در بعضی مواقع باعث سردرگمی شما می شود. محبوب ترین روش در هر دوی این ORMها استفاده از LINQ است که تا نسخه قبلی NHibernate مشکلاتی در پشتیبانی کامل LINQ وجود داشت که در نسخه جدید تا حدود زیادی برطرف شده است. NHibernate از زبان HQL که یک SQL شیء گرا برای نوشتن کوئری است پشتیبانی می کند که برای کسانی که پیش زمینه SQL دارند کار را راحت می کند. Criteria API روش دیگری است که اگر نحوه استفاده از آن را یاد بگیرید تقریباً هر کوئری که نیاز داشته باشید را می توانید با آن بنویسید. در نسخه 3.0 NHibernate روش جدیدی به نام QueryOver اضافه شده که همان Criteria API را با استفاده از اکستنشن متدها و عبارت های lambda به صورت type safe ارائه می دهد. کوئری های نوشته شده به این روش شباهت زیادی به کوئری های نوشته شده با LINQ دارند. MultiQuery نام روش دیگری است که NHibernate را قادر می سازد که فقط با یک بار رفت و برگشت به دیتابیس چند کوئری را اجرا کند و نتایج آن را برگرداند.

سادگی در استفاده

فکر میکنم همه بدانیم که استفاده از Entity Framework در عمل از استفاده از NHibernate به مراتب ساده تر است. ابزارهایی که ویژوال استادیو برای ایجاد کلاس های دامین پروژه برای Entity Framework در اختیار شما قرار می دهد کار شما را بسیار آسان می کند. برای استفاده از EF شما نیازی به دانستن چیز خاصی ندارید و همین که کلاس های شما با استفاده از ویزارد ساخته شدند می توانید شروع به استفاده از آن ها کنید. اما در NH شما نیاز به یادگیری و مطالعه بیشتری دارید و احتمال برخورد به مشکل در آن نسبت به EF بسیار بیشتر است. اگر اهل مطالعه و یادگیری نیستید و در برنامه نویسی بی حوصله اید به هیچ وجه از NHibernate استفاده نکنید!

پشتیبانی از دیتابیس های مختلف

EF و NH هر دو از دیتابیس های محتلفی پشتیبانی می کنند. اما پشتیبانی کردن آن ها با یکدیگر تفاوت دارد. EF محصول مایکروسافت است و به صورت توکار فقط از SQL Server پشتیبانی می کند. برای دیتابیس های دیگر مثل اوراکل یا Sybase باید از پروایدرهای تجاری استفاده کنید. به تازگی MySql و SQLite پروایدرهای خود را برای EF ارائه کرده اند و اوراکل نیز قرار است در نیمه دوم سال 2011 این کار را انجام دهد. البته شما خودتان هم می توانید برای دیتابیس مورد نیاز خود یک پروایدر برای EF بنویسید.

در مورد NH چون یک محصول اوپن سورس است به صورت پیش فرض از دیتابیس های مختلفی مثل اوراکل، MySql، SQLite، SQL Server، Firebird پشتیبانی می کند.

Second Level Cache

استفاده از Caching در یک ORM معمولاً در دو سطح امکان پذیر است. سطح اول که در سطح تراکنش است و تضمین می کند که دو رکورد یکسان در یک Session دو بار خوانده نخواهند شد. سطح دوم Cache در سطح DAL انجام می شود و باعث بالا رفتن سرعت اجرای کوئری ها بدون اتصال دوباره به دیتابیس می شود و فقط محدود به یک Session نخواهد شد. EF  تا نسخه 4.0 این قابلیت را به صورت توکار ارائه نمی کند اما NHibernate تعدادی Provider مناسب برای این کار دارد.

کتابخانه های کمکی

در حال حاضر تعداد کتابخانه های کمکی NHibernate به علت کدباز بودن آن بسیار زیاد است. پروژه هایی مثل NHibernate Search و NH Validator که توسط جامعه کاربری توسعه می یابند برای EF وجود ندارند. برای EF باید به محصولات تجاری شرکت ها مراجعه کنید.

کارایی و سرعت

Entity Framework و NHibernate به اندازه کافی کارایی خوبی دارند اگر به درستی به کار گرفته شوند. نکته ای که وجود دارد این است که با EF شما به سختی می توانید اشتباه کنید اما در NHibernate اشتباه کردن به راحتی آب خوردن است! در Entity Framework بدون اینکه شما کاری انجام دهید، کارایی خوبی خواهید داشت اما در مورد NHibernate اینطور نیست. اگر مستندات NHibernate را کامل بخوانید و تمام ملاحظات کارایی را در پیاده سازی لحاظ کنید به کارایی و سرعت بالاتری از EF هم خواهید رسید.

زمان یادگیری

همانطور که گفته شد، یادگیری NHibernate معمولاً زمان بیشتری نسبت به Entity Framework نیاز دارد. با NHibernate شما نیاز به یادگیری مفاهیم بیشتری دارید و معمولاً برای حل یک مشکل زمان بیشتری را باید صرف کنید. هر دو، کتاب ها و منابع خوبی برای یادگیری دارند.

نتیجه

برای تصمیم گیری درباره استفاده از هر کدام از این ORMها فاکتورهای دیگری نیز موثر هستند که در این مطلب به آن ها اشاره نشد. NHibernate در حال حاضر انتخاب های بیشتری را نسبت به EF ارائه می دهد و شما کنترل بیشتری بر روی ویژگی های آن دارید. انتخاب های بیشتر باعث پیچیده تر شدن NH شده است. EF به جای آن از سادگی خاص محصولات مایکروسافت بهره می برد و برای راه اندازی یک پروژه که وقت کمی دارد بسیار مناسب است. هر چند انتخاب ها و ویژگی های بیشتر همیشه نکته مثبتی نیستند، چون اگر ندانید چطور انتخاب کنید و یا نحوه کار ویژگی مورد نظر را درک نکرده باشید، به راحتی می توانید اشتباه کنید. EF و NH هر دو وظیفه های مهم یک ORM را به خوبی انجام می دهند و کمی در جزئیات با هم متفاوت اند که در این مطلب به آن ها اشاره شد.

استفاده از jQuery UI Dialog در ASP.NET

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

خوشبختانه کتابخانه jQuery UI دارای یک کامپوننت Dialog مناسب برای استفاده در محیط وب است که با تمامی مرورگرهای مدرن سازگاری کامل دارد و به علت اینکه بر روی کتابخانه jQuery کار می کند در تمام پلت فرم های توسعه وب قابل استفاده است.

برای استفاده از این Dialog در یک صفحه ASP.NET باید کتابخانه های jQuery و jQuery UI را دانلود کنید و در صفحه مورد نظر خود به آن ها ارجاع اسکریپتی بدهید. در این مطلب یک مثال ساده در مورد استفاده از jQuery UI Dialog  را توضیح خواهیم داد. پروژه مثال این مطلب را از اینجا دریافت کنید. قصد ندارم تمام کدهای نوشته شده در این پروژه مثال را توضیح بدهم، فقط نکات مهم مربوط به موضوع بحث را خواهید خواند. خواندن سورس کد و مشاهده مثال بهتر از توضیحات متنی به شما کمک می کند.

پس از دانلود و اجرای پروژه، با یک صفحه ساده مواجه خواهید شد که یک دکمه با عنوان Set Values در آن وجود دارد. با کلیک کردن بر روی این دکمه یک دیالوگ jQuery شبیه به تصویر زیر خواهید داشت :

jQuery UI Dialog Exampleدکمه Cancel دیالوگ را می بندد و دکمه OK برچسب های روی صفحه را با مقادیر تکست باکس ها هماهنگ می کند. jQuery UI Dialog در حالت معمول بعد از تگ form در ASP.NET رندر می شود که این باعث می شود تا دکمه های موجود در دیالوگ هیچ Post Backی به صفحه نداشته باشند که البته این مشکل به راحتی حل می شود. برای اینکه دکمه های موجود در دیالوگ بدون رفرش شدن صفحه کار خود را انجام بدهند، محتویات دیالوگ را درون یک UpdatePanel قرار می دهیم. مهمترین کدهایی که در مورد آن ها بحث می کنیم، کدهای جاوا اسکریپت زیر هستند :

<script type="text/javascript">
 $(document).ready(function () {
 $('#divValues').dialog({
 autoOpen: false,
 draggable: true,
 maxHeight: 440,
 width: 400,
 modal: true,
 title: "Enter values",
 open: function (type, data) {
 $(this).parent().appendTo("form");
 }
 });
 });

 function openDialog(id) {
 $('#' + id).dialog("open");
 }

 function closeDialog(id) {
 $('#' + id).dialog("close");
 }

 </script>

در واقع این کدهای بالا هستند که دیالوگ jQuery را می سازند و آن را باز و بسته می کنند. علامت $ که در ابتدای کد بکار رفته نشان دهنده این است که در حال استفاده از توابع کتابخانه jQuery هستیم. تابع اول دیالوگ را با خصوصیات مشخص شده مقدار دهی می کند. لیست کامل این خصوصیات را می توانید اینجا مشاهده کنید و بر اساس نیاز خود تغییر دهید. بعد از اجرای برنامه، تا زمانی که تابع openDialog صدا زده نشود، دیالوگ ما هم نشان داده نخواهد شد و در واقع jQuery آن را از دید کاربر مخفی نگه خواهد داشت. محتویات یک دیالوگ باید در یک div قرار بگیرند که نام آن باید برای dialog مشخص شود. نکته ای که شما به عنوان یک برنامه نویس ASP.NET در این مورد باید بدانید این است که حتماً UpdatePanel دیالوگ را داخل این div قرار دهید تا کدهایتان به درستی کار کند.

ویژگی خوب کتابخانه jQuery UI سبک بودن و سازگار بودن با اکثر مرورگرهای مدرن امروزی است. برای تغییر ظاهر دیالوگ هم دست شما بسیار باز است و می توانید از تم های آماده jQuery UI استفاده کنید و یا حتی استایل خود را برای آن بسازید.

دریافت پروژه مثال

یادگیری Castle ActiveRecord با مثال – قسمت پنجم

قسمت اول | قسمت دوم | قسمت سوم | قسمت چهارم

نکته : اگر از گوگل ریدر یا هر فیدخوان دیگری استفاده می کنید و کدها را به درستی مشاهده نمی کنید، لطفاً مطلب اصلی را در وبلاگ بخوانید.

اعتبار سنجی موجودیت ها در Castle ActiveRecord

یک ORM خوب بدون داشتن ویژگی Validation یا اعتبار سنجی کامل نیست. در Castle ActiveRecord با استفاده از کلاس ActiveRecordValidationBase می توان خصوصیات موجودیت ها را قبل از رسیدن به دیتابیس اعتبار سنجی کرد. برای این کار باید کلاس مورد نظر را از کلاس ActiveRecordValidationBase به جای کلاس ActiveRecordBase به ارث برد. با استفاده از امکانات موجود در فضای نام Castle.Components.Validator می توانید قوانین اعتبار سنجی مورد نظر خود را برای پراپرتی های کلاس خود تعریف کنید تا در صورت اشتباه بودن مقادیر وارد شده برای آن ها، آبجکت از ذخیره شدن اطلاعات در دیتابیس جلوگیری کند.   به مثال زیر توجه کنید :

[ActiveRecord(Table="Customers", Lazy=true)]
 public class Customer: ActiveRecordValidationBase<Customer>
 {
 [PrimaryKey(PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [ValidateNonEmpty]
 [Property(NotNull=true, Length=250)]
 public virtual string Title { get; set; }

 [Property(Length=50)]
 public virtual string ContactNumber { get; set; }

 [ValidateEmail("Not like an email")]
 [Property(Length=250)]
 public virtual string Email { get; set; }

 [ValidateLength(10,400)]
 [Property(Length=400)]
 public virtual string Address { get; set; }
}

این همان کلاس Customer پروژه مثال MyBookStore است که این بار از کلاس ActiveRecordValidationBase به ارث برده شده است که دارای یک متد مهم به نام IsValid است. در فضای نام Castle.Components.Validator صفت های اعتبارسنجی معمول برای استفاده در سنارویوهای معمول وجود دارد که می توانید از آن ها برای انجام اعمال اعتبارسنجی در سطح موجودیت ها استفاده کنید. در اینجا از صفت ValidateNonEmpty برای اطمینان از خالی یا null نبودن مقدار پراپرتی Title، از صفت ValidateEmail برای اطمینان از صحت فرمت ایمیل وارد شده توسط کاربر و از ValidateLenght برای اعتبارسنجی طول رشته وارد شده کاربر برای پراپرتی Address استفاده شده است.

از Validatorهای مهم دیگر این کتابخانه می توان به ValidateIsUnique که چک می کند مقدار خصوصیت در دیتابیس وجود نداشته باشد، ValidateRegExp که چک می کند مقدار خصوصیت با یک Regular Expression هماهنگ باشد و ValidateIsGreater و ValidateIsLesser که مقدار خصوصیت را با مقدار خصوصیت دیگری از نظر بزرگتر یا کوچکتری مقایسه می کند، اشاره نمود.

اگر کاربر بخواهد مقدار نامعتبری را به هر یک از خصوصیت های این کلاس نبست دهد، یک استثنا رخ خواهد داد. برای جلوگیری از این موضوع شما باید اول مطمئن شوید که مقادیر وارد شده برای خصوصیات یک موجودیت با توجه به Validatorهای تعریف شده برای هر کدام، معتبر باشند. متد IsValid چک می کند که تمام اعتبار سنجی ها با موفقیت انجام شده اند و سپس True برمی گرداند.
ممکن است برخی نیازهای اعتبارسنجی شما برای تعریف به صورت Attribute یک خصوصیت مناسب نباشد. اگر اینطور بود می توانید متد IsValid را Override کنید و متد base را زمانی صدا بزنید که مطمئن شدید اعتبار سنجی شما با موفقیت انجام شده است. برای مثال می خواهیم مطمئن شویم که برای خصوصیت Title این کلاس حتماً بیشتر از 6 کاراکتر وارد شود :

public override bool IsValid()
 {
 if (Title.Length > 6)
 return base.IsValid();
 else
 return false;
 }

اگر هر کدام از مقادیر وارد شده برای پراپرتی های این کلاس با توجه به Validation تعریف شده برای آن ها، معتبر نباشد، یک استثنای ValidationException رخ خواهد داد. برای تغییر این رفتار می توانید متد NotIsValid این کلاس را بر اساس نیاز خود Override کنید.

همانطور که مشاهده کردید، استفاده از Validationها و تعریف اعتبارسنجی های سفارشی در سطح موجودیت ها در Castle ActiveRecord بسیار آسان در عین حال قدرتمند است. شما بر اساس نیاز پروژه خود می توانید پیچیده ترین اعتبار سنجی ها را با استفاده از امکانات این کتابخانه در سطح موجودیت های خود پیاده سازی کنید. این یکی از دلایل مهمی است که Castle ActiveRecord را در نظر من و بسیاری دیگر محبوب ساخته است.

farasun.wordpress.com

این مطلب ادامه دارد…

برای اینکه مطالب بعدی را از دست ندهید، مشترک فید فراسان شوید!

یادگیری Castle ActiveRecord با مثال – قسمت چهارم

قسمت اول | قسمت دوم | قسمت سوم

نکته : اگر از گوگل ریدر یا هر فیدخوان دیگری استفاده می کنید و کدها را به درستی مشاهده نمی کنید، لطفاً مطلب اصلی را در وبلاگ بخوانید.

از آنجا که در حال حاضر انجام آزمایش های واحد یا Unit Testing نقش مهمی را در توسعه یک نرم افزار ایفا می کند، در این قسمت می خواهیم نحوه نوشتن آزمایش واحد برای لایه دسترسی به داده هایی که با Castle ActiveRecord توسعه داده شده است را مورد بررسی قرار دهیم. برای این کار از فریم ورک اوپن سورس NUnit استفاده خواهیم کرد. قبل از هر کاری کتابخانه NUnit را از اینجا دریافت کنید. خواهید دید که انجام تست های واحد بر روی کلاس های Castle ActiveRecord به راحتی امکان پذیر است.

برای اینکه مطمئن شویم مدل برنامه مثال ما درست کار می کند، از تست واحد استفاده می کنیم. شاید بهتر بود قبل از نوشتن پست های قبلی، ابتدا تست واحد را می نوشتم اما به نظرم اینطوری توضیح دادن کدها مشکل تر بود. دست بکار شوید و یک پروژه جدید به نام MyBookStore.Test به Solution خود اضافه کنید و به فایل های Castle.ActiveRecord ، NHibernate.dll ، NUnit.Framework.dll و MyBookStore.Model.dll ارجاع دهید.

اگر خاطرتان باشد اولین کاری که پس از مشخص شدن مدل برنامه کردیم، راه اندازی اولیه CAR در هنگام اجرای برنامه بود. کلاس ActiveRecordStarter برای این مورد کاربرد دارد. در برنامه اصلی تنظیمات ActiveRecord را از فایل App.config خواندیم اما در اینجا می خواهیم از یک فایل جداگانه تنظمیات را بخوانیم چون قرار است تست واحد با استفاده از NUnit Test Runner اجرا شود. یک کلاس جدید به نام TestCase به این پروژه اضافه کنید و کدهای زیر را در آن بنویسید :

using System;
using System.Collections.Generic;
using NUnit.Framework;
using Castle.ActiveRecord;
using Castle.ActiveRecord.Framework;
using Castle.ActiveRecord.Framework.Config;
using MyBookStore.Model;

namespace MyBookStore.Test
{
[TestFixture]
 public class TestCase
 {

 [TestFixtureSetUp]
 public virtual void FixtureSetup()
 {
 IConfigurationSource configSource =
 new XmlConfigurationSource("ActiveRecordConfig.xml");
 ActiveRecordStarter.Initialize(typeof(Book).Assembly,configSource);
 }

 [SetUp]
 public virtual void OneTimeSetup()
 {
 ActiveRecordStarter.DropSchema();
 ActiveRecordStarter.CreateSchema();
 }

 [Test]
 public void InsertMyBook()
 {
 using (new SessionScope())
 {
 Book book = new Book()
 {
 Title = "Learn Castle ActiveRecord",
 BuyPrice = 1000,
 SalePrice = 2000
 };
 Category category = new Category() { Title = "ORM" };
 category.Create();
 Author author = new Author() { Title = "Iman Nemati" };
 author.Create();
 Publisher publisher = new Publisher() { Title = "Farasun" };
 publisher.Create();
 book.Categories = new List<Category>();
 book.Categories.Add(category);
 book.Author = author;
 book.Publisher = publisher;
 book.Create();
 Book[] books = Book.FindAll();
 Assert.AreEqual(1, books.Length);
 Assert.AreEqual("Iman Nemati", books[0].Author.Title);
 }
 }
 }
}
}

پروژه را کامپایل کنید تا اسمبلی MyBookStore.Test ساخته شود. حالا یک فایل XML به نام ActiveRecordConfig.xml با محتویات زیر به پروژه خود اضافه کنید :

<?xml version="1.0" encoding="utf-8" ?>
<activerecord>
<config>
<add key="connection.driver_class"
value="NHibernate.Driver.SqlClientDriver"/>
<add key="dialect"
value="NHibernate.Dialect.MsSql2008Dialect"/>
<add key="connection.provider"
value="NHibernate.Connection.DriverConnectionProvider"/>
<add key="connection.connection_string"
value="Data Source=.\SQLEXPRESS;Initial Catalog=MyBookStoreTest;Integrated Security=True;Pooling=False"/>
<add key="proxyfactory.factory_class" value="NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle"/>
</config>
</activerecord>

بر روی این فایل کلیک راست کنید و گزینه Properties را کلیک کنید و خاصیت  Copy to Output Directory را برابر Copy always قرار دهید. برای انجام تست واحد نیاز به یک دیتابیس جدا از دیتابیس اصلی داریم. برای این کار در Server Explorer دیتابیس جدیدی به نام MyBookStoreTest بسازید و اگر نیاز است تغییراتی در فایل Config بالا اعمال کنید تا مشکلی پیش نیاید. بعد از اتمام این کار، NUnit Test Runner را اجرا کنید. این فایل معمولاً در مسیر کتابخانه ای که دانلود کرده اید قرار دارد. پس از اجرای این برنامه، از منوی File گزینه Open Project را برگزینید و فایل اسمبلی MyBookStore.Test.dll در مسیر bin\Debug پروژه خود را انتخاب کنید. پس از این کار باید متدهای تست برنامه خود را مشاهده کنید. در اینجا ما فقط یک تست واحد نوشتیم که یک موجودیت Book را با خاصیت ها و روابط مشخص شده در دیتابیس ایجاد می کند و سپس چک می کند که آیا این موجودیت با موفقیت به دیتابیس اضافه شده است یا نه و بعد از آن نام نویسنده را با رشته مورد انتظار ما مقایسه می کند تا از صحت اطلاعات درج شده اطمینان پیدا کنیم. اگر تمام کارها را به درستی انجام داده باشید با کلیک روی دکمه Run، تست واحد شما با موفقیت Pass خواهد شد.

این تست چطور کار می کند؟

اگر با انجام تست واحد آشنایی دارید می توانید این بخش را نخوانید. کلاس TestCase با خاصیت TestFixture همراه شده که این مشخص می کند این کلاس دارای متدهایی برای تست است. متد FixtureSetup همانطور که از نامش مشخص است و با توجه به خاصیت TestFixtureSetup که برای آن تعریف شده، وظیفه مقداردهی های اولیه برای متدهای تست کلاس را بر عهده دارد و فقط یکبار در طول تست اجرا می شود. متد OneTimeSetup نیز که با خاصیت SetUp مشخص شده فقط یکبار برای تمام تست ها اجرا خواهد شد. متد InsertMyBook که با خاصیت Test مشخص شده، متدی است که Fail یا Pass شدن آن برای ما مهم است. در این متد با استفاده از Assert می توان شرط های مختلفی را آزمایش کرد تا از صحت کارکرد متد مطمئن شد. شما می توانید غیر از این متد، متدهای دیگری نیز با مشخصه Test به این کلاس اضافه کنید و تست های واحد خود را برای متدهای مختلف بنویسید.

farasun.wordpress.com

این مطلب ادامه دارد…

برای اینکه مطالب بعدی را از دست ندهید، مشترک فید فراسان شوید!

یادگیری Castle ActiveRecord با مثال – قسمت سوم

قسمت اول | قسمت دوم

در ادامه می خواهیم اعمال CRUD را برای هر یک از کلاس های برنامه پیاده سازی کنیم. اگر از هر یک از کلاس های دامین برنامه یک نمونه بسازید متوجه خواهید شد که به علت مشتق شدن تمامی این کلاس ها از کلاس ActiveRecordBase تمامی اعمال مورد نظر ما توسط CAR پیاده سازی شده اند! یعنی شما نیازی نیست برای انجام اعمال CRUD متدهایی جدیدی به کلاس های دامین برنامه اضافه کنید. در واقع Castle ActiveRecord یک لایه دسترسی به داده های کامل برای شما مهیا می کند. کافیست شما قوانین تجاری برنامه خود را با override کردن متدهای کلاس ActiveRecordBase اعمال کنید.

برای درک بهتر فرض کنید می خواهیم یک کتاب جدید ایجاد و به دیتابیس اضافه کنیم. کد زیر را برای این کار می نویسیم :

using (new SessionScope())
 {
 Book book = new Book()
 {
 BuyPrice = 1000,
 SalePrice = 1200,
 Title = "Castle ActiveRecord"
 };
 book.Categories = new List<Category>();
 Category category = new Category() { Title = "ORM" };
 category.Save();
 book.Categories.Add(category);
 Author author = new Author() { Title = "Iman Nemati" };
 author.Save();
 book.Author = author;
 Publisher publisher = new Publisher() { Title = "Farasun" };
 publisher.Save();
 book.Publisher = publisher;
 book.Save();
 }

خوشبختانه این کد آنقدر واضح است که نیازی به توضیح اضافه ندارد. یکی از مزایای مهم استفاده از یک ORM همین واضح بودن کدهاست. متد Save ابتدا شیء را برای داشتن یک ID معتبر بررسی می کند و سپس بر اساس آن عمل Insert یا Update را انجام خواهد داد. در اینجا از SessionScope برای Insert کردن آبجکت های مختلف استفاده کردیم. با این کار Castle ActiveRecord یک ISession را برای ذخیره کردن تمام آبجکت های ما در دبتابیس بکار می گیرد. برای ذخیره کردن یک آبجکت به تنهایی نیاز به استفاده از SessionScope ندارید.

حالا فرض کنید می خواهیم شیء کتابی که در بالا به دیتابیس اضافه کردیم را به روز رسانی کنیم. مثلاً عنوان کتاب را عوض کنیم. برای این کار ابتدا باید اطلاعات کتاب مورد نظرمان را در یک آبجکت Load کنیم، اطلاعات آن را تغییر دهیم و برای ذخیره به دیتابیس بفرستیم. کلاس ActiveRecordBase متدهایی مناسبی را برای خواندن و به روز رسانی اطلاعات در اختیارمان قرار می دهد. با متد Find می توانیم اطلاعات یک آبجکت را بوسیله ID یکتای آن از دیتابیس بخوانیم و پس از اعمال تغییرات با استفاده از متد Save تغییرات را به دیتابیس بفرستیم.

Book book = Book.Find(SelectedBookId);
 book.Title = "Learn Castle ActiveRecord with Example";
 book.Save();

همانطور که می بینید انجام اعمال CRUD با استفاده از CAR به سادگی انجام پذیر هستند. به همین ترتیب برای Delete و Update نیز متدهای مناسب وجود دارد. فقط باید توجه داشته باشید که برای انجام Delete و Update آبجکت شما باید دارای یک ID معتبر باشد، اما برای Insert احتیاجی به ID معتبر نیست.

بازیابی رکوردها (Retrive)

همانطور که در اولین قسمت این سری آموزشی گفته شد، در الگوی ActiveRecord متدهای استاتیک بر روی کل رکوردهای دیتابیس و متدهای داینامیک (آن هایی که حتماً باید اول نمونه سازی شوند و سپس مورد استفاده قرار گیرند) بر روی یک رکورد خاص عمل می کنند. کلاس ActiveRecordBase شامل یکسری متد استاتیک است که بیشتر به منظور یافتن رکوردها بر اساس یک شرط پیاده سازی شده اند. برای دستیابی به رکوردها در دیتابیس می توانید از متدهای استاتیک زیر کمک بگیرید :

  • Find : آبجکتی شامل اطلاعات رکوردی از دیتابیس با ID مشخص شده را برمی گرداند.
  • FindAll : آرایه ای از آبجکت ها شامل اطلاعات تمام رکوردهای موجود در دیتابیس برای این کلاس را بر می گرداند.
  • FindAllByProperty : آرایه ای از آبجکت ها شامل اطلاعات تمام رکوردهایی که با شرط Property = Value برابر باشند را برمی گرداند.
  • TryFind : مانند Find است با این تفاوت که اگر رکوردی که با ID پاس داده شده وجود نداشته باشد هیچ خطایی رخ نخواهد داد.

بحثی در مورد بقیه متدهای این کلاس نخواهیم کرد چون می خواهیم برای دستیابی به رکوردها از کوئری های LINQ استفاده کنیم. برای این کار در پروژه Model برنامه مثال به فایل Castle.ActiveRecord.Linq ارجاع دهید. با استفاده از این کتابخانه می توانید از قابلیت های معمولی Linq برای اجرای کوئری روی کلاس های مدل خود برخوردار شوید. متدهای زیر را به کلاس Book خود اضافه کنید : (یادتان نرود اول فضای نام Castle.ActiveRecord.Linq را using کنید)

public static Book GetByID(long id)
 {
 return (from x in ActiveRecordLinq.AsQueryable<Book>()
 where x.ID == id
 select x).First();
 }

 public static List<Book> GetByAuthor(long authorID)
 {
 return (from x in ActiveRecordLinq.AsQueryable<Book>()
 where x.Author.ID == authorID
 select x).ToList();
 }

 public static List<Book> SearchWithTitle(string title)
 {
 return (from x in ActiveRecordLinq.AsQueryable<Book>()
 where x.Title.Contains(title)
 select x).ToList();
 }

 public static List<Book> GetBooksByPriceBetween
(decimal lowPrice, decimal highPrice)
 {
 return (from x in ActiveRecordLinq.AsQueryable<Book>()
 where x.SalePrice >= lowPrice &&
 x.SalePrice <= highPrice
 select x).ToList();
 }

همانطور که مشاهده می کنید با استفاده از سینتاکس آشنای Linq هر نتیجه ای که بخواهید می توانید از اطلاعات موجود در دیتابیس بدست آورید. حالا باید خودتان بتوانید متدهای مورد نیاز برای دسترسی به رکوردها را برای بقیه کلاس های پروژه بنویسید. پس دست به کار شوید!

farasun.wordpress.com

این مطلب ادامه دارد…

برای اینکه مطالب بعدی را از دست ندهید، مشترک فید فراسان شوید!

یادگیری Castle ActiveRecord با مثال – قسمت دوم

قسمت اول

در ادامه می خواهیم امکان فروش کتاب ها را به برنامه خود اضافه کنیم. برای این کار باید یک کلاس برای نگهداری اطلاعات فروش کتاب ها و یک کلاس برای نگهداری اطلاعات فروش مربوط به مشتریان بسازیم. برای درک بهتر می توان گفت کلاس Order اطلاعات صورت حساب مشتری را نگهداری می کند که در این صورت حساب ممکن است یک یا چند OrderItem وجود داشته باشد که هر کدام از این OrderItemها مشخص کننده تعداد یک کتاب مشخص سفارش داده شده توسط مشتری است. کلاس های زیر را به پروژه خود اضافه کنید:

کلاس Order برای نگهداری صورت حساب مشتری (Order.cs) :

[ActiveRecord(Table="Orders", Lazy=true)]
 public class Order: ActiveRecordBase<Order>
 {
 [PrimaryKey(Generator=PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [Property(NotNull=true)]
 public virtual DateTime OrderDate { get; set; }

 [Property(NotNull=true)]
 public virtual decimal TotalPrice { get; set; }

[HasMany(typeof(OrderItem), Inverse=true, Lazy=true, Cascade=ManyRelationCascadeEnum.AllDeleteOrphan)]
 public virtual IList<OrderItem> Items { get; set; }

 [BelongsTo(Column="CustomerID", NotNull=true)]
 public virtual Customer Customer { get; set; }
 }

کلاس OrderItem برای نگهداری اطلاعات فروش کتاب ها (OrderItem.cs) :

[ActiveRecord(Table="OrderItems", Lazy=true)]
 public class OrderItem: ActiveRecordBase<OrderItem>
 {
 [PrimaryKey(PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [BelongsTo(Column="BookID", NotNull=true)]
 public virtual Book Book { get; set; }

 [Property(NotNull=true)]
 public virtual int Count { get; set; }

 [BelongsTo(Column="OrderID")]
 public virtual Order Order { get; set; }
 }

همانطور که مشاهده می کنید هر Order متعلق به یک Customer است که با صفت BelongsTo در تعریف کلاس مشخص شده و دارای یک یا چند OrderItem است که با صفت HasMany تعریف شده است. چند نکته به نظر می رسد که باید بیشتر در موردشان توضیح داده شود :

  • مشخص کردن کلاس به عنوان Lazy از این جهت است که NHibernate بتواند مجموعه ای از اشیای از نوع این کلاس را به صورت Lazy بار گذاری کند. یعنی هر زمانی که نیاز به اطلاعات این کلاس ها بود، NHibernate اطلاعات را از دیتابیس بخواند.
  • NHibernate برای انجام Lazy Loading در سطح یک کلاس احتیاج دارد که شما تمام پراپرتی ها را به صورت virtual تعریف کنید.
  • در رابطه های HasMany و HasAndBelongsToMany نیاز است تا نوع کلاس طرف دیگر رابطه را با آوردن typeof و نام کلاس مورد نظر مشخص کنید. در مورد رابطه های BelongsTo نیازی به مشخص کردن نوع طرف دیگر رابطه نداریم و نوع پراپرتی همان نوع طرف دیگر رابطه است.
  • در رابطه های مختلف می توانید حالت Cascade را نیز مشخص کنید که اگر مثلاً رکورد یک طرف رابطه حذف شد، رکوردهای وابسته به آن در طرف دیگر رابطه حذف شوند تا داده یتیم در سیستم وجود نداشته باشد.
  • مقدار دهی درست Inverse در رابطه ها بسیار مهم است.معمولاً  شما باید Inverse طرفی را true قرار دهید که با صفت HasMany مشخص شده است.
  • استفاده به جا از Lazy=true در صفت رابطه ها باعث بالا رفتن کارایی برنامه شما خواهد شد.

خب تا اینجا تمام کلاس های مورد نیازمان برای ساختن یک برنامه کتاب فروشی را نوشتیم. حالا می توانید یک کلاس دیاگرام به پروژه خود اضافه کنید (با Add New item و انتخاب گزینه ClassDiagram) و تمام کلاس های ایجاد شده را در آن Drag & Drop کنید تا رابطه های میان کلاس ها را به صورت ویژوال مشاهده کنید. تقریباً کارمان با این پروژه به پایان رسیده. بر روی پروژه خود کلیک راست کنید و گزینه Build را بزنید تا Class Library شما ساخته شود.

حالا بر روی Solution کلیک راست کنید و پروژه جدیدی از نوع Windows Application اضافه کنید. فایل های Castle.ActiveRecord.dll و NHibernate.ByteCode.Castle و البته فایل کتابخانه مدل برنامه خود که ساخته اید را به ارجاعت این پروژه اضافه کنید. سپس یک فایل App.config را با کلیک راست بر روی نام پروژه، برگزیدن Add New Item و انتخاب Application Configuration file به این پروژه اضافه کنید و محتویات زیر را به جای محتویات پیش فرض آن کپی کنید:

<?xml version="1.0"?>
<configuration>
 <configSections>
 <section name="activerecord" type="Castle.ActiveRecord.Framework.Config.ActiveRecordSectionHandler, Castle.ActiveRecord"/>
 </configSections>

 <activerecord>

 <config>
 <add key="connection.driver_class" value="NHibernate.Driver.SqlClientDriver"/>

 <add key="dialect" value="NHibernate.Dialect.MsSql2008Dialect"/>
 <add key="connection.provider" value="NHibernate.Connection.DriverConnectionProvider"/>
 <add key="connection.connection_string" value="Data Source=.\SQLEXPRESS;Initial Catalog=MyBookStore;Integrated Security=True;Pooling=False"/>

 <add key="proxyfactory.factory_class" value="NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle"/>
 </config>

 </activerecord>

<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>

سپس در پنجره Server Explorer یک دیتابیس جدید به نام MyBookStore بسازید. در اینجا می خواهیم جداول مورد نیاز مدل برنامه خودمان را در یک دیتابیس SQL Server بسازیم. برای این کار فایل Program.cs را باز کنید و به صورت زیر تغییر دهید:

using System;
using System.Windows.Forms;
using System.Configuration;
using Castle.ActiveRecord;
using Castle.ActiveRecord.Framework;
using MyBookStore.Model;

namespace MyBookStore
{
 static class Program
 {
 /// <summary>
 /// The main entry point for the application.
 /// </summary>
 [STAThread]
 static void Main()
 {
 Application.EnableVisualStyles();
 Application.SetCompatibleTextRenderingDefault(false);
 IConfigurationSource configSource = ConfigurationManager.GetConfig("activerecord") as IConfigurationSource;
 ActiveRecordStarter.Initialize(configSource, typeof(Book), typeof(Author), typeof(Publisher),
 typeof(Category), typeof(Customer), typeof(Order), typeof(OrderItem));
 ActiveRecordStarter.CreateSchema(); //اینجا دیتابیس از روی کلاس ها ساخته می شود
 Application.Run(new Form1());
 }
 }
}

اگر تمام کار ها را به درستی انجام داده باشید با زدن دکمه F5 دیتابیس شما به صورت زیر ساخته خواهد شد:

Server Explorerهمانطور که مشاهده می کنید به ازای هر یک از کلاس های برنامه ما یک Table در دیتابیس ساخته شده و برای ایجاد رابطه چند به چند میان موجودیت Category و Book نیز یک Table واسط به نام BookCategories ساخته شده است.

برای تنظیم اولیه Castle ActiveRecord چند راه وجود دارد که در اینجا من از IConfigurationSource استفاده کردم و تنظیمات را از فایل کانفیگ برنامه خواندم و به ActiveRecordStarter.Initialize فرستادم. در این متد باید نوع تمام کلاس هایی که قرار است Map شوند را برای CAR مشخص کنید. سپس با استفاده از متد CreateSchema از کلاس ActiveRecordStarter دیتابیس را بر روی SQL Server می سازم. CAR برای انجام این کار از تنظیماتی که در فایل App.config مشخص شده است، استفاده می کند. همانطور که می بینید در تنظیمات مشخص کرده ام که قرار است دیتابیس بر روی SQL Server 2008 با Connection String مشخص شده ساخته شود. البته نوشتن CreateSchema در متد Main برنامه کار درستی نیست. شما باید فقط زمانی دیتابیس را از ابتدا بسازید که دیتابیس برنامه از قبل وجود نداشته باشد. در واقع فقط هنگام نصب برنامه (یا اجرای اول برنامه) دیتابیس باید بوسیله این متد ساخته شود و در دفعات بعدی از آن برای ذخیره و بازیابی داده ها استفاده شود.

اگر بخواهیم Database Diagram یا همان ERD این پروژه را مشاهده کنیم، باید نموداری شبیه به نمودار زیر را داشته باشیم:

MyBookStore ERDدر تصویر بالا می توانید تمام ارتباط هایی که قبلا در کلاس ها تعریف کرده ایم را مشاهده کنید.

دریافت پروژه مثال تا اینجا (لطفاً پس از دریافت، پسوند فایل را به zip تغییر داده و سپس فایل را باز کنید!)

یک نکته : اگر از گوگل ریدر یا هر فیدخوان دیگری استفاده می کنید و کدها را به درستی مشاهده نمی کنید، لطفاً پست اصلی را در وبلاگ بخوانید.

farasun.wordpress.com

این مطلب ادامه دارد…

برای اینکه مطالب بعدی را از دست ندهید، مشترک فید فراسان شوید!

یادگیری Castle ActiveRecord با مثال – قسمت اول

Castle ActiveRecord پیاده سازی الگوی ActiveRecord برای پلت فرم دات نت است که در آن هر نمونه از یک کلاس به عنوان یک رکورد در دیتابیس در نظر گرفته می شود که با ساخته شدن یک نمونه از کلاس، یک رکورد در دیتابیس درج می شود و با به روز شدن اطلاعات آن کلاس، رکورد مورد نظر در دیتابیس به روز می شود. متدهای استاتیک درون کلاس ها بر روی کل یا مجموعه ای از رکوردهای دیتابیس عمل می کنند.
Castle ActiveRecord پیاده سازی الگوی ActiveRecord برای پلت فرم دات نت مایکروسافت است که بر روی NHibernate ساخته شده و به عنوان یک لایه دسترسی به داده ها عمل می کند و پیچیدگی های NHibernate را از دید برنامه نویس مخفی نگه می دارد. انجام عمل Mapping در CAR به صورت اضافه کردن خاصیت به کلاس ها انجام می گیرد و شما را از نوشتن فایل های XML برای انجام نگاشت کلاس ها رها می سازد. با استفاده از Castle ActiveRecord دیگر نیازی به یادگیری نحوه نگاشت فایل های XML در NHibernate ندارید و در چند دقیقه می توانید یک لایه دسترسی به داده های کامل و بی نقص را پیاده سازی کنید. اکثر پیچیدگی های NHibernate بوسیله CAR هندل می شوند. در حال حاضر CAR زیر مجموعه ای از قابلیت های نگاشت NHibernate را که توسط اکثر برنامه نویسان و بیشتر سناریوها مورد استفاده قرار می گیرد را پوشش می دهد.

در این مطلب و مطالب آینده، با بررسی یک مثال نحوه استفاده از Castle ActiveRecord به عنوان یک لایه برای دسترسی به داده ها که بر روی NHibernate ساخته شده است را یاد خواهید گرفت. پیش نیاز یادگیری این مطلب آشنایی با مفهوم ORM است. بهتر است قبل از خواندن این نوشته، مطالب زیر را خوانده باشید :

بررسی مدل برنامه مثال

می خواهیم برنامه ای تحت ویندوز برای کتاب فروشی ها بنویسیم که اطلاعات کتاب ها، مشتریان و فروش یک کتاب فروشی کوچک را مدیریت کند. در این برنامه هر کتاب می تواند یک نویسنده و یک ناشر داشته باشد و در دسته بندی های مختلفی قرار بگیرد. کاربر می تواند اطلاعات فروش کتاب ها را به ازای هر مشتری وارد کند. برای درک بهتر مدل برنامه نگاهی به کلاس دیاگرام زیر بیندازید :

MyBookStore Domain Modelبرای شروع، آخرین نسخه کتابخانهCastle ActiveRecord را از اینجا دانلود کنید. ویژوال استادیو را باز کنید و یک سولوشن خالی ایجاد کنید. یک پروژه از نوع Class Library با نام MyBookStore.Model به سولوشن خود اضافه کنید و کتابخانه Castle.ActiveRecord را به ارجاعات این پروژه اضافه نمایید. یک کلاس به نام Category به این پروژه اضافه کنید، فضای نام Castle.ActiveRecord را using کنید و کدهای زیر را در بدنه آن بنویسید (کپی کنید!) :

[ActiveRecord(Table="Categories", Lazy=true)]
    public class Category: ActiveRecordBase<Category>
    {
        [PrimaryKey(Generator=PrimaryKeyType.Native)]
        public virtual long ID { get; set; }

        [Property(NotNull=true, Length=100)]
        public virtual string Title { get; set; }
    }

اصلاً نگران نباشید اگر منظور Attributeهای اضافه شده به کلاس بالا را متوجه نمی شوید. یکی از مزایای CAR نسبت به استفاده مستقیم از NHibernate همین نحوه نگاشت کلاس ها بر اساس Attributeهاست. در این روش دیگر نیازی به نوشتن فایل های XML برای انجام عمل Mapping ندارید و کدهای نوشته شده در کلاس شما از خوانایی بسیار بالایی برخوردار خواهند بود.

حالا کلاس دیگری به نام Customer به پروژه خود اضافه کنید و کدهای زیر را در آن بنویسید (قبلش فضای نام Castle.ActiveRecord را using کنید ) :


[ActiveRecord(Table="Customers", Lazy=true)]
 public class Customer: ActiveRecordBase<Customer>
 {
 [PrimaryKey(PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [Property(NotNull=true, Length=250)]
 public virtual string Title { get; set; }

 [Property(Length=50)]
 public virtual string ContactNumber { get; set; }

 [Property(Length=250)]
 public virtual string Email { get; set; }

 [HasMany(typeof(Order), Inverse=true, Lazy=true)]
 public virtual IList<Order> Orders { get; set; }
 }

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

  • با اضافه کردن صفت ActiveRecord مشخص می کنیم که این کلاس قرار است به یک Table در دیتابیس Map شود.
  • با مقدار دهی Table می توانید نام جدولی که قرار است در دیتابیس ساخته شود را تعیین کنید. اگر مقدار دهی نشود به صورت پیش فرض نام کلاس را برای نام Table انتخاب می کند.
  • در هر کلاس یک پراپرتی به نام ID وجود دارد که با صفت PrimaryKey معرفی شده اند. با این کار یک فیلد به نام ID به عنوان کلید اصلی در Table ایجاد می شود و نوع آن Identity خواهد بود (البته در SQL Server)
  • اعضایی که با صفت Property مشخص شده اند، فیلدهای Table را مشخص می کنند. هر کدام از این اعضا به صورت پیش فرض Nullable هستند که می توانید با مقدار دهی NotNull برای هر کدام این پیش فرض را تغییر دهید.
  • برای اعضای String می توانید Length مشخص کنید.

برای ادامه کلاس های زیر را به پروژه تان اضافه کنید. یادتان نرود در هر کدام فضای نام Castle.ActiveRecord را using کنید!

کلاس Author برای نگهداری اطلاعات یک نویسنده :

Author.cs

[ActiveRecord(Table="Authors", Lazy=true)]
 public class Author: ActiveRecordBase<Author>
 {
 [PrimaryKey(Generator=PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [Property(NotNull=true, Length=100)]
 public virtual string Title { get; set; }

کلاس Publisher برای نگهداری اطلاعات ناشر یک کتاب : Publisher.cs

[ActiveRecord(Table="Publishers", Lazy=true)]
public class Publisher: ActiveRecordBase<Publisher>
{
[PrimaryKey(Generator=PrimaryKeyType.Native)]
public virtual long ID { get; set; }</p>
<p dir="ltr">[Property(NotNull=true, Length=100)]
public virtual string Title { get; set; }</p>
<p dir="ltr">[Property(Length=400)]
public virtual string Description { get; set; }
}

کلاس Book برای نگهداری اطلاعات یک کتاب : Book.cs

[ActiveRecord(Table="Books", Lazy=true)]
public class Book: ActiveRecordBase&lt;Book&gt;
{
[PrimaryKey(Generator=PrimaryKeyType.Native)]
public virtual long ID { get; set; }</p>
[Property(NotNull=true, Length=250)]
public virtual string Title { get; set; }

[Property(NotNull=true)]
public virtual decimal BuyPrice { get; set; }

[Property(NotNull=true)]
public virtual decimal SalePrice { get; set; }

[BelongsTo(Column="AuthorID", NotNull=true)]
public virtual Author Author { get; set; }

[BelongsTo(Column="PublisherID", NotNull=true)]
public virtual Publisher Publisher { get; set; }

[HasAndBelongsToMany(typeof(Category), Table="BookCategories" ,
 ColumnKey="BookID", ColumnRef="CategoryID")]
public virtual IList Category Categories { get; set; }
}

کلاس های Author و Publisher نکته جدیدی ندارند اما اگر به تعریف کلاس Book توجه کنید Attributeهای جدیدی می بینید. با توجه به مدل برنامه (که تصویر آن در ابتدای مطلب آمده) موجودیت Book با موجودیت های دیگر ارتباط دارد که باید در تعریف این کلاس این ارتباط ها را معرفی کنیم. پراپرتی های Author و Publisher با صفت BelongsTo به همراه NotNull=true مشخص شده اند. این یعنی هر Book باید متعلق به یک Author و یک Publisher مشخص باشد. پراپرتی Categories لیستی از نوع کلاس Category است که در ابتدای مطلب تعریف آن را دیدید. این پراپرتی با صفت HasAndBelongsToMany مشخص شده است که منظور رابطه چند به چند میان کتاب ها و دسته بندی هاست. در این رابطه ColumnKey فیلدی است که آی دی Book و ColumnRef فیلدی است که آی دی یک Category را برای ایجاد رابطه چند به چند ذخیره می کند. در طرف دیگر رابطه (یعنی در کلاس Category) جای ColumnKey و ColumnRef باید عوض شود اما نام Table باید یکی باشد.

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

کلاس Author :

[ActiveRecord(Table="Authors", Lazy=true)]
 public class Author: ActiveRecordBase<Author>
 {
 [PrimaryKey(Generator=PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [Property(NotNull=true, Length=100)]
 public virtual string Title { get; set; }

 [HasMany(typeof(Book), Inverse=true, Lazy=true)]
 public virtual IList<Book> Books { get; set; }
 }

کلاس Publisher :

[ActiveRecord(Table="Publishers", Lazy=true)]
 public class Publisher: ActiveRecordBase<Publisher>
 {
 [PrimaryKey(Generator=PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [Property(NotNull=true, Length=100)]
 public virtual string Title { get; set; }

 [Property(Length=400)]
 public virtual string Description { get; set; }

 [HasMany(typeof(Book), Inverse=true, Lazy=true)]
 public virtual IList<Book> Books { get; set; }
 }

کلاس Category :

[ActiveRecord(Table="Categories", Lazy=true)]
 public class Category: ActiveRecordBase<Category>
 {
 [PrimaryKey(Generator=PrimaryKeyType.Native)]
 public virtual long ID { get; set; }

 [Property(NotNull=true, Length=100)]
 public virtual string Title { get; set; }

 [HasAndBelongsToMany(typeof(Book), Table="BookCategories", ColumnKey="CategoryID", ColumnRef="BookID")]
 public virtual IList<Book> Books { get; set; }
 }

همانطور که مشاهده می کنید نیازی نیست تمام تعریف کلاس های بالا را تغییر دهید، فقط کافیست پراپرتی های جدید را به همان کلاس های قبلی اضافه کنید. در کلاس های Author و Publisher یک پراپرتی به نام Books از نوع لیستی از کلاس Book با صفت HasMany تعریف شده است. HasMany مشخص کننده یک رابطه یک به چند از این موجودیت ها به موجودیت «کتاب» است. Inverse=true مشخص می کند که طرف دیگر رابطه یعنی Book مسئول ذخیره کردن اطلاعات است و Lazy=true ویژگی Lazy Loading را برای این مجموعه فعال می کند.

پراپرتی جدید کلاس Category مشخص کننده رابطه چند به چند این موجودیت با موجودیت Book است. اگر به تعریف کلاس Book نگاهی دوباره بیندازید مشاهده می کنید که این رابطه برای کلاس Book تعریف شده است. در Castle ActiveRecord همیشه باید رابطه ها را برای هر دو طرف یک رابطه تعریف کنید. برای یک رابطه چند به چند باید از صفت HasAndBelongsToMany استفاده کنید و ColumnKey، ColumnRef و Table را طوری مقدار دهی کنید که در انتها یک رابطه چند به چند به درستی بین دو موجودیت بوسیله یک Table واسط ایجاد شود. ColumnKey همیشه کلید خارجی موجودیت جاری است و ColumnRef کلید خارجی طرف دیگر رابطه را مشخص می کند. نام Table برای هر دو طرف رابطه باید یکی باشد تا CAR بتواند رابطه چند به چند را برای شما ایجاد کند.

farasun.wordpress.com

این مطلب ادامه دارد…

برای اینکه مطالب بعدی را از دست ندهید، مشترک فید فراسان شوید!