Single responsibility principle

As explained in .NET MAUI in Action

The single-responsibility principle is a software design principle stating that a component should have one primary reason to change.

The single-responsibility principle (SRP) says that each class or method should have one purpose, with every part aligned to that purpose. In application architecture, separating UI, presentation, and business responsibilities reduces coupling and makes changes easier to isolate. section 9.4 section 9.3

Apply SRP in an MVVM architecture by assigning each concern to its proper component:

• Keep layout and UI behavior, such as markup, animation, and formatting, in the View. section 9.3 section 9.3.5
• Keep UI state and presentational logic, such as bound properties and responses to user actions, in the ViewModel. section 9.3 section 9.3.5
• Keep domain objects, processing rules, and database or API operations in the Model and its services. section 9.3 section 9.3.5

MauiStockTake without MVVM

A UI that gathers control values, constructs service requests, manages application state, and executes business logic violates SRP. The result is tight coupling, difficult maintenance, and business logic that is almost impossible to test except manually. Moving state and commands into a ViewModel and business operations into the Model separates those responsibilities. section 9.4

Figure 9.7 In the MVVM pattern, the View only contains UI logic. Controls are bound to properties on a ViewModel, and rather than event handlers, commands are used to trigger actions. The ViewModel maintains the state of the View by exposing properties for the UI to bind to and commands for the UI to call. The Model contains all the business logic, and the ViewModel interacts with the Model. In this example, a CarService from the Model is injected into the ViewModel. A Button in the View is used to trigger a command in the ViewModel. The ViewModel contains a Car object, which has properties bound in the UI. The Add Car Command calls the AddCar method in the injected service and passes in the ViewModel’s Car property as a parameter.

Trace how a car application divides responsibilities: the View binds controls, the ViewModel exposes state and commands, and an injected CarService performs business operations. section 9.3.5

How .NET MAUI in Action covers it

How deep it goes

Defines one-purpose classes and methods, then works through responsibility boundaries and their maintenance and testing effects.

Examples

Uses MauiStockTake, a car database application, injected services, bound properties, commands, and UI-versus-business-logic comparisons.

What you can do after

Apply it via MVVM to separate UI state and behavior from business operations, improving maintainability and testability.

How it connects

Connects SRP with SOLID, MVVM, View, ViewModel, Model, UI logic, presentation logic, and business logic.

liveBookmanning.com

Read .NET MAUI in Action on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Software Design for Python ProgrammersThe Single Responsibility Principle states that a class should have one primary responsibility and remain cohesive around it.
• 

  liveBookmanning.com
  The Art of CodeThe Single Responsibility Principle is an object-oriented design principle stating that a class should have only one reason to change.
• 

  liveBookmanning.com
  Object-Oriented Software Design in C++A design principle stating that a class should have one major responsibility.
• 

  liveBookmanning.com
  Unit Testing Principles, Practices, and PatternsThe Single Responsibility Principle states that a class or module should have one responsibility and one reason to change.
• 

  liveBookmanning.com
  ASP.NET Core in Action, 3eThe single-responsibility principle is a design principle stating that a class should have responsibility for one piece of functionality and change only when that functionality changes.
• 

  liveBookmanning.com
  GitHub Actions in Action: Continuous integration and delivery for DevOpsThe single responsibility principle is a software design principle stating that a component should have one primary responsibility and one reason to change.

Compare how 7 books explain single responsibility principle →

Related concepts

• principlekind of · A principle is a general rule, guideline, or value that guides decisions, behavior, or judgments.
• cohesive classimplemented by · A class whose methods and instance variables collectively serve one closely related primary responsibility.
• SOLID principleskind of · The SOLID principles are five object-oriented software-design principles concerning single responsibility, openness to extension, substitutability, interface segregation, and dependency inversion.
• separation of concernsimplements · Separation of concerns is a design principle that organizes a system so distinct responsibilities are handled by separate, independently manageable parts.
• functionconfigures · A function is a callable program unit that performs an operation, may accept inputs, and can produce a result or side effect.
• pipeline componentimplemented by · A pipeline component is a discrete, executable stage in a data or machine-learning workflow that performs an operation and may consume or produce data artifacts.

This explainer was generated by Manning's knowledge graph from the text of .NET MAUI in Action. The section links point to the parts of the book it draws on.