Expert C# Business Objects - Review

Expert C# 2005 Business Objects Book Review

Dave Hayden — Sat, 09 Sep 2006 11:53:00 GMT

Expert C# 2005 Business Objects Book Review

by David Hayden ( Sarasota Florida ASP.NET Developer )

A few weeks ago I received an email from a reader asking if I planned to write a chapter-by-chapter book review of Expert C# 2005 Business Objects Book Review like I did for its predecessor, Expert C# Business Objects:

Although the author suggests Expert C# 2005 Business Objects ( Apress ) was essentially a complete rewrite to take advantage of the new features in the .NET 2.0 Framework, I didn't notice a lot of changes from Expert C# Business Objects. It felt like the same book to me, but to be fair, I didn't re-read Expert C# Business Objects again to refresh my memory. Due to my perception that little has changed, I felt the links above to chapter summaries still hold true today.

Summary of Expert C# 2005 Business Objects

The purpose of the book is essentially to showcase the CSLA .NET Framework, and lead the reader on a journey through its creation as well as the concepts and principles that shape it. One is essentially learning key technologies and concepts of object-relational mapping and creating domain ( business ) objects to support a distributed, scalable, and secure architecture.

During the journey, the author introduces you to the entire spectrum of technologies necessary for databinding, implementing business rules, tracking the life-cycle of business objects, object-relational mapping, and collaborating with other business objects. The author gets into the fundamentals of class design and discusses various interfaces ( IEditableObject, INotifyPropertyChanged, IBindingList, IDataErrorInfo, etc. ) and features in the .NET Framework ( serialization, reflection, delegates, etc. ) that can be implemented to support certain functionality.

The author discusses various object-oriented principles that govern the reason for assigning behavior to certain classes and why the domain objects collaborate in certain ways. He briefly mentions competing ideas and principles and the various pros and cons for choosing one over the other.

Most books only discuss the technology in a vacuum, leaving you to try to understand how to actually implement the technologies and concepts, but Expert C# 2005 Business Objects let's you have your cake and eat it, too. You get 1) a great introduction to class design, object-oriented principles, functionality in the .NET Framework, object-relational mapping, etc. and 2) pragmatic implementation of those concepts and technolgies to create a reusable framework for your business applications.

Even if like me you choose not to use CSLA .NET, the book is extremely valuable. The concepts and technologies in the book can be used in your own applications and frameworks to implement databinding, business rules, lifecycle tracking of business objects, etc. You can also use the ideas as a stepping stone to create your own implementations.

Recommendations

If you have the first book, Expert C# Business Objects, I honestly don't think you need to read Expert C# 2005 Business Objects. I didn't notice a lot of major changes in concepts and learnings from the previous book.

If you don't have Expert C# Business Objects and you are interested in business objects and object-relational mapping, the book is a must read in my opinion. It gives you a solid introduction to business object concepts and pragmatic implementation of those concepts into the CSLA .NET Framework.

Source: David Hayden ( Sarasota Florida ASP.NET Developer )

Filed: Expert C# Business Objects - Review, .NET Books, O/R Mappers

Additional Resources: OOP and Design Patterns Resources - Books Websites Articles

Expert C# Business Objects by Rockford Lhotka Book Review - Conclusion

Dave Hayden — Sun, 07 Nov 2004 13:27:00 GMT

Expert C# Business Objects by Rockford Lhotka Review - Conclusion

----

I will be providing a chapter by chapter review of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Read Expert C# Business Objects Chapter 1.
Read Expert C# Business Objects Chapter 2.
Read Expert C# Business Objects Chapter 3.
Read Expert C# Business Objects Chapter 4.
Read Expert C# Business Objects Chapter 5.
Read Expert C# Business Objects Chapter 6.
Read Expert C# Business Objects Chapter 7.

This concludes my review of Expert C# Business Objects. Although there are additional chapters describing how to use the CSLA.NET framework via Windows Forms, Web Forms, and Web Services, they are implementational chapters and better read firsthand.

----

Expert C# Business Objects is highly recommended to anyone wanting an excellent tutorial on the how's and why's of building business objects for your applications. Regardless of whether you want to use CSLA.NET or not, the book is packed full of good information on key .NET technologies / practices and how to apply them to your design model.

