Reflection in C#: A Comprehensive guide with examples and benefits of using it


  <figure"><img src="/assets/blog/posts/imgs/csharp-record-vs-class.png" alt="C# record vs class illustration"
            class="image-center" /></figure>
        <p>Are you a code-savvy developer looking to level up your C# game? Well, buckle up because we're about to dive
            into
            the intriguing world of C# record vs class. These two fundamental concepts in object-oriented programming
            hold
            the key to writing efficient and powerful code in C#.</p>
        <p>But what sets them apart? That's precisely what we'll explore in this article - the crucial distinctions
            between
            C# <a href="https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/records">record</a> vs <a href="https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/types/classes">class</a>. By understanding their differences, you'll be equipped with the knowledge needed to make
            informed decisions.</p>
        <h2>The Difference between C# Record vs Class</h2>
        <p>When comparing C# record vs class, they have distinct characteristics that set them apart. Understanding
            these
            differences is crucial for developers who want to make the right choice when designing their code.</p>
        <h3>Immutability and Mutability of C# records vs classes</h3>
        <p>One fundamental distinction between C# records vs classes lies in their mutability. While records are
            immutable
            by default, meaning their values cannot be changed once assigned, classes are mutable, allowing
            modifications to
            their properties.</p>
        <h3>Equality Semantics for C# records vs classes</h3>
        <p>Another key difference of C# records vs classes relates to equality semantics. Records provide value-based
            equality semantics, which means they compare the values of their properties for equality. On the other hand,
            classes use reference-based equality, comparing whether two objects refer to the same memory location.</p>
        <h3>Inheritance Support for C# records vs classes</h3>
        <p>Inheritance is an essential feature in object-oriented programming, but it varies between C# record vs class.
            While inheritance is not supported for records, it remains possible with classes. This distinction allows
            developers to create class hierarchies and derive new types from existing ones.</p>
        <p>Understanding these differences helps developers choose between C# records vs classes type based on their
            specific requirements. Whether it's immutability versus mutability, value-based or reference-based equality
            semantics, or the need for inheritance support - each characteristic plays a role in determining which
            option is
            most suitable for a given scenario.</p>
        <p>By considering these distinctions between C# records vs classes carefully, developers can leverage the
            strengths
            of both within their projects.</p>
        <h2>When to Use C# Record vs Class</h2>
        <p>There are a few points to consider when to use C# records vs classes. </p>
        <p>Use a record when you need an immutable type with value semantics. Records are ideal for representing data
            structures that are meant to be read-only and have value-based equality semantics. They provide a concise
            syntax
            for defining immutable objects and automatically generate useful methods like <code
                class="language-text">Equals, GetHashCode</code>, and
            <code class="language-text">ToString</code>.
        </p>
        <p>Choose a class when you require mutability or inheritance. Classes allow you to define mutable objects that
            can
            be modified throughout their lifetime. They also support inheritance, allowing you to create hierarchies of
            related types and leverage polymorphism.</p>
        <h2>Advantages of Using C# Records vs Classes</h2>
        <p>There are several advantages to using C# record vs class. Let's explore these benefits:</p>
        <ul>
            <li>The simplified syntax for defining immutable types: With C# records, you can easily define immutable
                types
                using a concise syntax. This simplifies the process of creating objects that cannot be modified once
                instantiated.</li>
            <li>Enhanced support for pattern matching and deconstruction: C# records provide improved support for
                pattern
                matching and deconstruction. This allows you to conveniently extract data from records and perform
                operations based on specific patterns or conditions.</li>
            <li>Improved performance due to structural equality checks: Unlike classes, C# records perform structural
                equality checks by default. This means that two record instances with the same values in their
                properties
                are considered equal. This feature enhances performance by eliminating the need for manual equality
                comparisons.</li>
        </ul>
        <p>Using C# records vs classes can lead to more efficient and maintainable code. By leveraging simplified
            syntax,
            enhanced support for pattern matching and deconstruction, and improved performance through structural
            equality
            checks, developers can benefit from increased productivity and code clarity.</p>
        <p>So, when working on projects that require immutability, pattern matching, or performance optimizations,
            consider
            utilizing C# records vs classes as they provide significant advantages over traditional classes.</p>
        <h2>Understanding the Key Features of C# Records</h2>
        <p>Having compared C# records vs classes, the former offers several key features that make them a powerful tool
            for
            developers. Let's explore these features in more detail:</p>
        <ol>
            <li>Automatic implementation of <code class="language-text">GetHashCode()</code> and <code
                    class="language-text">Equals()</code> methods based on property values:<br>Comparing C#
                records vs classes, with records, you don't have to manually override the <code
                    class="language-text">GetHashCode()</code> and <code class="language-text">Equals()</code>
                methods. They are automatically implemented based on the property values of the record.<br>This
                simplifies
                the process of comparing and hashing records, saving developers time and effort.</li>
            <li>Value-based equality comparisons through the == operator without overriding it explicitly:<br>In C#,
                when
                using records, you can compare instances using the == operator without explicitly overriding it.<br>The
                ==
                operator performs value-based equality comparisons for record instances, making it easier to check if
                two
                records have identical property values.</li>
            <li>Support for positional patterns in pattern-matching expressions:<br>C# records support positional
                patterns
                in pattern-matching expressions.<br>This allows developers to easily match specific patterns within
                record
                instances by their positions, enabling more flexible and concise code.</li>
        </ol>
        <p>These features enhance productivity and simplify code maintenance when working with C# records vs classes. By
            automating common tasks like implementing equality comparisons and providing support for positional
            patterns, C#
            records enable developers to focus on building robust applications efficiently.</p>
        <h2>Comparing the Syntax and Behavior of C# Record vs Class</h2>
        <h3>Syntax</h3>
        <p>Records in C# are defined using the <strong>"record" keyword</strong>, while classes are defined using the
            <strong>"class" keyword</strong>.
            However, classes can also include optional modifiers like "sealed" or "abstract."
        </p>
        <h3>Behavior</h3>
        <p>There is a fundamental difference between C# record vs class. Records have value semantics by default,
            meaning
            they are treated as <a href="https://learn.microsoft.com/en-us/dotnet/standard/collections">data structures</a> rather than reference types. On the other hand, classes have reference
            semantics unless explicitly overridden.</p>
        <p>Here are some key differences to consider, comparing C# records vs classes:</p>
        <ol>
            <li>Records:<br>Are similar to immutable data structures.<br>Encourage public read-only fields for data
                members.<br>Provide structural equality out of the box.<br>Generate value-based equality methods
                automatically.</li>
            <li>Classes:<br>Are more commonly used for complex behaviors and encapsulation.<br>Allow mutable state
                through
                properties and fields.<br>Rely on reference equality by default.<br>Require manual implementation of
                equality methods.</li>
        </ol>
        <p>In terms of code examples, let's take a look at how these differences manifest:</p>
        <pre><code class="language-csharp">
        // Record example
        public record Person(string Name, int Age);

        // Class example
        public class PersonClass
        {
        public string Name { get; set; }
        public int Age { get; set; }
        }
    </code></pre>
        <p>In this simple comparison of C# record vs class representing a person's information, we can see that the
            record
            syntax is more concise and automatically generates useful methods like ToString(), GetHashCode(), and
            Equals()
            based on its members.</p>
        <p>On the other hand, the class requires explicit implementation of these methods if needed. Since records have
            value semantics by default, two instances with identical values will be considered equal even if they occupy
            different memory locations.</p>
        <h2>Utilizing Record Types with Expressions in C#</h2>
        <p>Records can be a powerful tool when working with expressions in C#. By leveraging record types, you can
            simplify
            code generation and enable the creation of dynamic code at runtime. This opens up new possibilities for
            powerful
            code manipulation.</p>
        <p>Here's how you can make the most out of record types and expressions:</p>
        <ol>
            <li><strong>Simplify Code Generation</strong>: With record types, you can define data structures that are
                immutable by default. This means that once a record is created, its values cannot be changed. This
                immutability simplifies code generation as you don't need to worry about managing mutable state.</li>
            <li><strong>Dynamic Code at Runtime</strong>: Expressions allow you to generate and execute code dynamically
                during runtime. By combining expressions with record types, you can create flexible and adaptable code
                that
                responds to different scenarios. This enables you to build more dynamic applications that can adjust
                their
                behavior based on changing conditions.</li>
            <li><strong>Powerful Code Manipulation</strong>: The combination of record types and expressions gives you
                the
                ability to manipulate your code in powerful ways. You can dynamically create new instances of records,
                modify existing records, or even generate entirely new code based on certain conditions or inputs.</li>
        </ol>
        <h2>Best Practices for Using C# Records vs Classes</h2>
        <h3>When to Use C# Records vs Classes</h3>
        <ul>
            <li>Use records when immutability and value-based equality are desired.</li>
            <li>Prefer classes when mutability or inheritance is necessary.</li>
        </ul>
        <h3>Naming Conventions and Access Modifiers</h3>
        <ul>
            <li>Follow naming conventions to maintain code readability.</li>
            <li>Make proper use of access modifiers for encapsulation.</li>
        </ul>
        <p>Using C# records vs classes effectively requires understanding their purpose and applying best practices.</p>
        <p>When immutability and value-based equality are desired, <strong>records</strong> offer a convenient solution.
            They allow you to create objects that are immutable by default, ensuring that once initialized, their values
            cannot be changed. This can be particularly useful when dealing with data transfer objects or representing
            entities where the values should remain constant. Records provide built-in value-based equality checks,
            making
            it easier to compare instances based on their content rather than reference.</p>
        <p>On the other hand, if mutability or inheritance is necessary, <strong>classes</strong> are the way to go.
            Unlike
            records, classes can have mutable properties and methods that allow for changes after initialization.
            Furthermore, they support inheritance, enabling you to create hierarchies of related types.</p>
        <p>To maintain code consistency and readability, it's important to adhere to naming conventions. Choose
            meaningful
            names for your record or class that accurately represent their purpose in the application. Make proper use
            of
            access modifiers such as <code class="language-text">public, private</code>, or <code
                class="language-text">protected</code> to control visibility and encapsulation.</p>
        <p>By following these best practices when working with C# records vs classes:</p>
        <ol>
            <li>Utilize records for immutability and value-based equality requirements.</li>
            <li>Opt for classes when mutability or inheritance is needed.</li>
            <li>Apply appropriate naming conventions for clarity.</li>
            <li>Implement access modifiers effectively.</li>
        </ol>
        <h2>Case Studies: Real-World Applications of C# Record vs Class</h2>
        <p>Having compared C# records vs classes, both offer powerful tools for developers to model their domain and
            create
            complex object hierarchies. Let's explore some case studies that highlight the practical usage of records
            and
            classes in real-world applications.</p>
        <h3>Example scenarios showcasing the practical usage of records in domain modeling:</h3>
        <ul>
            <li>When designing a system for managing employee data, using records allows us to define lightweight,
                immutable
                data structures that represent employees' information. This ensures type safety and simplifies the
                codebase.
            </li>
            <li>In a financial application, records can be used to model transactions, where each transaction is
                represented
                by a record instance containing relevant data members such as amount, date, and recipient.</li>
        </ul>
        <h3>Real-world applications demonstrating the benefits of using classes for complex object hierarchies:</h3>
        <ul>
            <li>When building a game engine and comparing C# records vs classes, the latter is invaluable for creating
                complex object hierarchies. For example, we can use classes to define different types of game entities
                like
                characters, enemies, or items with varying behaviors and attributes.</li>
            <li>In large-scale enterprise systems, classes provide flexibility in representing business entities with
                intricate relationships. Class inheritance enables us to create specialized subclasses while reusing
                common
                functionality from base classes.</li>
        </ul>
        <h3>Explore case studies that highlight the appropriate use cases for both C# records vs classes:</h3>
        <ol>
            <li><strong>Domain Modeling of C# records vs classes</strong>:<br>Records excel at representing simple data
                structures with immutability.<br>Classes shine when dealing with complex hierarchical relationships
                between
                objects.</li>
            <li><strong>Data Structures of C# records vs classes</strong>:<br>Records are suitable for lightweight data
                containers without behavior.<br>Classes allow us to encapsulate behavior along with data in more
                elaborate
                structures.</li>
        </ol>
        <p>By understanding these examples and considering the specific needs of your project, you can make informed
            decisions about the advantages of C# records vs classes.
        <h2>C# Records vs classes: Making the Right Choice for Your Project</h2>
        <p>In conclusion, understanding the differences between C# records vs classes is crucial for making the right
            choice
            in your project. C# records provide several advantages over classes, such as immutability by default,
            enhanced
            syntax for equality comparison, and built-in support for value-based equality semantics.</p>
        <p>When deciding whether to use C# records vs classes, consider the specific requirements of your project.
            Records
            are well-suited for scenarios where you need immutable data structures with value-based equality. Classes
            offer
            more flexibility and are suitable for situations that require mutable objects with behavior.</p>
        <p>By utilizing C# records vs classes, you can take advantage of their key features like expression-bodied
            members
            and deconstructors. These features allow for concise code and improved readability.</p>
        <p>It's important to consider performance considerations when choosing between C# records vs classes. While
            records
            may have some overhead due to their immutability characteristics, they can provide performance benefits in
            certain scenarios.</p>
        <p>To make the most out of using C# records vs classes, follow best practices such as properly defining equality
            members, avoiding unnecessary inheritance hierarchies, and keeping your codebase clean and maintainable.</p>
        <p>Real-world case studies demonstrate how distinguishing advantages of C# records vs classes have been
            successfully
            applied in various projects. By exploring these examples, you can gain insights into how others have
            leveraged
            these language features to solve specific problems.</p>
        <p>In summary, understanding the strengths and weaknesses of C# records vs classes will empower you to make
            informed
            decisions about which approach is best suited for your project's needs. Embrace the power of C# records vs
            classes to write cleaner code with improved expressiveness while maintaining high-performance standards.</p>
  

