اهمیت jQuery برای برنامه نویسان ASP.NET

شاید تا به حال برنامه نویسان ASP.NET به لطف کنترل های WebForms و ASP.NET AJAX نیازی به یادگیری جاوا اسکریپت احساس نکرده باشند، اما پس از ارائه ASP.NET MVC و افزایش محبوبیت jQuery در جامعه دات نت، دیگر هر برنامه نویسی برای گذران زندگی از این طریق باید به جاوا اسکریپت و به طور خاص با کتابخانه معروف jQuery آشنایی داشته باشد. در حال حاضر کمتر وب سایت و پروژه تحت وب معروفی در جامعه دات نت پیدا خواهید کرد که از jQuery استفاده نکند.

jQuery چیست و چه فرقی با Java Script دارد؟

JQuery - a new kind on java script libraryjQuery یک فریم ورک سریع و سبک به زبان جاوا اسکریپت است که از CSS3 و اکثر مرورگرهای حال حاضر به صورت کامل پشتیبانی می کند و بسیاری از کارها را که با جاوا اسکریپت به سختی و با نوشتن کدهای فراوان باید انجام داد را به راحتی و با نوشتن کد کمتر می توان انجام داد. جاوا اسکریپت یک زبان اسکریپت نویسی سمت کلاینت است و jQuery یکی از فریم ورک های محبوب برای این زبان است.

jQuery چه ربطی به برنامه نویسان ASP.NET دارد؟

مایکروسافت در حال حاضر به صورت رسمی از jQuery پشتیبانی می کند و پروژه های ASP.NET MVC که در ویژوال استادیو 2010 می سازید، به صورت پیش فرض از jQuery استفاده می کنند. این پشتیبانی رسمی دلیل بسیار محکمی است برای ما برنامه نویسان تکنولوژی های مایکروسافت که به یادگیری jQuery بپردازیم. اما دلایل مهم دیگری نیز وجود دارد. یادگیری و استفاده از jQuery نسبت به کارهایی که برای شما انجام می دهد، آسان است. با تمام مرورگرهای محبوب حال حاضر مثل IE, Firefox, Chrome, Opera, Safari سازگاری کامل دارد. شما کدهای خود را یکبار می نویسید و دیگر نگران نوع مرورگر کاربر برای اجرای این کدها نخواهید بود. با استفاده از jQuery می توانید به راحتی تمام عناصر صفحه را پس از رندر شدن تغییر دهید. انجام اعمال AJAX با استفاده از این فریم ورک امکان پذیر است و معمولاً کارایی بهتری نسبت به ASP.NET AJAX دارد.

از کجا شروع کنیم؟

هرچند jQuery به صورت پیش فرض در پروژه های ویژوال استادیو 2010 پیدا می شود اما شما می توانید آخرین نسخه jQuery را از سایت رسمی اش دانلود کنید. در همین سایت، برای شروع می توانید مستندات jQuery را بخوانید. Rick Strahl در اینجا مطلب آموزشی مناسبی در مورد استفاده از jQuery در ASP.NET نوشته که برای شروع مطلب خوبی است. در کدپلس هم می توانید پروژه های زیادی پیدا کنید که استفاده از jQuery در ASP.NET را آسان تر کرده اند. اگر در سایت های دانلود eBook به دنبال کتاب jQuery for ASP.NET Developers بگردید، کتاب خوبی است برای شروع.

یادگیری 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

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

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

نگهداری تاریخچه تغییرات اطلاعات در یک دیتابیس

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

خوشبختانه این مشکلی نیست که برای اولین بار در جهان ما با آن برخورد کرده باشیم. در سطح اینترنت بحث های زیادی در این مورد وجود دارد و راه حل های مختلفی در مورد آن ارائه شده است. قبل از ما نرم افزارهای مختلفی مثل سورس کنترل ها و وب سایت معروف Wikipedia مکانیزم هایی برای ذخیره تغییرات داده های مهم خود پیاده سازی کرده اند. پس این نیاز، به هیچ وجه نیاز غیر معقولی نیست. کاربر نیاز دارد بداند در یک بازه زمانی خاص، موجودیت مورد نظرش چه مقداری داشته است و ما باید این امکان را برایش پیاده سازی کنیم.