The book doesn't assume much knowledge on .NET and business objects, so it is an excellent guide for beginners. However, I think intermediate and advanced developers will appreciate it as well. The chapters are constructed in a logical order that allows you to easily progress from chapter to chapter in a comfortable manner. The book has a good mix of technical and “learning” information spread within each chapter that makes it enjoyable to read.

For more information on CSLA.NET, I recommend visiting Rockford Lhotka website at http://www.lhotka.net/ArticleIndex.aspx?area=CSLA%20.NET

From there you will find a whole list of links to help you further your knowledge.

Expert C# Business Objects by Rockford Lhotka - Chapter 7 - Business Object Implementation - CSLA.NET

Dave Hayden — Sat, 30 Oct 2004 11:53:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 7 - Business Object Implementation

----

I will be providing a chapter by chapter review of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Chapter 7 builds templates to help the developer organize and create c# business objects that implement the CSLA.NET framework as well as actual c# business objects used to implement the sample project tracking application discussed in Chapter 6.

----

This is another chapter, like Chapter 3 - Key Technologies, that alone is worth the purchase price of the book. This chapter is where the rubber meets the road and the developer puts together all the .NET technologies and business base classes discussed in previous chapters and builds a solid framework for their project.

The chapter begins by providing an overview of the lifecycle of business objects. Sequence diagrams are used to help visualize the life cycle where the perspective is given from the UI viewpoint where objects are essentially managed. CSLA.NET uses “Class-In-Charge” for object creation, fetching, and immediate deletion which are exposed as static methods on the class.

Templates are created for various different types of business objects: editable root object, editable child collection, read-only NameValueLists, etc. that essentially can be used as a starting point for your own business objects. The following (see below) shows the common regions of a CSLA.NET business object. I tosssed in some sample comments and data, but the chapter provides some really good detail on how these sections are implemented for various c# business objects. As a bonus, the reader also gets some good information about overriding basic object methods in your business components, whether you use CSLA.NET or not.

[Serializable()]
public class MyBusinessClass : CSLA.baseclass
{
    #region Business Properties and Methods

    #endregion

    #region System.Object overrides

    // overrides for ToString and various Equals

    #endregion

    #region Static Methods

        public static MyBusinessClass NewMyBusinessClass() { ... }

        public static MyBusinessClass GetMyBusinessClass() { ... }

        public static void DeleteMyBusinessClass() { ... }

    #endregion

    #region Constructors

        private MyBusinessClass()
        {
            // Prevent Direct Creation
        }

    #endregion

    #region Criteria

    // Criteria for identifying existing object - example
    [Serializable()]
    private class Criteria
    {
        public int _id;

        public Criteria(int id)
        {
            _id = id;
        }
    }

    #endregion

    #region Data Access

    // private implementation of data access CRUD methods

    #endregion
}

The last half of the chapter takes the business object templates built in the first half of the chapter and applies them to the project tracking sample application designed in chapter 6. Here you see more useful code for actual data tables and business root objects (aggregates), child collections, and read-only NameValueLists. Real-world discussions of handling database transactions as well as making sure you process deletes in the databases first are also discussed in the end of the chapter. You also get to see the SafeDataReader and SmartDate objects in action to facilitate easier coding for the developer.

Certainly anyone walking away from Chapter 7 should have a pretty good understanding of CSLA.NET, business objects, and managing the business object lifecycle in general. Personally, the book could end here and I would be happy with the purchase. However, it doesn't (bonus!). Now for the conclusion.

Expert C# Business Objects by Rockford Lhotka - Chapter 6 - Object-Oriented Application Design

Dave Hayden — Sun, 24 Oct 2004 18:38:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 6 - Object-Oriented Application Design

----

I will be providing a chapter by chapter summary of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Chapter 6 walks the reader through the design of a sample project tracking application. It describes building use cases, identifying entities and value objects, and creating database tables and stored procedures.

----

Chapter 6 focuses on the following key concepts:

Creation of a business object
Implementation of business rules
Transactional and nontransactional data access
Parent-child relationships between objects
Many-to-many relationships between objects
Use of name-value lists
Use of CSLA.NET security

This chapter is not very technical aside from showing the basic of database table design and stored procedures.