C# Record vs Class: Key Differences and Best Use Cases

MediatR

DDD Aggregates - Best Practices and Implementation Strategies

<figure><img src="/assets/blog/posts/imgs/object-dependencies.png" alt="Mediator design pattern" class="image-center"/></figure>



<h2 class="wp-block-heading">Introduction</h2>



<p>In software development, effective communication is crucial for ensuring that components work harmoniously together. When components are tightly coupled and communicate directly, changes to one component can have a ripple effect on other components, making the system complex and difficult to maintain. The <a href="https://en.wikipedia.org/wiki/Mediator_pattern" target="_blank" rel="noreferrer noopener">Mediator design pattern</a> addresses this challenge by providing a centralized communication channel that encapsulates the interaction logic.</p>



<p>By adopting the Mediator design pattern, software developers can achieve loose coupling, where components have limited knowledge of each other, and interactions are mediated through a common interface. This loose coupling promotes modularity, as components can be developed and modified independently without affecting the entire system. It also simplifies communication logic, as the mediator handles the complexities of coordinating interactions between components.</p>



<p>The Mediator pattern is especially valuable in scenarios where multiple components need to communicate with each other in a controlled manner. It provides a clear separation of concerns, making the codebase more readable and maintainable. Additionally, the Mediator pattern enhances testability, as components can be easily tested in isolation by substituting the mediator with mock objects.</p>