یک روش طراحی دیتابیس به نام Point in Time Architecture وجود دارد که به صورت مخصوص برای حل چنین مشکلی بکار می رود. این روش طراحی تضمین می کند که همیشه تصویری از اطلاعات گذشته را در خود نگهداری کند تا هر گاه نیازی به اطلاعات گذشته بود، در اختیار ما قرار بدهد. در این روش طراحی هیچ گاه رکوردها به صورت فیزیکی آپدیت یا حذف نخواهند شد و فقط flagهایی برای علامت گذاری بر روی رکوردهای تغییر داده شده قرار می گیرد. در این روش، ساختار دیتابیس باید طوری طراحی شود که دیتابیس به ازای هر رکورد بتواند به سئوالات زیر پاسخ دهد :

  • رکورد چه موقع و توسط چه کسی Insert شد؟
  • رکورد چه موقع و توسط چه کسی Update شد؟
  • در یک تاریخ خاص اطلاعات رکورد چگونه بوده است؟

برای پاسخ به این سئوالات باید یکسری فیلد کنترلی داشته باشیم :

  • CreatedDate : تاریخ ساخته شدن رکورد برای اولین بار
  • ModifiedDate : تاریخی که اطلاعات رکورد تغییر داده می شوند
  • UserID : کاربری که اطلاعات را تغییر می دهد

tuple versioningبرای پیاده سازی چنین روشی می توان دو جور عمل کرد. روش اول این است که هر گاه کاربر خواست اطلاعات را تغییر دهد، به جای عمل Update ما یک عمل Insert انجام دهیم و اطلاعات قبلی را با یک فیلد کنترلی آرشیو شده محسوب کنیم. در این روش باید یک فیلد ModifiedDate داشت که هر زمان رکورد ویرایش شد مقداردهی شود. رکوردی که فیلد ModifiedDate آن برابر null باشد، رکورد جاری ما خواهد بود. این روش Tuple Versioning نام دارد که مکانیزمی برای ذخیره حالت فعلی یک رکورد به علاوه حالت های گذشته آن در یک جدول است. این روش برای زمانی که امکان تغییرات در رکوردهای جدول کم باشد بسیار مناسب است. در صورت زیاد بودن امکان تغییرات یک رکورد، باعث حجیم شدن جدول می شود و کارایی را پایین می آورد.

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

History Tableهمانطور که در شکل بالا می بینید، برای نگهداری تاریخچه تغییرات قیمت یک محصول، یک Table جداگانه میسازیم و چند فیلد کنترلی به آن اضافه می کنیم. در اینجا فیلدهای ModifiedDate تاریخ تغییر قیمت محصول، SalesPrice قیمت محصول در زمان تغییر و UserID مشخص کننده کاربری است که قیمت محصول را تغییر داده است.

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

یادگیری 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

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

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

چرا NHibernate انتخاب خوبی به عنوان یک ORM است؟

در مطلب قبل دلایلی برای استفاده از ORM در دات نت فریم ورک برای دسترسی به داده ها و کار با دیتابیس معرفی شد. در این مطلب به معرفی NHibernate و دلایلی برای استفاده از آن به عنوان یک ORM مناسب برای دات نت فریم ورک پرداخته خواهد شد. NHibernate پیاده سازی ORM معروف دنیای جاوا یعنی Hibernate برای پلت فرم دات نت است که به صورت گسترده ای مورد استفاده توسعه دهندگان دات نت در سراسر دنیا قرار گرفته است. NHibernate آزاد و کد باز است و وظیفه اش مانند ORMهای دیگر نگاشت کلاس های شیء گرا به جدوال یک دیتابیس است.