Use Cases

Rocky provides a decent overview of creating use cases for the sample project-

Project Maintenance

Add a Project
Edit a Project
Remove a Project

Resource Maintenance

Add a Resource
Edit a Resource
Remove a Resource

Assigning a Resource

Object Design

Rocky then uses a form of decomposition for the object design, which identifies the “nouns“ in the use cases and narrows down which of the “nouns“ are business entities and value objects.

He also identifies the security roles in the application based on the users in the use cases.

The chapter discusses overly complex relationships, in particular, circular containment issues. Here is a quote from the chapter that I thought was worth mentioning:

“In a situation like this [circular containment issues], we should always be look for relationships that should be using, instead of containing. What we'll often find is that we're missing a class in our diagram - one that doesn't necessarily flow directly from the use cases, but is required to make the object model workable.“

“The specific problem we're trying to deal with is that when we load an object from the database, it will typically also load any child objects in contains [no lazy loading here] - containment relationships will be followed in order to do the data loading. If we have an endless loop of containment relationships, that poses a rather obvious problem! We need some way to short-circuit the process, and the best way to do this is to introduce a using relationship into the mix. Typically, we won't follow a using relationship as we load objects.“

The chapter then takes a moment to briefly reflect on performance and then shows UML diagrams to describe the overall design.

Database Design

The end of the chapter steps the reader through creating the database tables and stored procedures as well as establishing database security.

The next chapter, Expert C# Business Objects Chapter 7, Business Object Implementation, takes you through creating the actual business objects.

Expert C# Business Objects by Rockford Lhotka - Chapter 5 - Data Access and Security

Dave Hayden — Mon, 04 Oct 2004 06:33:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 5 - Data Access and Security

----

I will be providing a chapter by chapter summary of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Read Expert C# Business Objects Chapter 1.
Read Expert C# Business Objects Chapter 2.
Read Expert C# Business Objects Chapter 3.
Read Expert C# Business Objects Chapter 4.

Chapter 5 discusses object persistence of business objects and the creation of tables and stored procedures. This chapter is fairly technical, so the information here will be spotty at best.

----

Chapter 5 creates the following components in CSLA.NET:

CSLA.Server.DataPortal.dll
CSLA.Server.ServicedDataPortal.dll

which are responsible for persisting business objects in your business framework.

All business objects in you application will derive from one of four base classes:

BusinessBase
BusinessCollectionBase
ReadOnlyBase
ReadOnlyCollectionBase

For these objects to support persistence, 5 virtual methods are added to each of these classes that must be overriden in your business classes:

DataPortal_Create()
DataPortal_Fetch()
DataPortal_Update()
DataPortal_Delete()
Save()

For example:

virtual protected void DataPortal_Create(object criteria)
{
throw new NotSupportedException("Invalid operation - create no allowed");
}

These methods are not called directly by the object itself, but by the DataPortal Server object using reflection.

For example, let's consider the following business object.

[Serializable()]
public class Employee : BusinessBase
{
...

    [Serializable()]
    public class Critieria
    {
        public string SSN;

        public Criteria(string SSN)
        {
            this.SSN = SSN;
        }
    }

...

    override protected void DataPortal_Create(object criteria)
    {
        // Custom code needed to create object...
        // Custom SQL Code...
    }
}

During object creation an instance of the object's criteria class is passed to the DataPortal Server's create method:

static public object DataPortalServer.Create(object criteria, object principal)
{
... GetMethod(criteria.GetType().DeclaringType, "DataPortal_Create") ...
}

Using the criteria object, the portal can get the business object's "DataPortal_Create" method using reflection by using the DeclaringType property. This method can then be invoked by the DataPortal to create the object. The other methods work in a similar fashion.

The rest of the chapter talks about database security and building utility classes, like SafeDataReader that automatically handles null values so you don't have to always write code like-

If (dr.IsDBNull(0))
{
// Handle null value appropriately
}
else
{
// Handle regular value appropriately
}

SafeDataReader automatically handles null appropriately.

There is some pretty cool stuff in this chapter. And, even if you don't want to use CSLA.NET in your projects, there are some good utility classes and best practices in CSLA.NET that can be of use in any project.