<h2 class="wp-block-heading">Understanding the Mediator Pattern</h2>



<p>The Mediator design pattern is grounded in a set of core principles and concepts that make it an effective tool for managing communication between components. At its heart, the Mediator pattern promotes the principle of loose coupling by abstracting the communication logic into a mediator object. This object acts as a central hub, allowing components to interact without direct knowledge of each other. By encapsulating the interaction logic, the Mediator pattern simplifies the communication process and reduces dependencies, leading to a more modular and maintainable codebase.</p>



<p>The Mediator pattern facilitates communication between components by providing a centralized point of control. Instead of components directly communicating with one another, they send messages or notifications to the mediator, which then orchestrates the interaction and relays relevant information between the components. This decoupling ensures that components remain independent, promoting encapsulation and enabling better separation of concerns. The mediator acts as a facilitator, coordinating complex interactions and promoting a more organized and structured system architecture.</p>



<p>The advantages of using the Mediator design pattern in software development are manifold. Firstly, it promotes loose coupling and reduces dependencies between components, leading to a more flexible and modular system. With decreased coupling, individual components can be modified or replaced without affecting other parts of the system, resulting in improved maintainability. Secondly, the Mediator pattern simplifies the communication logic by centralizing it within a mediator object. This simplification enhances the readability and comprehensibility of the code, making it easier to understand and maintain. Additionally, the Mediator pattern enhances testability, as components can be isolated for unit testing by substituting the mediator with mock objects. This promotes effective testing practices and helps ensure the reliability and correctness of the software. Overall, the Mediator pattern empowers developers to create more scalable, extensible, and maintainable software systems.</p>



