Component-based Scalable Logical Architecture (CSLA) is an implementation framework created by Rockford Lhotka that provides a standard way to create robust object oriented programs using business object. Business objects are objects that abstract business entities in an object oriented program. These entities could be things such as sales orders, employees, invoices, and so on. CLSA was originally targeted toward Visual Basic 6 in the book Visual Basic 6.0 Business Objects by Lhotka ISBN 186100107X. With the advent of Microsoft .Net, CSLA was revised and called CSLA.NET. This revision took advantage of Web Services and the fully object oriented languages that came with Microsoft .Net (i.e. Visual Basic.net and C#). CSLA.NET was expounded in Expert C# Business Objects ISBN 1590593448 and Expert One-on-One Visual Basic .NET Business Objects ISBN 1590591453, both written by Lhotka. Though CSLA and CSLA.NET were originally targeted toward Microsoft programming languages, most of the framework can be applied to most object oriented languages.

Features of CLSA

Smart data

A business object encapulates all the data and behavior (including persistance logic) associated with the object it represents. For example, an order object will be the only part of the program to load an order, obtain or assign the order's member data (order numbers, etc...), save the order, and so on.

Typed Collections

The framework defines a standard way to create collection objects which represent a collection of objects. This allows an object model to map well to to a relational database's data model. For example, an Accounts table would map to an Accounts collection object. Each row in the Accounts table would map to an Account business object (observe the pluralisation) which is contained in the Accounts collection object. This makes it possible to define methods for the collection object that will propagate to its constituent objects. For example, to save all the Account objects in an Accounts collection, one would type:
myAccountsCollection.Save();
The Save() method will call the Save() method on each of its constituent Account objects.

Business objects can also contain other collection objects, in effect creating a relationship analogous to a parent child relationship between two tables. For example, the Account object mentioned above can contain an Orders collection object which in turn contains Order objects. In this case, the above call to Save() on the Accounts collection object could be written to save all of the Account objects as well as all of the orders associated with each of the accounts.

Object persistence

Data creation, retrieval, updates, and deletes (CRUD) are performed by clearly defined methods of the business object associated with the data.

Persistence state maintenance

CSLA defines a standard way of allowing a business object to maintain information about it's "persistence state". In other word, an object knows when it is new (it represents data that hasn't been saved yet) and when it is dirty, (it needs to be saved to the database either because it is new or because its member data has been changed since it was last loaded). Business objects can also be marked for deletion so they can later be deleted (for example when a user has pressed a button confirming his or her intention to delete the rows.)

N-Level undo

This feature makes it possible for an object or collection of objects to maintain a collection of states. This allows the object to easily revert back to previous states. This can be useful when a user wants to undo previous edit mulitple times in an application. The feature can also allow a user to redo multiple edit that were previosly undone.

Business rule tracking

Allows objects to maintain collections of "broken rule" objects. Broken rules will exist for an object until it is in a valid state, meaning it is ready to be persisted to the database. BrokenRule objects are usually associated with validation logic such as ensuring that no alphabetic characters are entered into a phone number field. For example, if an Account object has a PhoneNumber property, and that property is assigned a phone number with alphabetic characters, the Account object's IsValid property will become false (making it impossible to save to the database) and then a new BrokenRule object will be created and assigned to the Account's Broken Rules collection. The rule will disappear when the invalid phone number is corrected making the Account object capable of saving itself to the database.

Extended features of CLSA.NET

Simple UI creation

Using Windows Forms or Web Forms , data-bound controls like DataGrids and ListBoxes can be bound to business objects instead of more generalized database objects like ADO.NET DataSets and DataTables.

Distributed data access

Using Web Services, an object can perform its data access on the client machine or a server. It can also be configured to use manual database transactions or distributed two-phase_commit transactions.

Web Services support

Business logic created with the CLSA.NET framework can easily be exposed as a web services to remote consumers.

External links

Rockford Lhotka's website