Today in this article, we will go over Data Modelling – Fundamentals and Building Blocks and their usage guidelines.

What is Data Modelling

Data modeling is an important technique for effective database design, understanding the data requirements of a particular use case, and offering a structured method for understanding, representing, and implementing data structures for a given requirement.

Data Modelling normally occurs at the beginning of the development process to understand and document business requirements before database implementation.

This means it heavily helps you identify and documentation of business logic, rules, and relationships to ensure that the data model aligns with business objectives.

Data modeling focuses on organizing data at a Conceptual or Abstract or Physical level.

It aims to understand the information requirements of a business or system and define the relationships between different data entities.

Data modeling utilizes techniques like Entity-Relationship Diagrams (ERD) to represent entities, attributes, and relationships between entities, but this evolution and brainstorming does help you define your requirements in a true sense.

Along with facilitating discussions, it ensures changes to the design are visited during the early stages of development. In the world of development, which fully relies on design in the first place this does help in a greater way.

Data Modelling encourages communication between various stakeholders including the product owner, scrum, developers, or architects by providing a visual representation of data concepts that is accessible to both technical and non-technical audiences.

It very good technique for extending logical and physical design, normalization, relationship mapping, and performance optimization at the very beginning of use case or requirements explorations.

SQL and NO SQL – Data modeling is still a valid technique

Data Modelling operates at a more elevated level of abstraction, stressing entities, attributes, and relationships without getting into specific database implementation details, and hence this technique’s value holds for SQL or No SQL database design.

The outcomes of Data modeling ensure conceptualization, understanding, and representation of data requirements to various stake stakeholders and hence build confidence in the product which is going to evolve later stage as deliverables.

Type of Data Modeling Concepts

Conceptual Data Modeling

• Focuses on the high-level representation of the domain entities, business concepts, and relationships within a system.

• Helps in getting all the the fundamental entities, attributes, and relationships between.

• Provide a clear and abstract view of the business requirements, serving as a foundation for further development.

Logical Data Modeling

• This modeling helps translate the conceptual data model into a more detailed and structured format that can be implemented in a database.

• Defines tables, columns, fields, data types, relationships, and constraints for the given database management system.

• It acts as a bridge between the conceptual model and the physical implementation, ensuring a comprehensive and consistent representation of data.

Physical Data Modeling:

• Focuses on the actual implementation of the database on a specific database management system SQL or No SQL.

• Includes details such as storage structures, indexing, partitioning, and other optimization techniques to enhance performance.

• Involves decisions about how data is stored, accessed, and retrieved at the physical level, considering the specific features and requirements of the chosen DBMS.

Building blocks of Data modeling

Entities in Data Modelling

The best way to judge an entity is as some type of “real-world subject.”

At the end entity represents ” a collection of attributes or fields.”

Entities represent distinct objects, concepts, or things within a system that are described and stored as data.

These entities encapsulate relevant information through attributes, defining the properties or characteristics associated with them.

For example, in a customer relationship system, a “Customer” entity might include attributes such as “CustomerID,” “Name,” and “Email.”

Identifying and modeling entities is foundational for a clear understanding of the information requirements and relationships within a given domain or system.

Attributes in Data Modelling

Attributes provide granularity to the data model, offering a way to distinguish and categorize information within entities.

By defining these attributes, data modeling achieves a more comprehensive representation of the underlying data, enabling the organization and retrieval of specific details associated with each entity in a structured and meaningful manner.

Characteristics or properties of entities that describe the data associated with them.

Attributes provide details about the entities and are often represented as adjectives, like “Name” or “DateOfBirth.”

Relationships in Data modeling

In data modeling, relationships establish connections between entities, defining how they interact. T

These connections convey associations and dependencies, crucial for understanding the dynamics within a system.

For instance, in a database for a library, a “Customer” entity may have a relationship with an “Order” entity, indicating the association between individuals requesting an order.

• Relationships specify the cardinality and nature of connections, such as one-to-one or many-to-many, providing a structured framework for data representation.