<h2 class="wp-block-heading">Benefits of the Mediator Pattern</h2>



<p>The Mediator pattern offers a range of benefits that contribute to the robustness and maintainability of software systems.</p>



<h3 class="wp-block-heading">Decoupled Communication</h3>



<p>By leveraging the Mediator design pattern, components are decoupled through a mediator object. This decoupling eliminates direct dependencies between components, allowing them to interact solely through the mediator. This separation enhances code maintainability and extensibility, as modifications to one component have minimal impact on others. The mediator acts as a central point of coordination, ensuring loose coupling and promoting a more modular system architecture.</p>



<h3 class="wp-block-heading">Simplified Communication Logic</h3>



<p>Centralizing communication within a mediator object simplifies the overall communication logic. Components no longer need to be aware of the intricate details of other components' interfaces and interactions. Instead, they communicate with the mediator, which handles the complexities of routing and coordinating messages between components. This simplification reduces code complexity, making it more readable and understandable. It also promotes a clearer separation of concerns, facilitating easier debugging and maintenance.</p>



<h3 class="wp-block-heading">Flexibility and Extensibility</h3>



<p>The Mediator pattern provides flexibility and extensibility to software systems. Adding new components to the system is straightforward, as they only need to communicate with the mediator, rather than establishing direct connections with existing components. This flexibility allows for the introduction of new features or the modification of existing ones without requiring extensive modifications to the existing codebase. The Mediator pattern accommodates evolving requirements and enables the system to scale smoothly as new components are integrated.</p>



<h3 class="wp-block-heading">Testability</h3>



<p>The Mediator design pattern significantly improves testability by isolating components for effective unit testing. Since components communicate through the mediator, they can be easily tested in isolation by substituting the mediator with mock objects. This isolation enables focused testing of individual components, verifying their behavior and interactions through the mediator. With proper testing in place, developers can ensure the correctness and reliability of the system, reducing the likelihood of issues arising from component interactions.</p>



<h2 class="wp-block-heading">Implementation of the Mediator Pattern</h2>



<p>Implementing the Mediator design pattern involves a few key steps that ensure its successful integration into a software system. First, identify the components that require communication and define their interfaces. Next, create the mediator class, which acts as the central hub for communication. The mediator encapsulates the interaction logic and provides methods for components to send messages or notifications. Components should hold a reference to the mediator and use it to communicate with other components indirectly.</p>



<p>To showcase the Mediator design pattern in action, let's consider an example scenario of a chat application. In this scenario, we have different chat participants (components) who need to communicate with each other. The mediator class would be the chat room, which handles the communication between participants. When a participant sends a message, it goes through the chat room, which then relays the message to the intended recipients. This centralization simplifies the communication logic, as participants only need to interact with the chat room, abstracting away the complexities of direct participant-to-participant communication.</p>



<p>When implementing the Mediator pattern in .NET, there are several best practices and considerations to keep in mind. First, carefully design the mediator interface to include methods that facilitate effective communication between components. Ensure that the mediator is responsible for coordinating interactions and doesn't become too bloated with business logic. It's also important to handle edge cases and error scenarios gracefully within the mediator implementation.</p>



<p>Additionally, adhere to SOLID principles and strive for loose coupling between components. Avoid introducing direct dependencies between components outside of the mediator, as this can undermine the benefits of the pattern. Utilize interfaces and abstractions to enable flexibility and maintainability. Finally, consider using dependency injection frameworks to manage the creation and injection of mediators and their dependencies.</p>



<p>By following these implementation steps, leveraging real-world scenarios, and adhering to best practices, developers can successfully implement the Mediator pattern in .NET applications. This pattern promotes efficient communication and enhances the overall architecture of the software, contributing to a more scalable, maintainable, and robust system.</p>



<h2 class="wp-block-heading">Drawbacks and Considerations</h2>



<p>While the Mediator design pattern offers numerous benefits, it is important to be aware of its potential drawbacks and considerations during implementation.</p>



<h3 class="wp-block-heading">Increased Complexity</h3>



<p>Implementing the Mediator pattern introduces an additional layer of abstraction, which can increase the overall complexity of the system. Balancing the benefits gained from decoupling components with the complexity introduced by the mediator is crucial. It is essential to carefully design and document the mediator interface and ensure that it remains focused on communication responsibilities. Techniques such as clear naming conventions, well-defined responsibilities, and thorough documentation can help manage and mitigate the complexity introduced by the Mediator pattern.</p>



<h3 class="wp-block-heading">Performance Overhead</h3>



<p>The Mediator pattern can introduce a slight performance overhead compared to direct component-to-component communication. The additional layer of indirection in the mediator can lead to extra method invocations and object interactions, impacting performance to some extent. However, it is important to note that in most scenarios, the performance impact is negligible unless the application has strict real-time requirements. To mitigate performance concerns, developers can employ optimization techniques such as caching, minimizing unnecessary mediation, and optimizing the mediator's implementation to be as efficient as possible.</p>



<h3 class="wp-block-heading">Potential Dependency on a Single Point</h3>



<p>By centralizing communication through a mediator, the entire system relies on a single point of contact. This introduces a potential risk of a single point of failure. If the mediator becomes a performance bottleneck or experiences a failure, it can significantly impact the functionality of the entire application. To address this risk, it is crucial to design the mediator for scalability and fault tolerance. Strategies such as load balancing, redundancy, and implementing backup mediators can ensure the system remains resilient even in the face of failures. Additionally, monitoring and proper error-handling mechanisms can help detect and recover from potential issues related to the mediator.</p>