The next chapter, Expert C# Business Objects Chapter 6 - Object-Oriented Application Design, takes you through creating a project to use CSLA.NET.

Expert C# Business Objects by Rockford Lhotka - Chapter 4 - Business Framework Implementation

Dave Hayden — Sun, 19 Sep 2004 07:40:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 4 - Business Framework Implementation

----

I will be providing a chapter by chapter summary of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Read Expert C# Business Objects Chapter 1.
Read Expert C# Business Objects Chapter 2.
Read Expert C# Business Objects Chapter 3.

Chapter 4 walks the reader through the creation of many of the business classes in CSLA.NET.

----

Chapter 4 uses the business concepts and key technologies discussed in chapters 1 - 3 to build many of the business classes in CSLA.NET:

Core.BindableBase
Core.BindableCollectionBase
NotUndoableAttribute
Core.UndoableBase
BusinessBase
BrokenRules
RulesCollection
Rule
BusinessCollectionBase
ReadOnlyBase
ReadOnlyCollectionBase
SmartDate

This is one of those chapters that one really needs to read a couple of times and study to get real value. It is not too advanced, but just a lot of technology and concepts thrown at the reader in one chapter. The chapter talks a lot about the real world issues of databinding, tracking business rules, and managing object statutes (IsNew, IsDirty, IsDeleted) as well as the author's desire to support n-level undo. Throughout the chapter you actually build the classes mentioned above in Visual Studio.

The beginning of the chapter focuses mainly on the n-level undo functionality, which is a good education in the power of Reflection and Binary Serialization. The Core.UndoableBase class essentially has 3 methods: CopyState(), UndoChanges(), and AcceptChanges(). CopyState() reads all private and public instance variables of an object, serializes them in binary fashion, and then pushes the snapshot on a stack. UndoChanges() pops the snapshot off the stack and does just the opposite of CopyState(). AcceptChanges() just pops the stack.

Rockford then begins to focus on implementing the proper interfaces to support windows databinding, in particular, IEditableObject, which needs BeginEdit(), CancelEdit(), and ApplyEdit() methods. He also discusses Object Status Tracking, which is essentially making sure objects are properly marked as New, Dirty, or Deleted so that the Save() method on an object knows whether to do an Insert, Update, or Delete in SQL on the object.

Next the chapter constructs the Rule and RulesCollection classes. The rules are used by the DataPortal to decide if an object is valid. If the object is valid (no broken rules in the RulesCollection), the object is saved, otherwise it is not. The RulesCollection is also available to the UI developer to display errors. The rules are not enforced, which means the business onbject could be invalid unless the developer throws the proper exceptions. The rules framework only tracks broken rules and doesn't enforce them.

There are some other goodies throughout the chapter dealing with handling dates, strongly-typed collections, and null values. There is also a lot of good OOP concepts being thrown around to assure the developer cannot directly mess with certain areas of the business framework. A lot of good use of Internal and Protected Internal access modifiers as well as virtual methods, operator overloading, events, etc.

Again, the chapter was excellent, but it is not an easy read and requires a bit more studying to get the full educational impact. Before I continue with the next chapter, which starts to focus more on Data Access and Security, I am going to download the CSLA.NET source code ( CSLA .NET CS version 1.4 ) as well as read some other resources. I also want to build a business object on top of the CSLA.NET framework and see it work for myself. More on this in a couple of days.

Now on to Expert C# Business Objects, Chapter 5, Data Access and Security.

Expert C# Business Objects by Rockford Lhotka - Chapter 3 - Key Technologies - Remoting - Serialization - Reflection

Dave Hayden — Thu, 16 Sep 2004 10:14:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 3 - Key Technologies

----

I will be providing a chapter by chapter summary of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Read Expert C# Business Objects Chapter 1.
Read Expert C# Business Objects Chapter 2.

Chapter 3 describes the key technologies used in the creation of the CSLA.NET Framework.

----

This chapter is extremely good from a technical perspective as it describes the following technologies and how they are used in CSLA.NET:

Remoting
Serialization
Enterprise Services (COM+)
Reflection
.NET role-based security
ADO.NET

In my opinion, Rockford sums up the usefulness and practicality of these technologies very well in a single chapter. I must have read the chapter three times, and in my opinion, this chapter alone is well worth the price of the book. Although I cannot do the chapter justice, I wanted to briefly makes some points about Remoting, Serialization, and Reflection, which I found particularly interesting.