• By modeling relationships, data modeling ensures a comprehensive understanding of how entities relate to one another, fostering accurate and efficient retrieval of information from the database.

Keys in Data modeling

• Keys play a pivotal role in data modeling by uniquely identifying and organizing data within a database.

• In RDBMS or SQL worlds example – the “primary key” serves as a distinct identifier for each record, ensuring data integrity.
  • Foreign keys establish relationships between tables, linking data across entities.
  • Index keys enhance query performance, enabling swift data retrieval.
  • Composite keys combine multiple attributes to create a unique identifier.

• In No SQL Unique Keys identify documents or entries within a collection, ensuring data integrity.
  • In document-oriented databases, like MongoDB, keys often include a unique identifier, such as the document’s “_id.”
  • In key-value stores, like Redis, keys serve as direct access points to values.
  • NoSQL databases may also use composite keys or secondary indexes for diverse query patterns.
  • Keys are crucial for optimizing data access, retrieval, and navigation in NoSQL databases, contributing to performance in managing various data structures and relationships.

Benefits of Data Modeling

Below are the top-level benefits of data modeling.

• Creating a structure for collaboration between your IT and business teams.

• Revealing opportunities for improving business processes by defining data needs and uses.

• Saving time and money on IT and process investments through appropriate planning.

• Reducing errors (and error-prone redundant data entry) while improving data integrity.

• Increasing the speed and performance of data retrieval and analytics by planning for capacity and growth.

• Setting and tracking target key performance indicators tailored to your business objectives.

Data modeling Tools

Here are a few useful tools for Data modeling examples:

• erwin Data Modeler is a data modeling tool based on the Integration DEFinition for information modeling (IDEF1X) data modeling language that now supports other notation methodologies, including a dimensional approach.

• Enterprise Architect is a visual modeling and design tool that supports the modeling of enterprise information systems and architectures. It’s based on object-oriented languages and standards.

• ER/Studio is database design software that’s compatible with several of today’s most popular database management systems. It supports both relational and dimensional data modeling.

• Open Source tools include open-source solutions such as Open ModelSphere.

That’s all! Happy coding!

Does this help you fix your issue?

Do you have any better solutions or suggestions? Please sound off your comments below.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post What is Data Modelling – Fundamentals and Guidelines first appeared on TheCodeBuzz.

In this article, we will learn Entity Framework Repository Implementation for Relational databases like SQL in the .NET Core or ASP.NET Core 3.1 or .NET 6 application.

We already discussed basic details on getting started with EFCore in ASP.NET Core in our last article.

In Today’s article, we shall see how to extend the same existing implementation to use a better pattern i.e Repository.

Below are the steps which we shall be following to create a Repository,

EFCore scaffolding as Repository and UoW

EFCore is an ORM-Object-relational mapping framework that helps to represent the Database into the object-oriented programming model in the .NET Core ecosystem helping to interact and perform CRUD operation on relational DB without hassle.

Repository design patterns fit into any NoSQL or Relational DB requirements and also can be used for multiple other requirements.

Entity Framework DBContext as Repository and UOW

Using tools like Entity Framework gives us DBContext which already represents repository and UoW (Unit Of Work) implementation with very minimal effort.

The best thing is you can use DBContext anywhere from your code.

This DBContext can be DI (Dependency Injected ) from the API pipeline or Middleware as needed or can be consumed directly.

However, if you see DBContext is a class and not an Interface.

If you need to perform Test-Driven Development like Unit Testing, you will find a few challenges in mocking DBContext to simulate the Data access.

So considering testability as an important principle, one can easily implement a Repository.

Repository encourages a more loosely coupled approach to accessing our data from the database.

The code becomes cleaner and maintainable and highly extensible.

Entity Framework- Create Models using Schema

Do you follow schema modeling ??.

EFCore works very well for the Database First approach.

Where it lets you create the required scaffolding and domain entities using the existing Database.

However, You can follow the code-first approach as well followed by using Migration and Update database commands to create the database.

Entity Framework – using Database First