<p>By considering these drawbacks and taking the necessary precautions, developers can effectively manage the complexity, optimize performance, and ensure the resilience of systems utilizing the Mediator pattern. Balancing the benefits and trade-offs of the pattern is essential to achieve the desired outcomes and creating robust and reliable software solutions.</p>



<h2 class="wp-block-heading">Real-World Use Cases</h2>



<p>The Mediator design pattern finds its applicability in various real-world scenarios, where effective communication between components is crucial for the success of a software system.</p>



<h3 class="wp-block-heading">Examples of scenarios where the Mediator pattern is beneficial</h3>



<p>1. Chat Applications: In chat applications, the Mediator pattern can be employed to manage communication between multiple users. The mediator acts as the central chat room, coordinating the exchange of messages and notifications between participants.</p>



<p>2. Air Traffic Control Systems: Air traffic control systems heavily rely on coordinated communication between multiple entities such as aircraft, control towers, and ground crew. The Mediator pattern can ensure efficient and organized communication in such complex systems.</p>



<p>3. Event-driven Architectures: Systems that rely on events and event-driven architectures can benefit from the Mediator pattern. The mediator can handle event propagation and communication between event publishers and subscribers, facilitating loosely coupled interactions.</p>



<h3 class="wp-block-heading">Case studies highlighting the successful implementation of the Mediator pattern:</h3>



<p>1. Financial Trading Systems: In financial trading systems, the Mediator pattern can be used to facilitate communication between trading algorithms, market data providers, and order execution systems. This allows for efficient coordination and integration of various components within the system.</p>



<p>2. Game Development: The Mediator pattern is valuable in game development, where multiple game entities, such as characters, enemies, and interactive objects, need to interact. The mediator manages the communication and coordination between these entities, enabling dynamic and interactive gameplay.</p>



<h3 class="wp-block-heading">Insights from experienced developers who have utilized the Mediator pattern.</h3>



<p>Experienced developers have shared insights into their experiences with the Mediator pattern. They emphasize the importance of careful design and ensuring a clear separation of concerns within the mediator. They also recommend keeping the mediator lightweight and focused on communication responsibilities, avoiding excessive coupling or additional business logic. Additionally, developers highlight the benefits of thorough testing and leveraging dependency injection to facilitate flexible and maintainable mediator implementations.</p>



<p>By examining these real-world use cases and insights from experienced developers, we gain a deeper understanding of how the Mediator pattern can be effectively utilized in various domains. These examples and experiences demonstrate the versatility and practicality of the Mediator pattern, enabling the development of robust and well-structured software systems.</p>



<h2 class="wp-block-heading">Conclusion</h2>



<p>In conclusion, the Mediator pattern proves to be a valuable tool in software development, enabling efficient communication and enhancing the architecture of complex systems. Throughout this blog post, we have explored the benefits and drawbacks of the Mediator pattern. Its advantages include decoupled communication, simplified communication logic, flexibility, and improved testability. These benefits contribute to the creation of maintainable, scalable, and modular software systems. However, it is important to consider the potential drawbacks, such as increased complexity and performance overhead, and to address them with proper design and optimization techniques.</p>



<p>It is a good idea to consider the Mediator pattern in your projects, particularly in scenarios that involve multiple components with intricate communication requirements. By leveraging the Mediator pattern, developers can achieve loose coupling, separation of concerns, and improved modularity, leading to more manageable and adaptable codebases. The Mediator pattern offers a structured and standardized approach to communication, enabling better code readability, maintainability, and extensibility.</p>



<p>Effective communication is a fundamental aspect of software development. The Mediator pattern serves as a reminder of the importance of designing software systems that promote clear and organized communication between components. Well-designed communication mechanisms improve collaboration, enhance system performance, and reduce the likelihood of errors or misunderstandings.</p>



<p>In conclusion, the Mediator pattern empowers developers to build software systems that are easier to understand, maintain, and evolve over time. By harnessing the benefits of the Mediator pattern and considering its implications, developers can elevate their software development practices and create robust and efficient solutions.</p>

Mediator design pattern in software development

Mastering CQRS: A Beginner's Guide to Command Query Responsibility Segregation

Event sourcing beginner's guide

Event Sourcing in C# - Best Practices and Implementation Tips

Mastering Microservices Design Patterns: Top 10 Principles

Mastering Saga Pattern for Microservices: Best Practices and Solutions

<p>This is a method for password validation in C#. The password should meet following requirements </p>

<ul><li>At least one lower case letter</li><li>At least one upper case letter</li><li>At least special character</li><li>At least one number</li><li>At least 8 characters</li><li>Can not be more than 32 characters</li><li>Can not contain space</li></ul>


<pre><code class="language-csharp">

