• Choose a category
• All
• Classic-Fiction

Base Class and Interfaces

Control vs. WebControl

Related Interfaces

Choosing a Rendering Style

The Render Method

Building the Control Tree

The SimpleGaugeBar Control

Defining the Object Model

Implementing the Object Model

Setting Up the Ruler

Setting Up the Control’s Site

Rendering the SimpleGaugeBar Control

Generating the HTML for a Custom Control

Using Child Controls for Rendering

The Gauge in Action

Building a Data-Bound Control

Key Features

Adding Data-Bound Properties

Adding a Data Item Property

Overriding the PerformDataBinding Method

The GaugeBar Control

Mapping Data Source Fields to Control Properties

The GaugeBar’s Data Item Object

Data Item and View State

Ad Hoc View-State Management

Getting Bound Data

Building a Composite Templated Control

Generalities of Composite Data-Bound Controls

Creating a Hierarchy of Child Controls

The Overloaded CreateChildControls

The Control Item

The BarChart Control

The BarChart Item Object

Adding Bound Data

Events of the BarChart Control

Using the BarChart Control

Adding Template Support

Templates and User Controls

Defining a Template Property

Defining a Template Container

Setting a Template Property

Rendering a Template

Summary

III. Design of the Application

13. Principles of Software Design

The Big Ball of Mud

Reasons for the Mud

Limited Skills

Requirements Churn

Members Turnover

Alarming Symptoms

Make a Change Here, Break the Code There

Easier to Use Than to Reuse

Easier to Work Around Than to Fix

Universal Software Principles

Cohesion and Coupling

Cohesion at a Glance

Coupling at a Glance

Separation of Concerns

Identifying the Concerns

Modularity

Information Hiding

SOLID Principles

The Single Responsibility Principle

SRP Canonical Example

SRP Real-World Considerations

The Open/Closed Principle

OCP Canonical Example

OCP Real-World Considerations

Liskov’s Substitution Principle

Substitution Principle Canonical Example

Substitution Principle Real-World Considerations

The Interface Segregation Principle

Interface Segregation Canonical Example

Interface Segregation Real-World Considerations

The Dependency Inversion Principle

Dependency Inversion Canonical Example

Dependency Inversion Real-World Considerations

Tools for Dependency Injection

Managed Extensibility Framework at a Glance

MEF vs. IoC

Should You Choose MEF or an IoC?

MEF in Action

Unity at a Glance

Registering Types and Instances

Resolving Dependencies

Declarative Configuration

Lifetime Managers

Summary

14. Layers of an Application

A Multitiered Architecture

The Overall Design

Methodologies

The Business Layer

Design Patterns for the BLL

The Transaction Script Pattern

The Table Module Pattern

The Active Record Pattern

The Domain Model Pattern

The Application Logic

The Service Layer Pattern

When the Application Logic Is Deployed Remotely

Exposing Entities to the Presentation Layer

Data Transfer Objects

The Data Access Layer

Implementation of a DAL

DAL and the Table Module Pattern

DAL and the Active Record Pattern

DAL and the Domain Model Pattern

Interfacing the DAL

Support for Multiple Databases

The Repository Pattern

Using an Object/Relational Mapper

LINQ-to-SQL

Entity Framework

NHibernate

O/RM Tools and SQL Code

Beyond Classic Databases

Going to the Cloud

Microsoft Dynamics CRM 2011

Schema-less Storage

Summary

15. The Model-View-Presenter Pattern

Patterns for the Presentation Layer

The MVC Pattern

Generalities of the MVC Pattern

Role of the Model

Role of the View

Role of the Controller

Web