Remoting
As I mentioned before, "remoting is all about allowing code running in one process to communicate with code running in a different process - even if that different process is on another machine across the network." - Rockford Lhotka

The book discusses object proxies, formatters (binary and SOAP/XML), and channels (HTTP and TCP) used by the remoting subsystem to allow client-server communications. Binary formatters were chosen in the CSLA.NET framework because they provide a deep copy of objects and the binary blob being sent over the channel is 30% the size of payloads being sent by the SOAP/XML formatter. The HTTP Channel is used as opposed to the TCP channel because it works best through firewalls and is easier to implement as it comes with IIS.

Rockford actually takes you through the building of a sample remoting project step-by-step. Very cool indeed.

Serialization
Serialization is used to convert a complex object type into a single byte stream. Remoting and Web Services use different types of serialization. Remoting uses a type of serialization that finds all the variables within an object and converts their values into a byte stream. To suppress serialization of some variables, you would need to use the [NonSerialized()] Attribute.

Web Services uses the XMLSerializer object, which only grabs public fields and public read-write properties only. Web services will not serialize private fields, read only properties, or write only properties. In short, The XMLSerializer does *not* make a clone of the object.

Rockford provides a useful code snippet, which is used in the CLSA.NET Framework, for manually invoking serialization for cloning objects using the binary formatter. The following method would be placed in an object class-

public object Clone()
{
IO.MemoryStream buffer = new IO.MemoryStream();
Runtime.Serialization.Formatters.Binary.BinaryFormatter formatter = Runtime.Serialization.Formatters.Binary.BinaryFormatter();

    formatter.Serialize(buffer, this);
    buffer.Position = 0;
    return formatter.Deserialize(buffer);
}

Reflection
The CLSA.NET framework uses Reflection quite a bit, which is especially important in the DataPortal. The DataPortal needs to initiate business objects directly even though the business objects have private constructors. This is possible via reflection as long as the class has a parameterless private constructor.

Using reflection, one can get class and object information (fields, properties, methods, etc.) as well as set private and public variables and invoke methods on objects.

You can get type information on a class:

Type typeData = typeof(string);
Type typeData = typeof(Customer);

or on an object:

Type typeData = objCustomer.GetType();

Using the type information, for example, you can then get all private instance variables and their values:

FieldInfo[] fields = typeData.GetFields(BindingFlags.Instance | BindingFlags.NonPublic);

