//prepare the view by explicitly loading the categories
products.FindAll(p => p.Category == null).ForEach(p => p.CategoryReference.Load());

string cmd = “update Company set CompanyLogo = @Pic where RKey = @RKey”;
string connstr = “Data Source=;Initial Catalog=;Integrated Security=False;Persist Security Info=True;User ID=;Password=;Encrypt=False”;
SqlConnection c = new SqlConnection(connstr);
SqlCommand comm = new SqlCommand(cmd, c);
comm.Parameters.Add(new SqlParameter(“@RKey”, SqlDbType.BigInt)).Value = 1;
comm.Parameters.Add(new SqlParameter(“@Pic”, SqlDbType.Image)).Value = m_barrImg;
c.Open();
comm.ExecuteNonQuery();

Entities with full persistence ignorance do not track any changes, but instead rely on a persistence framework such as EF to figure out what changes have been made to each entity. This is typically done via a snapshot mechanism. This can be expensive both in terms of the memory to store all the snapshots and to perform the diff.

Change tracking proxies help with this cost by injecting the ability for an entity to report changes directly back to the state manager, so no snapshot or diff is necessary.

1. All mapped properties must be declared virtual and be public or protected

public class Customer
{
    public virtual string Name { get; set; }
    public virtual CustomerDetail Detail { get; set; }
    public virtual ICollection<Order> Orders { get; set; }
}

2. Collection navigation properties must be of type ICollection<T> and must have a getter and a setter

Enforce Using Proxies

If you want to enforce using proxies throughout your application, one thing you can do is to make a protected parameterless constructor on your POCO object. This will prevent instantiation of your POCO classes in your stack and will require all entity class creation to go through the CreateObject<T> method on the ObjectContext class.

Adventures in Fluent NHibernate

A fluent interface to NHibernate – Part 4 – Configuration

http://rhinestone.googlecode.com/svn/samples/LinqRepositorySample

“In this post I set out to create a sample project that uses the RepositoryBase for implementing the repository pattern using Domain Driven Design. The sample with also demonstrate how Persistence Ignorance can be achieved using the RepositoryBase. In the sample I will show how you can easily switch the persistence layer between Linq to SQL and NHibernate.”

Implementing a persistence ignorant Unit of Work framework

Rhino Commons, Repository<T> and Unit Of Work

https://rhino-tools.svn.sourceforge.net/svnroot/rhino-tools/trunk/SampleApplications/Exesto

“The main abstraction that Rhino Commons provides in terms on data access is the IRepository<T> interface, which is accessible via the static Repository<T> accessor class. The Unit Of Work class and the IRepository<T> works together to simplify data access code in most cases.”

Rich-client NHibernate session management

http://schuager.com/downloads/CRMSample.zip

Friday, October 3, 2008

Implementing a persistence ignorant Unit of Work framework

“This post introduces a variation of MVP design pattern called MVP-VM, which is the windows forms (winforms) equivalent of WPF MVVM. The MVP-VM (Model View Presenter – Model View) pattern is a tailor made solution for winforms applications that require full testing coverage and use data binding as main mechanism for syncing the presentation with the domain model.”

http://aviadezra.blogspot.com/2009/08/mvp-mvvm-winforms-data-binding.html

WPF: If Heineken did MVVM Frameworks Part 1 of n !!! code

http://www.codeproject.com/KB/WPF/Cinch.aspx

how do i do… With the Model-View-ViewModel pattern

“First of all, I have a mostly Windows Forms and ASP.Net background. With these technologies, I typically applied different separated presentation patterns, such as Model View Presenter. So when I tried to build WPF and Silverlight applications, I tried to apply the same techniques. But what I found was, that building WPF and Silverlight applications is significantly different from those other technologies. When I tried to apply the Model View ViewModel pattern, I kept running into questions. How do I do “X” in this pattern.”

http://blogs.msdn.com/erwinvandervalk/archive/2009/08/12/how-do-i-do-with-the-model-view-viewmodel-pattern.aspx

This article discusses:

• Patterns and WPF
• MVP pattern
• Why MVVM is better for WPF
• Building an application with MVVM

source code : http://code.msdn.microsoft.com/mag200902MVVM

Customize Data Display with Data Binding and WPF

• WPF data binding
• Data display and hierarchical data
• Using templates
• Input validation

Understanding Routed Events and Commands In WPF

Retrieving ViewModel Objects from a Model Assembly:

“This article examines a way to easily transform data model objects into ViewModel objects, and safely add them to an observable collection, without introducing awkward assembly dependencies into an application.”

http://www.codeproject.com/KB/WPF/FromRussiaWithLove.aspx

MVVM Foundation is a library of classes that are very useful when building applications based on the Model-View-ViewModel philosophy. The library is small and concentrated on providing only the most indispensable tools needed by most MVVM application developers.

“This is my so long waited demo project showcasing the use of Fluent NHibernate and Linq to NHibernate (and some other interesting bits).”

The Repository Pattern

An implementation for NHibernate

MPBlog Implementation. Part 4

NHibernate Repository and Unit Of Work

MPBlog Implementation. Part 5

Downloads

Fluent NHibernate Auto Persistence Model

NerdDinner with Fluent NHibernate Part 1 – The domain model

NerdDinner with Fluent NHibernate Part 2 – The mapping

Mapping a Twitter like domain with Fluent NHibernate

“use a Top-down approach, starting with the domain model, writing the mapping, and finally creating the database schema using the SchemaExport class in NHibernate.”

Your very first NHibernate application – Part 1

“In this series I start from grounds up and will explain to the readers how easy it has become to write an NHibernate based application since Fluent NHibernate is available. I’ll explain the explicit mapping with the fluent syntax as well as the auto-mapping that Fluent NH offers.”

Your very first NHibernate application – Part 2

“I have discussed the mapping of various forms of relations between different entities. For all mappings I have presented the code needed to verify the mappings.”

Your very first NHibernate application – Part 3

In this part of the series about NHibernate and its sister product Fluent NHibernate, Gabriel Schenker introduces the auto mapping feature of Fluent NHibernate. (Download Sample Code)

Fluent NHibernate has a concept called Auto Mapping, which is a mechanism for automatically mapping all your entities based on a set of conventions.

http://wiki.fluentnhibernate.org/Auto_mapping

http://www.simplyvinay.com/Category/6/Default.aspx

MPBlog Implementation. Part 4

NHibernate Repository and Unit Of Work

http://www.simplyvinay.com/Post/50/MPBlog-Implementation.-Part-4.aspx

The Repository Pattern. An implementation for NHibernate

http://blogs.hibernatingrhinos.com/nhibernate/archive/2008/10/08/the-repository-pattern.aspx