Source : Mindcracker Network (www.c-sharpcorner.

com)

Application Architecture for .NET Applications

 

Introduction

This Article series helps the .NET developers and architects to design the effective
applications on .NET latest technologies. There are so many articles,books on application
architecture but it is still challenging for developers to understand best practices,
principles for the application design.

This post speaks about the fundamentals concepts of Application Architecture and
principles.

What is Application Architecture?

Defining a solution which meets all technical and operational requirements by optimizing
performance,security and manageability.

Why Architecture?

Software must built on a solid considerations and failing to meet the key scenarios and
understand the design problems will lead to long term consequences. The application
needs to address the following concerns .

 How the end user be using your application?

 What about quality attributes security,performance,concurrency,
internationalization and configuration.
 What architecture suits for your application now or after it has been deployed?

Goals of Architecture

Application Architecture builds the bridge between business requirements and technical
requirements. Good architecture reduces the business risks associated with the solution.
Architecture should consider

 Structure of the system not the implementation details

 User case scenarios
 Concerns of stake holders
 functional and quality requirements

Approach to Architecture

You must determine the type of application that you are building and architecture styles
that will be used and cross cutting technologies.

 Identify the type of application

 How the application will be deployed?
  Drill down for architecture styles and technologies
 Considering Quality attributes and cross=cutting concerns.

Application Type

Key part in architecture and design is identifying the type of application.

The application types can be

 Rich Client application designed to run on client PC.

 Rich Internet applications.
 SOA applications designed to support communication between loosely coupled
components.
 Smart client applications.

Deployment Strategy

When you design your application you must plan the infrastructure to deploy your
application. Your application must accommodate any restrictions that exist in the
environment. Identify infrastructure architecture early in the design process.

Architectural Style

Architectural style is set of policies and rules that we used in the component design later
that we use in the application.

Examples of architecture styles:

1. Client-server
2. Layered architecture
3. MVC
4. SOA

Cross cutting concerns

These concerns are key areas in your design that are not related to any layer in your
application. You must consider the following concerns when you are designing your
application.

Authentication : Determine how to authenticate users and pass the identities across
the layers.

Authorization : Ensure proper authorization across the trusted boundary.

Caching : Identify what should be cached and where to cache to improve your
application's performance and responsiveness.

Communication : Choose appropriate protocols to protect sensitive data passing over

the network.

Exception Management : Catch exceptions at the boundaries and show meaning full
messages to the end users.
 Instrumentation and Logging : Instrument all business and system-critical events and
log sufficient details. Do not log sensitive information.

Conclusion

This post explained the fundamentals of application architecture and in the next part of
the series I am going to explain about Architecture and Design guidelines.
Thank you for using Mindcracker Network

Introduction

Software Architecture can be described as structure of system, where system represents the collection of
components that accomplish a set of functions. This post explains the key design principles for software
architecture.

The above picture shows you  the common application architecture and different components in the system
and how they work together.
Design Principles

 Separation of Concerns Break your application into distinct features.

 Prefer composition over inheritance When reusing the functionality use composition over
inheritance because inheritance increases the dependency between parent and child classes.
 Don’t Repeat Yourself(DRY) Define only one component for providing specific functionality and
should not be duplicated in any other component.   

Design Considerations

When designing a application, software architect is to minimize the complexity by separating the design into
different areas. For example UI processing components should not include code that directly access a data
source, instead it should use data access components to retrieve data.

Authentication

Failure to design a good authentication strategy can leave your application vulnerable to spoofing attacks
and session hijacking.

Consider the following guidelines when designing the authentication strategy

 Identify your trust boundaries

 If you have multiple systems with in the application consider using the single sign-on strategy.
 Store the hash of the passwords in the database.
 Enforce the use of strong passwords.

Authorization

Consider the following guidelines when you are designing the authentication strategy

 Protect resources by applying authorization to callers based on their identity.

 Use resource-based authorization for system auditing.

Caching

Caching improves the performance and responsiveness of your application.

 You should use the cache for avoiding network round trips and avoid duplicate processing of data.
 Do not cache the volatile data.
 Do not cache the sensitive data unless you encrypt it.
Communication

It concerns the interaction between components across the layers. When crossing the physical boundaries,
you should use message-based communication.

 Build the service interfaces for communication

 Consider using MSMQ to queue messages for later delivery.

Concurrency and Transactions

When designing for concurrency and transactions for accessing the database it is important to identify the
concurrency data model that you want to use. The model can be optimistic or pessimistic.

 If you have business-critical operations, consider wrapping them in transactions.

 Use connection-based transactions when accessing a single-data source.
 Updates to shared data should be mutually exclusive, which is accomplished by applying locks.
 Avoid holding locks for longer period.

Configuration Management

 Encrypt sensitive information in configuration store.

 Provide separate administrative interface for editing configuration information.
 Categorize the configuration items into logical sections.

Data Access

Designing a Data Access Layer is important for application maintainability. The Data Access Layer should be
responsible for managing connections and executing commands against data source.

 Avoid accessing database directly from other layers and should have the data access layer
interaction for DB operations.
 Release the DB connections as early as possible.

Exception Management

Good Design of exception-management strategy is important for the reliability of your application.

 Do not catch the internal exceptions unless you can handle them.
 Design a appropriate exception propagation strategy.
 Design a strategy for unhandled exceptions.
  Design a appropriate logging and notification strategy.

Layering

Designing the layers allows you to separate the functionality into different areas of concern.

 Layers should represent the logical grouping of components.

 Components with in a layer should be cohesive means business layer components should provide
options only related to application business logic.  

Technorati Tags: Software Architecture

Share this post :