IT Samurai School coming soon...

Billy McCafferty — Mon, 04 May 2009 02:32:00 GMT

As if my life wasn't boring enough trying to get S#arp Architecture 1.0 out the door...

S#arp Architecture: a new home, upgrades and a logo!

Billy McCafferty — Fri, 08 Aug 2008 20:19:00 GMT

To facilitate better integration with SVN clients, S#arp Architecture has been moved to Google Code at http://code.google.com/p/sharp-architecture. Additionally, a discussion group has just been setup on Google Groups at http://groups.google.com/group/sharp-architecture to support use of the architecture, discuss the ideas and patterns behind it, offer suggestions for improvement, and exchange ideas for using it in real-world applications.

So why a bonsai tree on the logo? Bonsai trees are small, have years of practice trained into their shape, and have a solid core...all the attributes that I hope S#arp Architecture exhibits. Besides, if they're cool enough for Mr. Miyagi, then the choice is obvious!

By the way, S#arp Architecture 0.7.3 currently supports ASP.NET MVC Preview 4 and NHibernate 2.0 CR 1.

Enjoy!
Billy McCafferty

S#arp Architecture 0.7 now supports NHibernate 2.0 Beta 1

Billy McCafferty — Thu, 10 Jul 2008 06:36:00 GMT

S#arp Architecture 0.7 represents a major upgrade to the infrastructure of S#arp Architecture - but the overall architecture, with respect to application layering, remains the same. This release is far simpler to work with than previous versions while still providing plenty of flexibility. A huge thanks goes out to Frank Laub who has provided terrific feedback and guidance on making S#arp Architecture simpler while using it on real-world web applications. This release's many changes include:

NHibernate 2.0 Beta 1 integration is now included.
Integration with Spring.NET has been dropped. Spring.NET is a fantastic library with world class AOP, IoC support, and many other modules. But for S#arp Architecture, a simpler approach was found for performing dependency injection without the need for external configuration files. If you're still in need of many of Spring.NET's terrific libraries, you'll want to take a look at release 0.6.* which comes preconfigured with Spring.NET.
- The ~/SpringConfig folder no longer exists
- There is no more SpringInteropController
- The Spring XML generator has been dropped from ProjectBase
GenericDAO now uses the native NHibernate session.
HTTP Modules are no longer needed to support the Open-Session-in-View pattern for NHibernate session management.
All configuration, such as the DB connection string, is now just within web.config.
Concrete types needed for Dependency injection are now declared at the top of each dependency interface; e.g., IOrderDao.
NHibernate session storage mechanisms, for both web and unit-tests/winforms have been added to ProjectBase.Data and ProjectBase.Web.
The Identity attribute has been renamed to DomainSignature to better reflect its purpose.
Controllers now simply inherit from the base MVC Controller.
ProjectBase.Web.ControllerFactory has been introduced with built in dependency injection.

I'm confident you'll be very pleased with the changes and would highly recommend upgrading your project if you're already using this framework and do not need the many powerful utilities found within Spring.NET.

http://www.codeplex.com/SharpArchitecture

Billy McCafferty

S#arp Architecture upgraded to ASP.NET MVC Preview 3

Billy McCafferty — Tue, 10 Jun 2008 05:34:00 GMT

S#arp Architecture has been upgraded for compatibility with ASP.NET MVC Preview 3 and Spring.NET 1.1.2.. A big thanks goes out to Adam Cooper and Frank Laub for assisting with this effort. S#arp Architecture, an architectural framework for developing applications with ASP.NET MVC, Spring.NET and NHibernate, may be found at http://www.codeplex.com/SharpArchitecture.

Billy McCafferty

S#arp Architecture: ASP.NET MVC with NHibernate

Billy McCafferty — Mon, 21 Apr 2008 22:44:00 GMT

To skip to the chase... http://code.google.com/p/sharp-architecture/

It wasn't too many years ago that I used to state quietly that I was a Microsoft web developer. Inevitably, a Java developer would hear my whisper and begin laughing hysterically as I cowered away from defending Active Server Pages. Not long after, I felt a bit more confident defending Microsoft web development after the introduction of ASP.NET but have yet to this day been able to accurately describe the page life cycle or defend why the *%$@ it was ever a good idea. While the .NET language continued to progress into a world class language with generics and LINQ, I often wondered when the presentation layer would get the attention it deserved. To add insult to injury, the Rails crew was quick to join in the hysterics that the Java community had long been enjoying. To make up for the deficiencies of developing Microsoft web applications, many of us would come up with near ridiculous schemes to facilitate even a partial amount of test driven development and properly tiered layers. With ASP.NET MVC, we now easily stand shoulder to shoulder with the clean separation of concerns enjoyed by other technologies. But with any new technology, there is a dire and immediate need for communications and guidance concerning how to develop a solid, testable web application using time tested patterns for rapid development and long term maintainability. With this post, I hope to do just for ASP.NET MVC.