public static Result MatchPasswordMinimumCriteria(this CreateUser user)
    {
        if (user.Password.IsShorterThen(8))
        {
            return Result.Failure("Password cannot be less then 8 characters");
        }
        
        if (user.Password.IsLongerThen(32))
        {
            return Result.Failure("Password cannot be more then 32 characters");
        }

        if (user.Password.Contains(" "))
        {
            return Result.Failure("Password cannot contain space");
        }

        bool uppercaseCharacter = false;
        bool lowerCaseCharacter = false;
        bool number = false;
        bool specialCharacter = false;

        string specialCharacterString = @"%!@#$%^&*()?/>.<,:;'\|}]{[_~`+=-" + "\"";
        HashSet<char> specialCharacters =  specialCharacterString.ToCharArray().ToHashSet();
        
        foreach (var character in user.Password)
        {
            if (uppercaseCharacter && lowerCaseCharacter && number &&    specialCharacter)
            {
                break;
            }

            if (number == false && character.IsInteger())
            {
                number = true;
                continue;
            }

            if (lowerCaseCharacter == false && character.IsLower())
            {
                lowerCaseCharacter = true;
                continue;
            }
            
            if (uppercaseCharacter == false && character.IsUpper())
            {
                uppercaseCharacter = true;
                continue;
            }

            if (specialCharacter == false && specialCharacters.Contains(character))
            {
                specialCharacter = true;
            }
        }

        if (lowerCaseCharacter == false)
        {
            return Result.Failure("Password must contain lowercase character");
        }
        
        if (uppercaseCharacter == false)
        {
            return Result.Failure("Password must contain uppercase character");
        }
        
        if (number == false)
        {
            return Result.Failure("Password must contain number");
        }
        
        if (specialCharacter == false)
        {
            return Result.Failure("Password must contain special character");
        }
        
        return Result.Success();
    }  </code></pre>

<p>For better readability the method above can be split into multiple methods.</p>


<pre><code class="language-csharp">
{
    public static bool IsLongerThen(this string text, int minimumLength)
    {
        return minimumLength < text.Length;
    }

    public static bool IsLongerOrEqualThen(this string text, int minimumLength)
    {
        return minimumLength <= text.Length;
    }

    public static bool IsShorterThen(this string text, int maximumLength)
    {
        return maximumLength > text.Length;
    }

    public static bool IsShorterOrEqualThen(this string text, int maximumLength)
    {
        return maximumLength >= text.Length;
    }

    public static bool IsEmpty(this string? text)
    {
        return text == "";
    }

    public static bool IsNotEmpty(this string? text)
    {
        return text != "";
    }

    public static bool IsNullOrEmpty(this string? text)
    {
        return string.IsNullOrEmpty(text);
    }

    public static bool IsNotNullOrEmpty(this string? text)
    {
        return !string.IsNullOrEmpty(text);
    }
}</code></pre>

Password validation in C#

<p>It has been 7 years since I wrote my first line of code and I feel like sharing the story of how I found my first job as a self-taught programmer with 0 work experience might help someone who is also trying to explore the world of coding. </p>


<iframe width="100%" height="315" src="https://www.youtube.com/embed/Eoel5N8IklQ" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>


<h2>A bit about my background</h2>



<p>I moved to Denmark from Ukraine at the end of 2015 with the purpose of taking a master's degree in Mathematics, because that is what I was studying in Ukraine. While preparing all the documents to get accepted to the university, I took a course in Web development on Coursera, which is an educational platform similar to Udemy. And I literally fell in love with it because it was more practical compared to what I have been doing before. I was spending all my spare time taking online courses.</p>



<h2>Job hunting</h2>



<p>3 or 4 months later I felt like it is time to try to get a real job, so I wrote my CV and started applying to different companies. I sent my resume to some big and mid-sized companies for trainee and junior developer roles. Unfortunately, I was getting rejected by everyone and some of the companies never got back to me.</p>



<p>It was a very stressful period of my life. I was getting frustrated and upset, I can not even remember how many times I wanted to give up the idea of being a programmer. When I am thinking about it, I would not probably even hire myself back then. Mostly, because I knew that I did not have a college degree and it really dragged down my confidence. I was thinking that if some will hire me they will give me a favor. What I should have thought instead is that it is a win-win kinda deal. So, the most important lesson that I learned as a self-taught is that self-confidence plays a huge role and dramatically increases your chances to get your first job.&nbsp;</p>



<p><strong>But how can you get a job if no one even gives you a chance for the first interview? </strong>That is a very good question that I was asking There it is where I realized that I need to change a strategy and have at least one legit job experience on my CV. The first thing that I did was create my own company. It is very easy to do in Denmark and I thought that even if I do not find any customers I can still state in my CV that I was a freelancer and I will just keep building my portfolio.</p>



<p>Meanwhile, I was asking everyone around if they needed a website, a banner, a landing page, or a webshop. I even went to my dentist and I said, "Look, it is 2016 and people still need to call you if they want to make an appointment. Let's make you a website!'' I was talking to people at birthdays and weddings asking where they work and if they need any kind of help from a person who can code. This is how I met a guy who had his own publishing company and he was looking for help to create an educational platform for Danish kids to learn English.</p>



<p>At that time he had a freelancer that was doing the backend job for him and he needed someone to do the frontend. By the way, during the 2 years I worked there, I have never spoken with that backend guy.&nbsp;</p>



<p>In short, I had to create a website with the rules from a book and some interactive tests that children could complete and collect points. At that point, I could do only HTML, CSS, and some basic JavaScript. But the task required much more than that.</p>



<h2>Facing real challenges</h2>



<p>After 2 weeks of working there, I realized that I needed some help because even at that point if I studied for 14 hours I could not deliver my tasks before the deadline.</p>



<p>That was 2016 and I did not have any programmer friends back then, so I started thinking if I know anyone related to programming. Then I remembered that back in 2010, when I was studying Mathematics in Ukraine, I had a roommate who had a boyfriend who was into programming. I found him on Facebook and asked if he could help me to speed up my learning process. He said that he is working as a system administrator but he has a friend who is a self-taught front-end developer and he gave me his phone number.</p>



<p>And that guy basically saved my ass. He spent so much time explaining to me basic concepts of programming and giving me code reviews. That was extremely helpful. The funny part is he did not want anything in return because he was also self-taught and he said “My friend helped me when I just started my coding journey and I have to help at least one person for that”.</p>



<p>And this is how I learned how to code. Obviously, it was not great at the beginning. I did not use any concepts of clean code and design patterns but that was the start and I was getting paid for it.</p>