We shall be learning EFCore using Database first approach where we already have an existing Database called ‘Master‘ and a table name called Employee.

SQL Database Schema

We can start with the below simple Database schema,

I have discussed how to do ECore scaffolding and generate domain entities in the below article.

• Scaffold – DBContext Database command in .NET Core

Once you are ready with scaffolding please use the repository to access DBContext objects as below.

Entity Framework- Define Repository Interfaces

Repository Interfaces will be defined as below,

public interface IEmployeeRepository
{
    IEnumerable<Employee> GetEmployees();
    Employee GetEmployeeByID(int employeeID);
    void InsertEmployee(Employee employee);
    void DeleteEmployee(int employeeID);
    void UpdateEmployee(Employee employee);
}

We shall define repository class specific to the context, i.e. here EmployeeRepository will be dealing with Employee DBContext.

Entity Framework- Define Repository Class

Please see the implementation for the Repository class performing CRUD operation below.

EmployeeContext object is accessed using EmployeeRepository Constructor injections as below,

public class EmployeeRepository : IEmployeeRepository
    {
        private readonly EmployeeContext _context;
        public EmployeeRepository(EmployeeContext context)
        {
            _context = context;
        }
        public IEnumerable<Employee> GetEmployees()
        {
            return _context.Employee.ToList();
        }
        public Employee GetEmployeeByID(int employeeID)
        {
            return _context.Employee.Find(employeeID.ToString());
        }
        public void InsertEmployee(Employee employee)
        {
            _context.Employee.Add(employee);
        }
        public void DeleteEmployee(int employeeID)
        {
            Employee employee = _context.Employee.Find(employeeID);
            _context.Employee.Remove(employee);
        }
        public void UpdateEmployee(Employee employee)
        {
            _context.Entry(employee).State = EntityState.Modified;
        }
    }

EmployeeContext is created using database Scaffolding DBContext Commands as discussed in our Getting Started using EFCore article.

Now that our Repository is ready, this can be integrated into the code.

If following non-DDD or DDD architecture this repository will be responsible for performing CRUD and will also be used for data persistence through DBContext.

Using a Repository in API/Service

Here is an example of how I am using the repository in EmployeeController (In a similar way this repository can be interfaced from the Domain or Business layer as required (if you have any).

EmployeeRepository object is accessed using EmployeeController’s Constructor injections.

Below is a very simple and minimal implementation,

    [Route("api/[controller]")]
    [ApiController]
    public class EmployeeController : ControllerBase
    {
        private readonly IEmployeeRepository _employeeRepository;
        public EmployeeController(IEmployeeRepository employeeRepository)
        {
            _employeeRepository = employeeRepository;
        }
        // GET: api/Employee
        [HttpGet]
        public ActionResult<IEnumerable<Employee>> Get()
        {
            return Ok(_employeeRepository.GetEmployees());
        }
        // GET: api/Employee/5
        [HttpGet("{id}")]
        public ActionResult Get(int id)
        {
            return Ok(_employeeRepository.GetEmployeeByID(id));
        }
        // POST: api/Employee
        [HttpPost]
        public void Post([FromBody] Employee value)
        {
            _employeeRepository.InsertEmployee(value);
        }
        // DELETE: api/5
        [HttpDelete("{id}")]
        public void Delete(int employeeID)
        {
            _employeeRepository.DeleteEmployee(employeeID);
        }
    }

Repository and DBContext using IoC Dependency injection Container

Please initialize Repository and DBContext in the Service Container as below,

Dependency injection Container in .NET 3.1

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddScoped<IEmployeeRepository, EmployeeRepository>();
            services.AddDbContext<EmployeeContext>(options =>
            {
                options.UseSqlServer(Configuration.GetConnectionString("EmployeeDB"),
                 sqlServerOptionsAction: sqlOptions =>
                 {
                     sqlOptions.EnableRetryOnFailure();
                 });
            });
        }

Dependency injection Container in .NET 6 and above

If using .NET 6 and above, please use builder instances to add the lifetime of required services,