nhibernate logoدر ادامه مطلب با مزیت های NHibernate به عنوان یکی از بهترین ORMهای موجود برای پلت فرم دات نت آشنا می شوید. البته تمام مزیت هایی که در مطلب قبل در مورد یک ORM ذکر شد، در مورد NHibernate نیز صحت دارند که دیگر از ذکر آن ها در این مطلب صرف نظر شده است.

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

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

واقعاً از چند دیتابیس پشتیبانی می کند : شما فقط به SQL Server محدود نخواهید بود و تقریباً می توانید از هر دیتابیسی برای ذخیره داده های برنامه خود استفاده کنید.  NHibernate در حال حاضر از DBMSهای معروف و پر کاربرد مثل Oracle, SQL Server و MySql و چند دیتابیس دیگر پشتیبانی واقعی می کند. این در حالی است که Entity Framework مایکروسافت در حال حاضر به صورت رسمی فقط از SQL Server پشتیبانی می کند.

از زبان HQL پشتیبانی می کند : زبان HQL یک زبان پرس و جوی پیشرفته است که در پروژه Hibernate جاوا به صورت وسیع مورد استفاده قرار می گیرد. با استفاده از این زبان می توانید کوئری های پیچیده را بر روی دیتابیس مورد نظر خود اجرا کنید.

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

انجام تغییرات را آسان می کند : از آنجا که موجودیت های پروژه را خودتان مدل می کنید و بر روی آن ها کنترل دارید، انجام تغییرات بر روی مدل و ایجاد دیتابیس از روی آن با NHibernate بسیار آسان است. انجام تغییرات بر روی مدل برنامه با مهارت های یک برنامه نویس معمولی دات نت قابل انجام است و نیازی نیست برای تغییر در مدل برنامه و در نتیجه تغییر در دیتابیس یک حرفه ای باشید. این را هنگام توسعه اولین برنامه خود با NHibernate شدیداً درک خواهید کرد!

کتابخانه های کمکی مناسبی دارد : پس از یادگیری NHibernate متوجه خواهید شد که می توان بسیاری از کارها را با کتابخانه های کمکی که برای آن نوشته شده، سریع تر و آسان تر انجام داد. به طور مثال می توان از Fluent NHibernate برای انجام اعمال Mapping به جای نگاشت بر اساس فایل های XML استفاده کرد. کتابخانه  Castle ActiveRecord با اضافه کردن لایه ای بر روی NHibernate کاری می کند که شما بدون درگیر شدن با پیچیدگی های NHibernate از آن به راحتی استفاده کنید. کتابخانه ای برای اضافه کردن Validation و کتابخانه ای برای اجرای کوئری های Linq بر روی آبجکت های NHibernate نیز موجود است.

کارایی بالایی دارد : به عنوان یک ORM از کارایی مناسبی برای انجام عملیات های سنگین بر روی دیتابیس برخوردار است. البته این کارایی مناسب در صورتی است که شما NHibernate را به درستی تنظیم و از آن استفاده کنید. ویژگی هایی مثل Second Level Caching، Multi Query و Batch Select که باعث کاهش ایجاد اتصال ها به دیتابیس و در نتیجه افزایش Performance می شوند در NHibernate وجود دارند و شما کافیست تا از آن ها در مواقع مناسب استفاده کنید.

قابلیت تست پذیری بالایی دارد : به علت جدا کردن دامین مدل برنامه از لایه های دیگر برنامه، قابلیت تست پذیری اپلیکیشن هایی که بر اساس NHibernate توسعه می یابند بسیار بالاست. شما می توانید مدل برنامه خود را مورد آزمایش های واحد قرار دهید و از صحت عملکرد آن ها اطمینان حاصل نمایید.

farasun.wordpress.com

اگر دلیل دیگری برای استفاده از NHibernate به عنوان یک ORM مناسب برای دات نت فریم ورک سراغ دارید، در فرم نظرات این مطلب با ما به اشتراک بگذارید.