Pattern Resources

Share

Related resources for Pattern

Data Loss Prevention in Microsoft Fabric Internals10/28/2024 9:20:50 AM. Microsoft Fabric’s Data Loss Prevention (DLP) feature protects sensitive data across services like SharePoint, Teams, and Exchange by enabling policy creation, scanning, and enforcement through Micros
An in-depth Look at Advanced Pattern Matching in C# 1210/22/2024 5:27:09 AM. With Ziggy Rafiq, learn how to leverage advanced pattern matching features in C# 12, including the new let pattern and enhanced recursive patterns.
Why In ASP.NET Core logging is often implemented as a singleton10/20/2024 9:31:50 AM. In ASP.NET Core, logging is often implemented as a singleton to ensure efficient resource usage, centralized management, and thread-safe logging across the application.
Pattern Matching for Switch in Java 1710/7/2024 4:17:21 AM. Pattern matching for switches in Java 17 enhances code readability and simplifies working with complex data structures. It allows you to match object types, use type patterns, and add conditions with
Design Pattern (5-3), Dependency Injection, Console Demo10/1/2024 1:45:33 PM. This article will make console demo for the Dependency Injection
Design Pattern (5-1), Dependency Injection Implementation10/1/2024 1:44:22 PM. This article will discuss more about the implementation of Dependency Injection.
Design Pattern (5-4), Dependency Injection, MVC Demo10/1/2024 1:43:52 PM. This article will be an implementation of Dependency Injection for a MVC app.
Building A Cross Platform MVVM Pattern With ReactiveUI And Xamarin.Forms9/27/2024 10:14:33 AM. In this article, you will learn how to build a cross-platform MVVM pattern with ReactiveUI and Xamarin.Forms.
REPR Pattern - For C# Developers9/27/2024 8:14:53 AM. Discover the REPR Pattern, a powerful design technique tailored for C# developers. Learn how this pattern can simplify code structure, improve maintainability, and optimize performance in C# applicati
Why "Service Locator" is an "Anti-Pattern" for Dependency Injection9/26/2024 8:29:26 AM. The "Service Locator" pattern, while widely used, often leads to issues in software design, making it an anti-pattern in the context of Dependency Injection (DI). This article explores the d
Chain of Resposability Pattern9/24/2024 6:17:02 AM. The Chain of Responsibility is a behavioral design pattern that enables passing requests along a series of handlers. Each handler decides to process the request or forward it to the next in line. This
Using C# 12 with Clean Code Practices9/21/2024 3:37:12 PM. Learn how to write cleaner, more maintainable code with C# 12 features such as primary constructors and improved pattern matching. This article explores practical examples and tips for applying clean
Design Principle (2): Inversion of Control (IoC) Principle9/19/2024 3:44:37 PM. This series delves into Software Design Principles, with a focus on the Inversion of Control (IoC) Principle in this article. It covers Dependency Inversion, Dependency Injection, IoC Containers, and
Design Principle (1-1): SOLID in Code Demo9/19/2024 3:43:58 PM. This article will discuss the SOLID in code demo. This article series covers Software Design Principles, focusing on the SOLID principles. It includes practical code demos and explanations for each pr
Prototype Pattern: Cloning Objects in C#9/18/2024 7:52:32 AM. The Prototype Pattern is a creational design pattern that simplifies object creation by cloning existing instances instead of starting from scratch. Ideal for complex objects, it reduces initializatio
Repository Design Pattern in MVC Architecture With Entity Framework9/18/2024 5:49:26 AM. In this article, we will learn the Repository Design Pattern in MVC Architecture with Entity Framework simplifies data access by creating a layer between the data and business logic.
Top Reasons Why Web Developers Choose AngularJS9/17/2024 9:24:20 AM. AngularJS is a powerful, open-source JavaScript framework developed by Google for building robust Single Page Applications (SPAs). It simplifies web development by using HTML as a template language, o
Singleton Pattern: Ensuring a Single Instance in .NET Core9/17/2024 7:19:37 AM. In this article, we learn about Singleton Pattern: Ensuring a Single Instance in .NET Core. The Singleton Pattern ensures a class has only one instance, providing global access. It's commonly used
Abstract Factory Pattern: Designing Families of Related Objects in C#9/17/2024 5:10:34 AM. The Abstract Factory Pattern provides an interface for creating families of related objects without specifying their concrete classes. It ensures consistency and flexibility in object creation, useful
Factory Method Pattern: Simplifying Object Creation in C#9/17/2024 4:01:43 AM. The Factory Method Pattern is a creational design pattern that delegates object creation to subclasses, promoting flexibility and maintainability. It defines an interface for creating objects but lets
Categorizing Design Patterns: Creational, Structural & Behavioral9/16/2024 8:17:37 AM. In this article we will learn about Categorizing Design Patterns: Creational, Structural, and Behavioral. It provides real-life examples, benefits, and challenges, offering developers insights for be
The Importance of Design Patterns in .NET Core Development9/16/2024 6:11:56 AM. This article discusses the importance of design patterns in .NET Core development, highlighting how they enhance scalability, maintainability, and flexibility. Key patterns include Singleton, Reposito
What Are Design Patterns? Understanding the Basics9/16/2024 5:51:51 AM. Design patterns are essential in software development, offering reusable solutions to common problems. By applying patterns like Singleton, Factory Method, and Observer, developers create flexible, ma
Builder Pattern: Constructing Complex Objects9/14/2024 1:58:12 PM. In this article, we learn about Builder Pattern: Constructing Complex Objects. The Builder Pattern simplifies the creation of complex objects through step-by-step construction. It enables flexibility,
Design Principle (0): Design Principle vs Design Pattern9/13/2024 12:17:06 PM. This series explores software design principles, distinguishing between high-level design principles like SOLID and low-level design patterns, offering practical guidelines and implementation strategi
CRUD Operation Using Repository Unit Of Work Pattern9/12/2024 5:44:14 AM. Create an ASP.NET MVC project in Visual Studio 2013, add a class library, and set up a SQL Server database. Implement Entity Framework with an EDMX model, then use the Repository pattern for CRUD oper
Design Pattern (3), Singleton9/5/2024 12:49:09 PM. This article will discuss the Singleton pattern.
A Guide to Using the Decorator Pattern in Your C# Code9/4/2024 5:40:43 AM. In this article, we will learn how to implement this pattern in your C# code, improve code reusability, and follow best practices for more maintainable and flexible software design.
Understanding State Design Pattern9/2/2024 5:00:07 AM. This pattern is particularly useful for implementing state machines or managing complex state-dependent logic, as it promotes cleaner code and improves maintainability in software development.
Using Factory Patterns in C# 12 to simplify A/B testing8/31/2024 4:40:36 AM. Find out how Ziggy Rafiq simplifies A/B testing with feature toggles in C# 12 by using Factory and Abstract Factory design patterns.
Understanding of Design Patterns8/30/2024 5:13:44 AM. Design patterns are essential in software development, divided into architectural and application/code-level patterns. Architectural patterns guide the high-level structure of software, ensuring compo
C# 12 Design Patterns: Factory and Abstract Factory8/29/2024 2:29:42 PM. By Ziggy Rafiq, discover how Factory and Abstract Factory design patterns simplify the creation of complex objects in C# 12.
Repository Pattern In ASP.NET Core8/29/2024 7:16:41 AM. In this article, you will learn about repository pattern in ASP.NET Core.
Understanding of Domain Driven Design (DDD)8/29/2024 6:25:58 AM. Domain-driven design is a software development approach that closely aligns software models with business needs. It focuses on key concepts like Entities, Value Objects, Aggregates, and Aggregate Root
Abstract Factory Design Pattern in .NET Core C# 128/29/2024 4:29:33 AM. In this detailed article by Ziggy Rafiq, you will learn how to implement key components like AbstractFactory, ConcreteFactory, AbstractProduct, and ConcreteProduct in .NET Core with C# 12. By leveragi
Understanding CQRS Design Pattern8/28/2024 5:57:21 AM. CQRS (Command Query Responsibility Segregation) is a pattern that separates the responsibilities of reading and writing data into distinct models. This separation can help optimize both aspects indepe
Singleton Pattern Caching in .NET C#8/26/2024 4:05:29 AM. Learn how to implement caching using this pattern to enhance memory management, ensure thread safety, and optimize performance in your applications.
Factory Design Pattern Real World Example8/21/2024 8:44:53 AM. In this article, you will see the real world example of Factory Design Pattern.
Advanced gRPC Communication in .NET Core8/20/2024 7:27:56 AM. Explore advanced techniques for implementing microservices communication using gRPC in .NET Core. This article dives into high-performance, real-time communication patterns with practical code example
Event-Driven Microservices with .NET Core8/20/2024 7:18:14 AM. Build scalable, resilient microservices with .NET Core and MediatR by implementing event-driven architecture. This approach decouples services, enhances scalability, and simplifies maintenance. Learn
Learn Advanced CQRS with .NET Core8/20/2024 7:12:32 AM. Dive into the advanced implementation of the Command Query Responsibility Segregation (CQRS) pattern using .NET Core and MediatR. This article explains the benefits of CQRS in modern application devel
CRUD Operations with Repository Pattern and Web API in .NET 88/20/2024 6:57:32 AM. This guide covers creating a clean, maintainable data access layer by leveraging the Repository Pattern for managing database interactions and exposing endpoints through Web API, enhancing your .NET 8
Understanding Adapter Design Pattern8/16/2024 7:15:32 AM. The Adapter Design Pattern is a structural pattern that allows incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces by converting the interface of a class
Exploring Advanced Design Patterns in .NET Core8/12/2024 9:20:27 AM. A deep dive into the latest trends in design patterns within the .NET Core ecosystem. Understand how these advanced patterns are shaping modern application development and architecture.
Advanced .NET Core Design Patterns with Code Examples8/12/2024 8:58:55 AM. This article delves into advanced design patterns in .NET Core, offering practical examples and code snippets. Learn how to implement these patterns to build scalable and maintainable applications.
Transformer and Hallucinations in Simple Language8/12/2024 5:32:07 AM. Imagine a language model as a clever bird that creates new sentences from patterns it learned, not by recalling facts. It generates text by guessing the next word based on its training. While it produ
Validating User Input Using Regular Expression With C#8/9/2024 9:46:52 AM. In software development, validating user input is crucial to prevent errors and security issues. Regular expressions (regex) are used to validate fields such as email, zip codes, and phone numbers. Th
Builder Design Pattern in .NET Core C#8/9/2024 5:34:59 AM. The Builder Design Pattern in .NET simplifies constructing complex objects by using a step-by-step approach. It involves components like Abstract Builder, Concrete Builder, Director, and Product to se
Advanced .NET Core with MediatR Pattern8/8/2024 10:07:41 AM. Dive deep into the advanced usage of the MediatR pattern in .NET Core applications. Learn how to enhance application architecture with MediatR for complex scenarios, including code examples and best p
Understanding Relationship Between Objects8/7/2024 10:53:55 AM. Object relationships define how different classes interact in an application. Collaboration (uses-a), Aggregation (has-a), and Inheritance (is-a) are key types. For instance, Customer and Order use ag
Implementing the Mediator Pattern in .NET Core with MediatR8/6/2024 10:55:03 AM. Learn how to implement the Mediator pattern in .NET Core using the MediatR library. This article provides a detailed guide with code examples to help you understand and apply the Mediator pattern in y
CQRS Design Pattern and Its Use Case8/5/2024 9:45:32 AM. In this article, we will explore its use cases in microservices and domain-driven design, focusing on event sourcing, command and query handling, and optimized data management.
Repository Pattern With ASP.NET MVC And Entity Framework8/5/2024 3:59:24 AM. The "Repository Pattern with ASP.NET MVC and Entity Framework" tutorial guides you through implementing a robust data access layer using the repository pattern in ASP.NET MVC applications.
Repository Pattern In ASP.NET MVC8/5/2024 3:53:48 AM. In this article, we will learn about Repository pattern which is mostly used to create enterprise applications. Repository pattern divides application’s UI, business logic and data access components i
Understanding Builder Design Pattern8/1/2024 6:14:40 AM. The Builder is a pattern that belongs to the creational design patterns family. What makes it special is its ability to provide abstraction to the client by encapsulating different types of the same o
Essential Regular Expressions for Web Development7/31/2024 5:03:31 AM. Learn how to use regex for effective input filtering, text parsing, and string manipulation in both front-end and back-end environments. Master these techniques to build robust web applications.
Design Pattern (1), MVC7/29/2024 2:27:55 AM. This article will discuss Design Pattern, Model View Controller.
Design Pattern (2), MVVM7/29/2024 2:27:32 AM. This article discuss the Design Pattern, MVVM for WPF.
Design Pattern (3-1), Differences between Singleton & Static Class7/29/2024 2:24:17 AM. This article will discuss the Differences between Singleton and Static Class. This series explores Design Patterns, starting with MVC. The article discusses differences between Singleton and Static cl
Design Pattern (5), Dependency Injection7/29/2024 2:22:29 AM. This article discusses Dependency Injection. This article series covers Design Patterns, starting with MVC. This specific article focuses on Dependency Injection (DI) in .NET, explaining the Dependenc
Understanding Iterators in C#7/28/2024 9:09:18 AM. In this article, we will Understand key concepts, such as iterator methods and custom iteration patterns, and enhance your C# programming skills with practical examples and tips.
Singleton Design Pattern in .NET Core7/26/2024 5:01:10 AM. The Singleton Design Pattern ensures a class has only one instance and provides a global access point to it. In .NET Core, this involves a private constructor, a static instance variable, and a static
Java 21: The Latest Features and Improvements7/26/2024 4:11:18 AM. Java 21 introduces significant enhancements including Pattern Matching for Switch, Record Patterns, and String Templates. It also features Sequenced Collections, Virtual Threads, and Scoped Values, st
Understanding the Repository Design Pattern in .NET Core7/25/2024 4:53:07 AM. The Repository Design Pattern is a commonly used design pattern in software development that provides an abstraction layer between the business logic and data access layers in an application. It helps
Singleton Design Pattern: Detailed Explanation and Practical Examples7/24/2024 6:52:58 AM. The Singleton Design Pattern ensures a class has only one instance and provides global access to it. Implementations include Basic Singleton, Thread-Safe Singleton with synchronization, Double-Checked
Detailed Explanation of Builder Design Pattern in C#7/22/2024 6:26:29 AM. The Builder design pattern is a creational pattern used to construct complex objects step by step. It separates the object's construction from its representation, allowing for varied configuration
Logging Patterns in ASP.NET Core 87/22/2024 4:56:21 AM. In this article, we will explore the essential logging patterns in ASP.NET Core 8 to enhance your application's observability. Learn about basic, structured, and exception logging, along with best
Singleton Design Pattern7/19/2024 9:55:57 AM. Learn about the Singleton design pattern, which ensures a single instance of a class in Java. Explore eager and lazy loading techniques, including thread-safe solutions like double-check locking and e
Builder Design Pattern7/19/2024 7:01:46 AM. The Builder Design Pattern is a creational design pattern used to construct complex objects step by step. It separates the construction of an object from its representation, allowing for different typ
Factory Design Pattern 7/18/2024 2:52:28 PM. The Factory Design Pattern in Java is a creational pattern used to create objects without specifying the exact class of object that will be created. It promotes loose coupling by separating object cre
Bridge Design Pattern 7/18/2024 2:51:39 PM. The Bridge Design Pattern in Java separates abstraction from implementation, allowing them to vary independently. It promotes decoupling by creating a bridge between abstraction and its implementation
Prototype Design Pattern7/18/2024 2:51:17 PM. Learn about the Prototype design pattern in Java, a creational pattern that enables object cloning for efficient instantiation. Explore cloneable interfaces, deep vs. shallow copying, and how to imple
Harnessing Efficiency: Lazy Initialization in C# .NET7/17/2024 12:43:28 AM. Learn about lazy initialization in C# .NET—a vital design pattern that defers object creation until it's needed, optimizing performance and memory usage. Implementing with Lazy<T> ensures th
Generic Repository with EF Core Store Procedure in .NET Core 87/16/2024 12:40:58 PM. Entity Framework Core (EF Core) empowers .NET developers with seamless database interaction through object-relational mapping (ORM) and support for stored procedures. It optimizes performance by execu
Soft Deletes with EF Core7/16/2024 5:45:57 AM. Learn how to implement soft deletes using EF Core in your ASP.NET Core applications. This guide covers the soft deletion pattern, ensuring data integrity while keeping historical records.
The Unit of Work Pattern in C# for Modern Applications7/11/2024 8:17:00 PM. Explore the Unit of Work pattern in C#, essential for modern application development. Discover how it facilitates efficient database operations, manages transactions with Entity Framework, and enhance
C# Discriminated Unions and .NET Channels7/11/2024 3:00:02 AM. Explore the advanced features of C# with a focus on Discriminated Unions and .NET Channels. Learn how Discriminated Unions enhance type safety and pattern matching, and how .NET Channels facilitate co
Understanding about OpenZeppelin7/10/2024 6:30:07 PM. OpenZeppelin is a vital open-source entity in blockchain, offering robust tools for secure smart contract development on Ethereum. It provides libraries for ERC20, ERC721, and ERC1155 standards, empha
Detailed explanation of Abstract Factory design pattern7/8/2024 4:02:03 AM. The Abstract Factory design pattern is a creational pattern that provides an interface for creating families of related or dependent objects without specifying their concrete classes.
How to use the Abstract Factory Pattern in C# with the Interface Pattern7/4/2024 10:16:09 AM. Learn how these design patterns improve flexibility, scalability, and maintainability in software development by exploring the Abstract Factory Pattern and Interface Pattern in C# with Ziggy Rafiq. Be
Dependency Injection (DI) in .NET Core with a Simple Example7/4/2024 5:53:09 AM. Dependency Injection (DI) in .NET Core enhances code modularity, testability, and maintainability by decoupling dependencies. It follows Inversion of Control (IoC) principles, where classes receive th
Programming in Practice - GUI - MVVM Program Design Pattern7/3/2024 11:09:45 AM. This article concerns selected issues related to the representation of process information in graphical form to develop a comprehensive User Interface. It presents MVVM programming pattern as an imple
Generic Repository with EF Core in .NET Core 87/3/2024 9:18:09 AM. Observe the Entity Framework Core Generic Repository! The subject that will make some people uncomfortable. They are unwilling to discuss it at all. Others, on the other hand, adore it and become gidd
Consume API in Repository Design Pattern7/2/2024 8:57:02 AM. Learn how to effectively consume APIs using the Repository Design Pattern. This approach enhances code organization by separating data access logic into reusable repositories, promoting maintainabilit
Understanding Builder Design Pattern 7/1/2024 6:57:09 AM. Discover the Builder Design Pattern, a creational pattern that separates the construction of a complex object from its representation. Learn how it simplifies object creation, especially for objects r
Design Patterns and Advantages of Different Design Patterns7/1/2024 6:42:39 AM. Design patterns are recurring solutions to common problems in software design. They provide a template for solving issues in a particular context. The advantages of using different design patterns inc
Understanding CQRS Design Pattern 6/27/2024 5:05:00 AM. The CQRS (Command Query Responsibility Segregation) pattern separates the operations for reading and writing data in software architecture. It enhances scalability by segregating commands (writes) and
Automate SharePoint Site Creation with PowerShell and PnP6/26/2024 10:51:08 AM. Automate SharePoint site creation effortlessly using PowerShell and PnP (Patterns and Practices). Learn efficient scripting techniques to streamline the provisioning process, enhancing productivity an
Unit Testing With MS Tests In C#6/24/2024 11:44:18 AM. Unit testing ensures code quality by validating individual functions or methods. It reduces regression testing efforts, enhancing software maintenance. Using frameworks like MS Test or NUnit, develope
Techniques of State Management in .NET6/24/2024 6:03:49 AM. State management in .NET 6 is essential for preserving and accessing data across web applications. Techniques include server-side (session state, database storage) and client-side (cookies, LocalStora
Integrating Third-Party API Using AJAX in ASP.NET Core MVC 6/23/2024 6:15:23 AM. Integrating third-party APIs into your web application enhances functionality by accessing external data and services. This article demonstrates integrating an API using AJAX in an ASP.NET Core Razor
Design Patterns with C# Examples6/19/2024 11:57:56 AM. This article explains design patterns, providing standard solutions for software design problems. It covers Creational, Structural, and Behavioral patterns with C# examples, including Singleton, Facto
Introduction to Model View Control (MVC) Pattern using C#6/18/2024 8:42:40 AM. The benefits of using the Model-View-Control (MVC) pattern in our development projects is that we can completely decouple our business and presentation application layers. Furthermore, we will have a
Difference Between MVC And Web Forms6/13/2024 11:53:51 AM. Learn about MVC (Model-View-Controller) and its advantages over Web Forms in ASP.NET development. MVC emphasizes separation of concerns, better maintenance, and testing. Discover how MVC uses control
Facade Design Pattern In C#6/13/2024 11:52:32 AM. C# Facade Pattern is used in hiding complexity of large systems and provide simpler interfaces. In this article, we will understand what Facade Pattern is and when and how to use a facade pattern in C
Different Types Of Constructor In C#6/13/2024 10:35:41 AM. Constructors in C# initialize objects upon creation. They ensure objects start in a defined state by setting initial values or performing necessary setup. Types include default (without parameters), p
Repository Design Pattern In ASP.NET MVC6/13/2024 8:25:08 AM. Learn why direct database access complicates applications. Repository pattern in C# separates data access, improves testability, and supports flexible architecture changes. Follow a step-by-step guide
Garbage Collection - Dispose Vs Finalize And IDisposable Pattern6/12/2024 6:51:19 AM. Explore Finalize, Destructor, IDisposable pattern in C# for managing unmanaged resources. Learn about memory management, Garbage Collector behavior, and IDisposable interface. Implement IDisposable fo
Facade Design Pattern With Example6/11/2024 12:19:08 PM. In this article we will try to implement Facade Design pattern using an example of a Banking System which has different types of accounts like checking and savings.
ASP.NET Core 2 - Architecture And Design Pattern Ideology6/8/2024 12:52:03 PM. The need for a robust, interactive web experience is rapidly growing, necessitating improved, simpler, developer-friendly web technologies. ASP.NET Core 2 enhances productivity by providing a pre-defi

Topics