Example

        
            builder.services.AddScoped<IEmployeeRepository, EmployeeRepository>();
            builder.services.AddDbContext<EmployeeContext>(options =>
            {
                options.UseSqlServer(Configuration.GetConnectionString("EmployeeDB"),
                 sqlServerOptionsAction: sqlOptions =>
                 {
                     sqlOptions.EnableRetryOnFailure();
                 });
            });

Please note that the repository instance lifetime in your IoC container should be set as Scoped (same as DBContext) as a good practice.

As shown in the above code, we also have resiliency implemented for SQL Connection using EnableRetryOnFailure() added with the DBContext instance.

As a good practice, implement resiliency in SQL operation to address any issues related to Transient errors.

One can also implement a more Generic repository around DBContext if needed addressing multiple Domain models as discussed below article if needed.

• MongoDB Generic Repository Implementation ASP.NET Core

You are all set to use a repository in your code.

Other References :

• Getting started with EFCore in .NET Core

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

Today in this article we learned how to implement a Repository around SQL database using the EFCore ORM framework.

Application with a complex business/domain model gets a huge advantage over the Repository.

It provides an abstraction that not only isolates the business objects from the database access code but also provides a clean separation of concerns in an Object-oriented way.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Entity Framework Repository Implementation in ASP.NET Core first appeared on TheCodeBuzz.

Today in this article, we will talk about Middle Man Code Smell Resolution with examples.

This code smell more talks about encapsulation. As we know there are many advantages of encapsulating the delegated objects and exposing the delegates directly.

“Code is maintained more often than it is written”

Middle Man code smells come under a category called ‘Couplers’. In our last article, we understood couplers with the smell of Inappropriate Intimacy. and Feature envy which talks about class relationships and features/functions/method coupling, etc.

“Code is read more often than it is written”

Today in this session we will talk about the encapsulation of delegates.

Remove Middle Man

This is one of the code smell recipes to fix the code smell associated with delegated objects.

Let’s take an example with code smell,

Code Smell examples

   class Program
    {
       static void Main(string[] args)
        {
            Person person = new Person();
            person = person.GetManager();
        }
    }


    class Person
    {
        public Department Department { get; set; }
        public Person GetManager()
        {
            return Department.GetManager();
        }
    }


    class Department
    {
        private readonly Person _manager;
        public Department(Person manager)
        {
            _manager = manager;
        }
        public Person GetManager()
        {
            return _manager;
        }
    }

As in the above example, the Client class calls the Person’s delegated object to call the Department and get the manager’s details.

The issue with this approach is that every time the client wants to use the new feature of the delegates, the same feature needs to be added to the Person and Department as well.

To remediate this issue one can use a recipe called “Remove Middle Man”.

Resolution

Let’s remove the Middle man and expose the delegates from both Person and department to the client directly. So the client talks and knows the object it calling.

class Program
    {
        static void Main(string[] args)
        {
            Person person = new Person();
            Department department = person.GetDepartment();
            person = department.GetManager();
        }
    }
    class Person
    {
        public Department Department;
        public Department GetDepartment()
        {
            return Department;
        }
 
    }

    class Department
    {
        private readonly Person _manager;
        public Department(Person manager)
        {
            _manager = manager;
        }
        public Person GetManager()
        {
            return _manager;
        }

    }

The client talks to the Person and the Department objects directly. This removes the middleman or encapsulation. Also now the client talks and knows who is he interacting with.

Happy Coding !!

References:

• Continuous Code Quality using NDepend

• Sonar – Continuous Code Quality of Angular, React, Vue

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Awesome Code – Middle Man Code Smell Resolution with examples first appeared on TheCodeBuzz.

Today in this article, we will see a few techniques of how to autogenerate C# Class using JSON string or JSON Schema.

You might find the need for converting JSON schema to C# types or Typescript types while dealing with JSON format.

As we know JSON is a very popular format for information exchange, especially when dealing with information exchanges between Microservices using RESTFul principles.

We shall see how we can use NJsonSchema a C# library to create C# classes easily.