<h2>Salary</h2>



<p>It was a part-time job but I was spending all my time on it as a part of the learning process. I was paid approximately 1 400 USD per month to my company account and I paid 680 USD to myself. The rest stayed in the company. Eventually, that company went bankrupt with all the money but it is a different story.</p>



<p>Do I think that I was underpaid or overpaid? I was extremely happy to get any kind of payment at the beginning. I was expecting that I will have to work for free for a few months to gain some experience. So, the payment seemed to be quite fair.</p>



<h2>What I wish I have done differently</h2>



<p>I think that if my first job was in some big corporation where newbies usually have a mentor that helps them, then my experience would be less painful. I would have fewer sleepless nights, I would not get stressed and burned out. But on the other hand, I got pretty “Lucky” to get a job after only 4 months of learning how to code by myself. And I have no idea how long it would take me to get into a mid-sized or big company. So, I would not change anything here.</p>



<p></p>

My first job as a self-taught programmer

<p>There are several things that make a lot of people believe that life in Denmark seems like a paradise. But is it really as good as it seems? From this post you will learn the truth about life in Denmark and if this country suits your needs.</p>



<img src="/assets/blog/posts/imgs/pexels-marija-rusaka-11185751.jpg" alt="Nyhavn, Copenhagen, Denmark" class="image-center"/>



<p>When people hear the word "Denmark" they instantly think about high living standards, high salaries, a great welfare system, free medicine, a low crime rate, and many other things.&nbsp;</p>



<p>I have been living in Denmark for 7 years, and I can give you an honest opinion about what are the pros and cons of living in the country that got the title “The happiest country in the world”.</p>



<p>There is a list of things that make Denmark a very attractive country for immigration:&nbsp;</p>



<ul><li>High salaries </li><li>Low crime rate</li><li>Free health care</li><li>Free education</li><li>Free kindergartens</li><li>Financial benefits for unemployed</li><li>No racism in Denmark</li><li>Danes are open people and easy to make friends with </li><li>Work-life balance</li><li>Life in Denmark without knowing the Danish language</li></ul>



<p>I will go through each of them to see if it is as good as it seems. Let's start from the top of the list</p>



<h3><strong>High Salaries</strong></h3>



<p>Most people think that Denmark is a gold mine because average salaries are higher than in other European countries, even though there is no official minimum hourly wage.&nbsp;&nbsp;</p>



<p>However, when you hear that number, you have to take into account that you have to pay around 38-50% of taxes, and the prices for eating out, utilities, groceries, and even price for getting a haircut are also higher in Denmark.</p>



<p>For a person that can earn approximately the same amount of money regardless of the country of residence, like, for example, programmers, UI designers, content creators, and so on, I do not think it makes sense to move to Denmark only for the salary. But for a person with a special education such as a bike or car mechanic, hairdresser, nail-lash maker, chef, etc, Denmark can be a good opportunity to make life more comfortable.</p>



<h3><strong>Low crime rate</strong></h3>



<p>Denmark takes second place after Switzerland in the <a href="https://worldpopulationreview.com/country-rankings/crime-rate-by-country" target="_blank" rel="noreferrer noopener">list of countries with the lowest crime rate</a>.&nbsp;</p>



<p>People do not lock their doors and some local grocery stores function without a cashier. Customers just take what they need and leave money at the checkout. The only thing you should definitely put a lock on is your bike to prevent some drunk teenager from “borrowing” it to get home faster.&nbsp;</p>



<p>There are areas in Aarhus and Copenhagen that are considered “high crime districts” but a lot of things people say about them are just rumors.    </p>



<h3><strong>Free health care</strong></h3>



<p>Another thing that makes Denmark very attractive for immigration is free healthcare. Free healthcare means that treatment in a public hospital or visits to your family doctor does require insurance (except dentist). But what it really means is that you pay for it during all your life via taxes.</p>



<p>You pay for medication yourself or you can have insurance that will cover it. However, if you have some chronic disease and you spend a lot of money on medication the state can help you to cover some of it.</p>



<p>Unfortunately, there is also a downside of having free healthcare because it results in a long waiting time to get a visit to a special doctor. For example, some people can only get time at the doctor in a month or even three months. Which is a lot in my opinion. However,&nbsp; if a person has a severe health issue then there is a rule that this person should not wait for treatment longer than a month. If there is no free doctor who can help the patient in a public hospital, they can get treatment at a private hospital for free.</p>



<p>I do not have kids myself but I heard stories from mothers raising children in Denmark that doctors do not bother much trying to make kids feel better when they get ill. For instance, if a kid gets a bad stomach or food poisoned then the recommendation is to eat salty sicks and drink Cola. If a kid got cold, then they should eat ice cream. But the best among all the recommendations is just to wait. I mean, I felt very weird about those stories at the beginning but now I start understanding that maybe in some cases it is better to wait and let the body recover itself than give people pills that might do more harm in the long run.&nbsp;</p>



<p>As a person who lived in Ukraine for 24 years, I can say that Danish health care is on quite a high level. And if someone had a bad experience visiting a family doctor, it is possible to go to another one.&nbsp;</p>



<h3><strong>Free education</strong></h3>



<p>Public schools, colleges, and universities are indeed free in Denmark. And not only for Danes but also for European Union (EU) residents. There is also a scholarship of $897 (2022) before tax, which is around $700 after tax. However, EU citizens have to fulfill some requirements to be eligible to receive a scholarship. For example, one of the requirements is to have a part-time job while studying.&nbsp;&nbsp;</p>



<h3><strong>Free public kindergartens</strong></h3>



