M B A R K's Blog
Clean Code: Code by Actor

Clean Code: Code by Actor

M B A R K's photo
M B A R K
·

4 min read

Table of contents

One approach to achieving clean code is known as "Code by Actor," which focuses on organizing code based on different actors or entities in a system. In this article, we will explore the concept of Code by Actor and see how it can be implemented in C# with examples.

Understanding Code by Actor

Code by Actor is a design principle that aims to structure code based on the different actors or entities involved in a software system. An actor can be a user, a service, a database, or any other component that interacts with the system. By organizing code around these actors, it becomes easier to understand the flow of data and actions within the system.

The main idea behind Code by Actor is to group related functionality and responsibilities together. Each actor has its own set of responsibilities and behaviors, and the code related to that actor is organized in a separate module or class. This separation of concerns makes the code more readable and maintainable.

Implementing Code by Actor in C#

Let's consider a simple example of a blogging platform where we have three main actors: User, Post, and Comment. We will see how we can apply Code by Actor to structure our code in C#.

User Actor

The User actor represents the users of our blogging platform. They can register, log in, create posts, and leave comments on other posts. We can create a User class to encapsulate all the user-related functionality:

public class User
{
    public string Username { get; set; }
    public string Email { get; set; }

    public void Register(string username, string email)
    {
        // Registration logic
    }

    public void Login(string username, string password)
    {
        // Login logic
    }

    public void CreatePost(string title, string content)
    {
        // Post creation logic
    }

    public void LeaveComment(int postId, string comment)
    {
        // Comment creation logic
    }
}

By grouping all the user-related functionality together in the User class, we make it easier for developers to understand and work with the user-related features of the system.

Post Actor

The Post actor represents the blog posts on our platform. Each post has a title, content, and a list of comments. We can create a Post class to encapsulate the post-related functionality:

public class Post
{
    public string Title { get; set; }
    public string Content { get; set; }
    public List<Comment> Comments { get; set; }

    public void Publish()
    {
        // Publish the post logic
    }

    public void AddComment(Comment comment)
    {
        // Add a comment logic
    }
}

The Post class contains methods for publishing a post and adding comments to it. By organizing the post-related functionality in a separate class, we can easily work with posts and their associated actions.

Comment Actor

The Comment actor represents the comments made by users on blog posts. Each comment has a content and is associated with a specific post. We can create a Comment class to encapsulate the comment-related functionality:

public class Comment
{
    public string Content { get; set; }

    public void Edit(string newContent)
    {
        // Edit the comment logic
    }

    public void Delete()
    {
        // Delete the comment logic
    }
}

The Comment class contains methods for editing and deleting a comment. By keeping all the comment-related functionality within this class, we ensure that the code related to comments is well-organized and easy to understand.

Benefits of Code by Actor

Applying Code by Actor in your C# codebase offers several benefits:

  1. Modularity: Code by Actor promotes modular design by separating code into smaller, focused modules based on actors. This makes it easier to understand and modify specific parts of the system without affecting others.

  2. Readability: By organizing code around actors, the intent and behavior of different parts of the system become clearer. Developers can quickly identify which actor is responsible for a particular functionality and navigate the codebase more efficiently.

  3. Maintainability: Code by Actor improves code maintainability by encapsulating related functionality within their respective actors. Changes or updates to a specific actor's behavior can be localized, reducing the risk of unintended side effects.

  4. Collaboration: With Code by Actor, developers can work independently on different actors, leading to better collaboration and parallel development. Each developer can focus on their assigned actors, reducing merge conflicts and coordination issues.

clean codeC#