We will also see Visual Studio ‘Paste Special‘ functionality to achieve the same.

Today in this article, we will cover below aspects,

One can create C# classes for any given JSON in the form of a request or type or schema file.

Using NJsonSchema for creating classes

NJsonSchema is a .NET library to read, generate and validate JSON Schema. It provides basic code generation APIs, which can be used to generate C# classes or generate TypeScript classes or interfaces from a JSON schema.

The library reads a schema from a file or string and validates JSON data against it.

This library can be used to generate a schema from existing .NET classes.

Below are a few high-level features about this library,

• Generate C# code from JSON Schema
• Generate TypeScript code from JSON Schema
• Generate JSON Schema from JSON request or data file
• Generate JSON Schema from .NET classes/type via reflection
• Supports JSON Schema, Swagger and OpenAPI DTO schemas
• Read existing JSON Schemas and validate JSON data

Below the article, we shall see each feature with a simple example.

Getting started

Create any .NET Core application

• Install Nuget package,

Install-Package NJsonSchema.CodeGeneration.CSharp -Version 10.1.2

OR

Please use below schema file to generate the classes. One can use schema or JSON files directly.

{
  "$schema": "http://json-schema.org/draft-04/schema#",
  "type": "object",
  "properties": {
    "ID": {
      "type": "string"
    },
    "Name": {
      "type": "string"
    },
    "City": {
      "type": "string"
    },
    "Country": {
      "type": "string"
    }
  },
  "required": [
    "ID",
    "Name",
    "City",
    "Country"
  ]
}

OR

Let’s use below sample Employee.json file,

  {
    "ID": "1002",
    "Name": "ABCD",
    "City": "city",
    "Country": "USA"
  }

One can write the below logic to generate classes from a given JSON request.

           string json = File.ReadAllText("Employee.json");
            var schemaFromFile = JsonSchema.FromSampleJson(json);
            var classGenerator = new CSharpGenerator(schemaFromFile, new CSharpGeneratorSettings
            {
                ClassStyle = CSharpClassStyle.Poco,
            });
            var codeFile = classGenerator.GenerateFile();
            File.WriteAllText("C://Test/Employee1.cs", codeFile);

The generated files will be saved in the path specified above.

Below is the file generated using the above code,

Note:

You might get the below error due to conflicts between Newtonsfot Vs NJSonschema classes.

Unable to cast object of type ‘Newtonsoft.Json.Schema.JsonSchema’ to type ‘NJsonSchema.JsonSchema’.

Please use the namespace as below to fix the issue,

using JsonSchema = NJsonSchema.JsonSchema;

Using Visual Studio to Generate Classes

Alternatively, Visual Studio has the “Paste Special” capability to create c# classes from JSON.

Visual Studio – -> Edit — > Paste Special

The generated class looks as below for the same Employee.json schema,

public class Rootobject
{
    public string ID { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
    public string Country { get; set; }
}

Above you need to change a root object to the appropriate name of your choice.

Happy Coding !!

Other useful references,

• Generate TypeScript code from JSON Schema
• Generate JSON Schema from JSON request or data file
• Generate JSON Schema from .NET classes/type via reflection

Summary

Today in this article, we looked at a few easy techniques for creating C# classes from a given JSON schema. We saw how to use the NJsonSchema CodeGeneration library and also looked at Visual Studio Paste special features to generate required C# types.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post How to Autogenerate C# Class using JSON or JSON Schema first appeared on TheCodeBuzz.

In this post, we will see how to configure DbContext in Entity framework EFCore in ASP.NET Core.

We will see high-level guidelines and best practices that can be considered in general for configuring the DBCOntext.

As we looked into our article on Repository implementation for Entity framework DbContext instance represents the Unit Of Work and Repository patterns that can be used to query from a database and perform CRUD operations.

We shall be covering the below aspects in today’s article,

Configuring DbContext in Entity Framework is important for establishing the connection and performing efficient CRUD operations on the datastore of your choice.

Configuring the Default Database provider

This shall be the first thing we will do while configuring the DBContext instance.

It should have DbContextOptions which actually help set up required DBContext details along with the database provider to use and connection string etc.

Please do the below configuration to set the DBContext option.

Use AdDbContext() method to inject the required DBContext injected in the Service IoC container as below,

Using DBContext class to use Constructor Injections for the DbContextOptions<TContext> object as below,

