Izobraževanja Tečaji, delavnice in konference

.NET Software Architecture - Patterns of Application Architecture

AVT051

Termini: Trenutno ni določenega termina
18.10.2010 do 20.10.2010

Cena vključuje predavanja, praktične vaje, literaturo, kosilo, osvežilne napitke in ne vključuje DDV.

Opis

In software, architecture is the art of making hard-to-change decisions right. The architecture is the skeleton of a system, the set of pillars that sustain the whole construction. Software architecture has some preconditions—design principles—and one post-condition—an implemented system that produces expected results.

In this class, you’ll learn principles and patterns for building software applications with a particular eye on the idioms for the .NET platform. You’ll get exposure to object-oriented design, including an annotated overview of dependency injection, testability, inheritance and composition in the context of real-world scenarios such as maintenance and design effectiveness. You’ll understand why loosely-coupled components are the most suitable elements in an overall architecture that is easy to extend, test, maintain and, why not, port to the cloud. Next, the class covers specific design patterns and methodologies for presentation, business and data access layer. In particular, you’ll be guided to choose between table-oriented and data-oriented models and trade off tools and patterns for each scenario: domain model, active record model, anemic model, service model, but also specific tools such as Entity Framework, NHibernate, LINQ-to-SQL. A look at patterns for the presentation and user interface completes the definition of the toolset for today’s engineers.

Nothing new has been invented in the past 30 years in software design, but many fundamental concepts, developed since have been overlooked and disregarded. Going back to the roots boosts your productivity because it will refresh your skills and make clear what to change in your programming style and existing code. In the end, your ROI is immediate and tastes like code easier to maintain, read, adapt, test, and less fragile.

Program

From requisites to design
- Use-cases
- Methodologies
- Universal principles of OOD
SOLID principles and their (systematic) application
- Single responsibility
- Dependency injection
- Liskov principle
- Inheritance and composition
Value of design patterns and some XP coding practices
- Refactoring to patterns
- XP gems: DRY, OAOO, YAGNI, and more
Testability, design by contract in C# and unit testing
- Code Contracts in C#
- Mocking
Canonical architectures
- Service architecture
- Layered architecture
- Cloud architecture
Patterns for organizing the business logic
- Table Module
- Active Record
- Domain Model
- Service Layer
Designing a domain model
- Expectations and goals
- Aspects of DDD
Designing a service layer
- Loose coupling between presentation and business layer
- SOA principles
- Importance of DTO
- DTO vs. Entities
SQL, Role of the DAL and O/RM tools
- Object/relational mismatch
- Persisting domain models
- The DAL is often an O/RM
Model-first design with Entity Framework
- Entity Framework 4 in action
- Repository pattern
- Testing the business layer
Patterns for the presentation: MVP and MVVM
- Model View Presenter
- MVVM for WPF and Silverlight
.NET idioms for presentation: ASP.NET MVC
- MVC for the Web
- Impact on Web development
- Approaches for adding AJAX