foreach (FieldInfo field in fields)
{
System.Diagnostics.Debug.WriteLine(field.Name + ": " + field.GetValue(cust).ToString();
}

Conclusion
This chapter was really cool. A good practical overview on the power of these key technologies. Expert C# Business Objects by Rockford Lhotka Chapter 4 Business Framework Implementation goes into further detail on how these key technologies are applied in CLSA.NET.

Expert C# Business Objects by Rockford Lhotka - Chapter 2 - Framework Design - CSLA - Component-Based, Scalable, Logical Architecture

Dave Hayden — Tue, 14 Sep 2004 08:07:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 2 - Framework Design

----

I will be providing a chapter by chapter summary of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Read Expert C# Business Objects Chapter 1.

Chapter 2 talks about the high-level functions and capabilities we want out of the business framework, CSLA.NET, that is going to be built throughout the book.

----

In chapter 2, Rockford begins to discuss the functionality built into the framework design:

n-Level undo capability
Tracking broken business rules to determine whether an object is valid
Tracking whether an object's data has changed (is it "dirty"?)
Support for strongly-typed collections of child objects
A simple and abstract model for the UI developer
Full support for databinding in both Windows Forms and Web Forms
Saving objects to a database and getting them back again
Table-driven security
Other miscellaneous features

Rockford decides to use a "Class in Charge" model for the simple and abstract model for UI development, which is where the business class has static methods to handle the creation of the new class as well as save and get instances:

[Serializable()]
public class Customer
{
private Customer() {...}

private Customer(...) {...}

    public static Customer NewCustomer()
    {
        // Create new customer
        // Set default values
        // Return Customer Object
    }
}

Rockford talks a bit about enabling the new business objects for databinding by supporting the IEditableObject interface and handling property change events as well as the business collections supporting the IBindingList Interface.

Throughout the second half of the book the reader is introduced to all the classes in the CSLA.NET Framework. For business object creation, for example, the following classes are available for which to inherit your own business classes:

BusinessBase
BusinessCollectionBase
ReadOnlyBase
ReadOnlyCollectionBase
SafeDataReader
SmartDate
NameValueList

If you want to create an editable business object that supports n-level undo, tracking of business rules, object persistence, etc., you just inherit from BusinessBase:

[Serializable()]
public class Customer : BusinessBase
{
}

The chapter goes on to discuss the different classes as well as the high-level functionality in detail. Here is an example on how the broken rules work:

public int Quantity
{
    get { return _quantity; }
    set
    {
        _quantity = value;
        BrokenRules.Assert("BadQuantity", "Qty must be positive", _quantity < 0);
        BrokenRules.Assert("BadQuantity", "Qty can't exceed 100", _quantity > 100);
        MarkDirty();
    }
}

The chapter ends with discussion on the DataPortal functionality, which is responsible for handling object persistence. I won't go into it in detail, but Rockford focuses on how the DataPortal, and object persistence in general, should work whether the client is running in the same process on the same machine or a different process on a different machine. And, the developer should not have to change any code (only config settings) if the client is moved to a separate tier.

Read Expert C# Business Objects by Rockford Lhotka - Chapter 3 - Key Technologies.

Expert C# Business Objects by Rockford Lhotka - Chapter 1 - Distributed Architecture

Dave Hayden — Sat, 11 Sep 2004 07:01:00 GMT

Expert C# Business Objects by Rockford Lhotka - Chapter 1 - Distributed Architecture

----

I will be providing a chapter by chapter summary of Expert C# Business Objects by Rockford Lhotka (Amazon) as well as any thoughts and commentary when appropriate. Enjoy.

Chapter 1 essentially introduces terms, concepts, and a layered architecture that will be used to build a framework, called CSLA (component-based, scalable, logical architecture).

----

In chapter 1, the author introduces us to the concepts and issues surrounding distributed, object-oriented architecture.

Rockford describes n-tier architecture from both a logical and physical perspective. When most people talk about n-tier applications, they're talking about physical models in which the application is spread across multiple machines and different functions: a client, a web server, an application server, a database server, and so on.

A logical n-tier architecture (personally I call this a layered architecure) is about spreading different types of functionality. The most common logical separation is into a UI tier, a business tier, and a data tier that may exist on a single maching, or on three separate machines - the logical architecture doesn't define those details.

After discussing the impact different logical and physical n-tier architectures have on application complexity, performance, security, scability, etc., Rockford describes the Five Logical Tiers and the Roles They Provide:

Presentation - Renders display and collects user input
UI - Acts as an intermediary between the user and the business logic, taking use input and providing it to the business logic, then returning results to the user.
Business logic - Provides all business rules, validation, manipulation, processing, and security for the application.
Data access - Acts as an intermediary between the business logic and data management. Also encapsulates and contains all knowledge of data-access technologies (such as ADO.NET), databases, and data structures.
Data storage and management - Physically creates, retrieves, updates, and deletes data in a persistent data store.

Typically in an application, one ends up duplicating the business logic in several logical tiers. You can't trust the browser (for a web application), so one re-checks the business rules in the business layer. You can't trust the business layer, so one re-checks the business rules in the data access area. After much discussion on where to put the business logic in a distributed application, it is decided that the business logic tier definitely still remains a separate concept from the other tiers, but it's directly used by and tied into both the UI and the data-access tiers.

Once the ideal logical architecture is known, Rockford begins to briefly discuss Business Objects and OOP as well as the concepts of Anchored Objects and Unanchored objects.

Anchored object - When an anchored object is "passed" from one machine or process to another, only a pointer, or reference, is passed, not the object itself.
Unanchored object - When an unanchored object is "passed" from one machine or process to another, the object is physically copied and passed by value.

Rockford then concludes the chapter by describing how the use of anchored and unanchored objects impact the other tiers, which get us ready for Expert C# Business Objects by Rockford Lhotka - Chapter 2, Framework Design.