Pronounced "Sharp Architecture," this is a solid architectural foundation for rapidly building maintainable web applications leveraging the ASP.NET MVC framework with NHibernate 1.2 and Spring.NET 1.1.1. The primary advantage to be sought in using any architectural framework is to decrease the code one has to write while increasing the quality of the end product. A framework should enable developers to spend little time on infrastructure details while allowing them to focus their attentions on the domain and user experience. Accordingly, S#arp Architecture adheres to the following key principles:

Focused on Domain Driven Design

This architecture places emphasis on the domain as being the core element of focus. Accordingly, the domain layer has no direct dependencies on any data loading mechanisms or other resource dependent services. This facilitates a test driven approach to developing the domain without the need for external resources, such as a database, to be available during domain development. (Alternatively, some developers prefer a model driven approach to application development. A solid framework for supporting this alternative style is the ADO.NET Entity Framework.)

Loosely Coupled

All layers within S#arp Architecture depend only on the core domain layer and framework utilities. In many applications, the presentation tier depends on a service tier which depends on a domain tier which depends on a data access tier. A frequent problem with this is that every layer "up the chain" inherently depends on every tier below it. This tight coupling makes it increasingly more difficult, as development on a project proceeds, to make modifications to lower tiers without having an adverse affect on the tiers above it. Alternatively, this architecture keeps the tiers loosely coupled from each other; e.g., the controller and domain logic layers have no direct dependency on the data tier. To facilitate this, the core domin layer, in addition to defining the domain model and logic, also define service interfaces which are needed by other layers. (Examples of a "service" include a data access object, a ftp utility, or a web service.) In this way, the controller logic only has knowledge of data access interfaces, for which implementation details can be injected at runtime. This loosely coupled design further faciliates test driven development and allows dependencies to be more easily modified, if not completely replaced, with no affect on "higher" tiers.

Preconfigured Infrastructure

Developers often spend much of their time maintaining data access and other infrastructure related layers. Furthermore, infrastructure to facilitate test driven development which bypasses live data access code is often complicated and error prone to configure. By leveraging NHibernate 1.2 for data access, along with the benefits of .NET generics, it is rarely the case, using this described approach, that even a single line of code need be written to have full data access capabilities for a given domain object. Spring.NET 1.1 is then leveraged to provide dependency injection of concreate data access objects into the controllers layer. (Alternatively, the data access objects could be injected into a service layer when appropriate.) To reduce the risk of introducing bugs into XML configuration files, this framework includes a Spring.NET XML configuration generator to handle defining data access objects (DAOs), controllers, and DAO injection into controller constructors. The only time it is necessary to configure Spring.NET XML is when custom DAOs are required. Note that this is the only code generation in the entire framework. There is no bazillion lines of data access code generated upon every compilation. There are no magically created partial classes to facilitate data access. This makes for a much more understandable and maintainable application.

Open Ended Presentation

There are a plethora of great alternatives available for building the presentation layer of an application. Consequently, S#arp Architecture mandates few, if any, constraints on how the presentation layer should be designed and developed. In fact, the only constraint is that ASP.NET MVC be leveraged; other than that, any presentation option is available for use. To illustrate, this framework shows no preferences towards any particular presentation solution such as jQuery, Yahoo UI widgets, or the Microsoft AJAX utilities. As long as your preferred mechanism works with MVC, this framework will accommodate it.

To better facilitate community involvement, to provide releases for later versions of ASP.NET MVC and other framework dependencies, and to manage documentation (with a comprehensive walk through lab), S#arp Architecture is being managed at http://code.google.com/p/sharp-architecture/. The corresponding discussion group may be found at http://groups.google.com/group/sharp-architecture.

I sincerely hope that this architecture will serve as a key element in enabling you to create high quality applications which both you and your clients can take pride in. This work reflects the knowledge of industry experts, the feedback garnered from past experiences, and the help of many people who have lent a hand or provided guidance and/or feedback when needed. Particularly, I'd like to thank Damon Carr, Ben Scheirman, Alan Northam, Mark Pollack and Erich Eichinger of the Spring.NET team, Wayde Gilliam and the hundreds of developers who helped me hone my ideas by providing great feedback over the past couple of years. A special thanks also goes to Roy Bradley who made it possible for me to spend as much time as I did on this effort.

Some useful essential background material for this architecture may be found at http://www.codeproject.com/KB/architecture/NHibernateBestPractices.aspx. Although there are major changes in the infrastructure of the new architecture, the overall structure is similar to that presented in this previous article. So it's a great starting point for getting up to speed with the knowledge areas included.

The overall goal of this architecture is to allow developers to worry less about application "plumbing" and to spend most of their time on adding value for the client by focusing on the business logic and developing a rich user experience. Enjoy and keep the feedback coming!

Billy McCafferty

Billy McCafferty : NHibernate, Architecture

IT Samurai School coming soon...

S#arp Architecture: a new home, upgrades and a logo!

S#arp Architecture 0.7 now supports NHibernate 2.0 Beta 1

S#arp Architecture upgraded to ASP.NET MVC Preview 3

S#arp Architecture: ASP.NET MVC with NHibernate