 public EmployeeContext(DbContextOptions<EmployeeContext> options)
            : base(options)
        {
        }

        public virtual DbSet<Employee> Employee { get; set; }



..
.

Similarly, If using the override OnConfiguring method then you can achieve the same by DBContextOptionsbuilder to initialize the DbContextOption as below,

Lifetime management of DBContext

Using DbContext with Dependency Injection,

• Using DbContext via a dependency injection container is recommended.

• This ensures DbContext is created as per request by the API pipeline and disposed of based on lifetime management used while registering it.

• Add the DbContext type to the service container by using the AddDbContext method with Scoped lifetime (Recommended ).

• Using AddDbContext(..) ensures that you are registering the DBCOntext as a scoped object. i.e every new request will use the services injected and hence the new DBContext.

 public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddDbContext<EmployeeContext>(options =>
            {
                options.UseSqlServer(Configuration.GetConnectionString("EmployeeDB"));
            });
        }

Using DbContext without Dependency Injection,

If not using DI due to some reason, It becomes the implementor’s responsibility to keep track of such resources and dispose of them manually instead of the compiler doing it for you (as we see above using DI).

If not using DI – then It’s recommended to use the “Using” statement for creating the resources and disposing of them after their usage.

 using (var context = new EmployeeContext())
            {
                empList = _employeeContext.Employee.AsEnumerable().Select(x => x.EmployeeId).ToList();
            }

Access DBContext in Repository or other Services

It’s better to keep the same lifetime instance for Repository/Other Custom services and DBContext to avoid any issue related to Data corruption.

Define Connection Resiliency for your DBContext

The connection resiliency feature retries defaulted database commands automatically.

Use connection resiliency as it just takes a few lines of code for making your connection resilient.

For more details: Database Connection Resiliency in Entity Framework ASP.NET Core

If dealing with multiple DBContext, then Connection resiliency needs to be defined per DBContext separately.

Concurrency of EFCore DBContext

DBContext object is not thread-safe.

Using AddDbContext(..) however, ensures that you are registering the DBContext as Scoped. i.e every new request will use the new service instance and hence the new DBContext.

So ideally concurrency is implemented per request basic avoiding any data corruption issues.

However, It should be protected from any parallel access within the same request context.

It’s the implementor’s responsibility to implement the concurrency while using it in Task/Multithreaded operations.

As good practice also please make sure to use Synchronous and Asynchronous operation properly in the code.

In the above code, I marked method a method call with await as it invokes an Asynchronous operation. For more details please refer Understanding Async vs Sync programming

Client-Server query evaluation

.NET Core 3.0 onwards Entity Framework Core has blocked client-side query evaluation and recommends query execution on the server only.

If using the older version(<3.0) of EF Core please let the developer know about query evaluation support. One can configure the below warning for the same,

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            if (optionsBuilder.IsConfigured)
            {
                optionsBuilder.UseSqlServer(sqlConnectionString,
                 builder => builder.EnableRetryOnFailure())
                 .ConfigureWarnings(warnings => warnings.Throw(RelationalEventId.QueryClientEvaluationWarning));

            }

Or the same can be configured within Configure method in the StartUp.cs

Other references :

• Connection Resiliency Using EnableRetry and Execution Strategy- PartI

• Getting Started with EFCore in ASP.NET Core

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

Today in this article we looked at guidelines around configuring the DBContext in Entity framework ASP.NET Core applications. We looked at various aspects like managing database providers, lifetime management, resiliency, and concurrency management while configuring the DBContext.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Configure DbContext in Entity framework ASP.NET Core – Best Practices first appeared on TheCodeBuzz.