<p>Public kindergartens are not free in Denmark, but part of the fee is covered by the state ("kommune") and another part is paid by parents. If you have more than one kid then parents can pay less for the second kid.</p>



<h3><strong>Financial benefits </strong>for unemployed</h3>



<p>It is<strong> </strong>true that it is possible to get money from the state, as well as from private organizations if you quit your job or get fired. Financial support from the state is called “kontanthjælp” and from a private organization “dagpenge”. It is not everyone that can get money from the state. It is mostly for Danish citizens and EU citizens with permanent residence in Denmark. To be able to receive “dagpenge” you should be a member of an organization called “A-kasse” for at least a year. To be a member of such an organization you should pay a fee monthly, for me, it is $80. It is not so easy to be unemployed and receive financial support because from the first day you should show that you are actively looking for a job.&nbsp;&nbsp;</p>



<p>Financial support gives security to the people in Denmark, especially in difficult situations. But you have no idea how many people take advantage of the system and on purpose make sure they do not get a job, so they can be on this financial support as long as possible. I know people who openly say that they moved to Denmark for all the benefits they can get here. In the beginning, it is a scholarship, then when they graduate they apply to receive unemployment support where they are forced to actively look for a job. But because they can apply for positions that do not correspond to their skills or experience they keep getting financial support from the state for X amount of time (usually it is 2 years). Unfortunately, it is not only foreigners who take this path but also a lot of native Danes. There are also some regulations to it because they can not do it forever but still even if a person is getting money from the state (and it is not small money) it will still reflect on the economy.&nbsp;</p>



<h3><strong>There is no racism in Denmark</strong></h3>



<p>Let's say it this way, there is definitely no racism to the level it is, for example, in Russia.</p>



<p>A friend of mine and her husband had to run away from Moscow, Russia to Denmark because he is originally from one of the African countries. He had quite a tough life in Russia because of his skin color.&nbsp;</p>



<p>When my friend got married, her parents said that they do not have a daughter anymore because she chose a husband with different skin color. The guy could not walk alone on the street without being offended or sometimes even bitten by the locals. He also had difficulties finding a job. So, one night when he got home bruised, he and his wife had to run to Denmark to start a new life.&nbsp;</p>



<p>In Denmark you can still hear jokes that some people would find racist, but because Danes are polite people they will never say anything offensive straight to your face. However, some of them might talk behind your back.</p>



<p>To be fair, Denmark is a very small country with only 5,8 million people and for a long time, it was a closed country, compared to the UK, for example. That can be also the reason why Danes started forming some kind of prejudice about other nations. For instance,&nbsp; if you are coming from Poland or Romania you come to steal bikes in Denmark, if you are coming from Baltic countries then you work in the cleaning service. In addition, older Danes believe that foreigners are coming to Denmark to steal jobs from them. They can show their attitude by writing some negative comments on some posts and starting discussions on FaceBook.&nbsp;</p>



<p>The political parties that promote ideas of having fewer foreigners are getting more and more power which results in making requirements to get permanent residence and citizenship harder to fulfill.</p>



<h3><strong>Danes are open people and easy to make friends with</strong></h3>



<p>Not at all. They are very polite and friendly when it comes to interacting with foreigners in the work environment, but usually, they have their close circle of family and friends that they formed during kindergarten and school. So, no it is not easy to make friends with locals.</p>



<h3><strong>Work-life balance</strong>&nbsp;</h3>



<p>Danes have a nice working culture, very focused on employee happiness. They indeed try to keep a balance between work and life. It makes life in Denmark more fulfilling and more enjoyable.  An employee is not allowed by law to be forced to work overtime. If there are some problems at work and an employee thinks that his rights are violated, then there are organizations called “fagforening” that can protect your rights. However, you have to be a member of one of those. </p>



<p>Another nice feature of working in a Danish company is that there will usually be almost no people left in the office after 4 PM. Everyone runs home to spend more time with their family and friends. There is also no visible hierarchy at work. It is common to treat your boss or manager as a friend and it is okay to express your opinion without being afraid to be fired.</p>



<h3><strong>Life in Denmark without knowing the Danish language</strong></h3>



<p>It is not hard to live in Denmark without speaking Danish if your work does not require you to do so and you live in the Copenhagen area. I personally know people that have been living in the capital for 10 years with the same level of Danish since they arrived in the country. In addition, numerous big Danish companies have English as a company language.</p>



<p>You will need to learn Danish if you want to study in a college or university and the program is taught in Danish. If you choose to live in a smaller city then the ability to speak Danish will make your life in Denmark much easier. Another example when Danish is a requirement is for getting permanent residence and citizenship.  </p>



<h3><strong>Conclusion</strong></h3>



<p>Different people have different experiences living in Denmark. Some people love it, others hate it and move back to their native country. There are also a lot of people who complain about everything but don't move anywhere else. My personal problem living in Denmark is the weather. It is quite windy and rainy. There is no winter like in the rest of the Nordic countries with a lot of snow. Instead, winter looks like a mix of autumn, winter, and spring. The long winter with very little sunlight starts in mid-October and lasts until mid-April. This is something that is not possible to change but there is a workaround. Taking holidays to the warm country during winter makes you much happier.</p>



<p>During these 7 years living in Denmark,  I came up with the conclusion that it is a country for people who are focused on family, and work-life balance and believe that everyone in the society should be equal regardless of what you are doing and how much you earn. So, if you are a young, full of ambition, person focused on building a career and having fun in your free time, then maybe life in Denmark is not for you. It could seem to be a bit boring country to live in. Maybe, it is better for you to move to Dubai, London, or LA  </p>

Alina Bo

Coding, tech, life in Denmark