Back to: ASP.NET Core Tutorials For Beginners and Professionals
Eager Loading in Entity Framework Core (EF Core)
In this article, I am going to discuss Eager Loading in Entity Framework Core (EF Core) with Examples. Please read our previous article, where we discussed LINQ to Entities Queries in EF Core. At the end of this article, you will learn how to load the entities eagerly. You will also learn how to Eager Loading from multiple Levels and multiple Tables with Examples. We will work with the same example we have worked on so far.
Eager Loading in EF Core
Eager loading in Entity Framework Core is a technique used to load related entities along with the main entity in a single query. This helps to reduce the number of database queries and improve performance by retrieving all necessary data in one go. Eager loading is especially useful when you want to access properties of related entities without triggering additional database requests. EF Core provides the Include method and the ThenInclude method to enable the eager loading of related entities.
Examples to Understand Eager Loading in EF Core
Now, in order to understand Eager Loading in Entity Framework Core, we need multiple database tables. So, we are going to add some new database tables as well as going to update the existing database table.
Entities:
We are going to use the following Entities in our example. We will update the Student and Standard Entities while we will add the rest.
Student.cs
namespace EFCoreCodeFirstDemo.Entities
{
public class Student
{
public int StudentId { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public int? StandardId { get; set; }
public virtual Standard? Standard { get; set; }
public virtual StudentAddress? StudentAddress { get; set; }
public virtual ICollection<Course> Courses { get; set; } = new List<Course>();
}
}
Standard.cs
namespace EFCoreCodeFirstDemo.Entities
{
public class Standard
{
public int StandardId { get; set; }
public string? StandardName { get; set; }
public string? Description { get; set; }
public virtual ICollection<Student> Students { get; set; } = new List<Student>();
public virtual ICollection<Teacher> Teachers { get; set; } = new List<Teacher>();
}
}
StudentAddress.cs
namespace EFCoreCodeFirstDemo.Entities
{
public class StudentAddress
{
public int StudentId { get; set; }
public string? Address1 { get; set; }
public string? Address2 { get; set; }
public string? Mobile { get; set; }
public string? Email { get; set; }
public virtual Student Student { get; set; } = null!;
}
}
Course.cs
namespace EFCoreCodeFirstDemo.Entities
{
public class Course
{
public int CourseId { get; set; }
public string? CourseName { get; set; }
public int? TeacherId { get; set; }
public virtual Teacher? Teacher { get; set; }
public virtual ICollection<Student> Students { get; set; } = new List<Student>();
}
}
Teacher.cs
namespace EFCoreCodeFirstDemo.Entities
{
public class Teacher
{
public int TeacherId { get; set; }
public string? FirstName { get; set; }
public string? LastName { get; set; }
public int? StandardId { get; set; }
public virtual ICollection<Course> Courses { get; set; } = new List<Course>();
public virtual Standard? Standard { get; set; }
}
}
Modifying the Context Class:
Modify the EFCoreDbContext class as follows:
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
namespace EFCoreCodeFirstDemo.Entities
{
public class EFCoreDbContext : DbContext
{
//Constructor calling the Base DbContext Class Constructor
public EFCoreDbContext() : base()
{
}
//OnConfiguring() method is used to select and configure the data source
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
//To Display the Generated the Database Script
optionsBuilder.LogTo(Console.WriteLine, LogLevel.Information);
//Configuring the Connection String
optionsBuilder.UseSqlServer(@"Server=LAPTOP-6P5NK25R\SQLSERVER2022DEV;Database=EFCoreDB1;Trusted_Connection=True;TrustServerCertificate=True;");
}
//OnModelCreating() method is used to configure the model using ModelBuilder Fluent API
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
//Use this to configure the model using Fluent API
}
//Adding Domain Classes as DbSet Properties
public virtual DbSet<Course> Courses { get; set; }
public virtual DbSet<Standard> Standards { get; set; }
public virtual DbSet<Student> Students { get; set; }
public virtual DbSet<StudentAddress> StudentAddresses { get; set; }
public virtual DbSet<Teacher> Teachers { get; set; }
}
}
Note: As we already discussed, whenever we add or update domain classes or configurations, we need to sync the database with the model using add-migration and update-database commands using Package Manager Console or .NET Core CLI.
In Visual Studio, open NuGet Package Manager Console. To launch Package Manager Console, select Tools => NuGet Package Manager => Package Manager Console from the menu below.
This will open the Package Manager Console. Now type the add-migration CreateEFCoreDB2 command, select the project where your Context class is, and press the enter button, as shown in the image below.
You will get the following message once the above command is executed successfully.
We are getting one warning which says an operation was scaffolded that may result in the loss of data. Please review the migration for accuracy. So, basically, he is saying that before updating the database, please review the migration because there might be some data loss. You can ignore this at this moment.
Once this command is executed successfully, then you will see that another migration class file will be created with the current date and time along with the name you provided in the migration command, and you can see this class file within the Migrations folder as shown in the below image.
Don’t think the database is created after creating the migration file using the add-migration command. We still need to update the database using the Update-Database command. We can use the –verbose option to view the SQL statements being applied to the target database. So, open Package Manager Console and execute the Update-Database –verbose command, as shown in the image below.
Once the above script is executed successfully, you can verify the database table using SSMS, as shown in the image below.
Eager Loading in EF Core:
So, in order to understand Eager Loading in EF Core, we need to have some data in the database table. So, please execute the following SQL Script to insert some dummy data into the respective database tables using SSMS.
-- Use EFCoreDB1
USE EFCoreDB1;
GO
-- Standards table data
INSERT INTO Standards VALUES('STD1', 'Outstanding');
INSERT INTO Standards VALUES('STD2', 'Good');
INSERT INTO Standards VALUES('STD3', 'Average');
INSERT INTO Standards VALUES('STD4', 'Below Average');
GO
-- Teachers table data
INSERT INTO Teachers VALUES('Anurag', 'Mohanty', 1);
INSERT INTO Teachers VALUES('Preety', 'Tiwary', 2);
INSERT INTO Teachers VALUES('Priyanka', 'Dewangan', 3);
INSERT INTO Teachers VALUES('Sambit', 'Satapathy', 3);
INSERT INTO Teachers VALUES('Hina', 'Sharma', 2);
INSERT INTO Teachers VALUES('Sushanta', 'Jena', 1);
GO
-- Courses table data
INSERT INTO Courses VALUES('.NET', 1);
INSERT INTO Courses VALUES('Java', 2);
INSERT INTO Courses VALUES('PHP', 3);
INSERT INTO Courses VALUES('Oracle', 4);
INSERT INTO Courses VALUES('Android', 5);
INSERT INTO Courses VALUES('Python', 6);
GO
-- Students table data
INSERT INTO Students VALUES('Pranaya', 'Rout', 1);
INSERT INTO Students VALUES('Prateek', 'Sahu', 2);
INSERT INTO Students VALUES('Anurag', 'Mohanty', 3);
INSERT INTO Students VALUES('Hina', 'Sharma', 4);
GO
-- StudentAddresses table data
INSERT INTO StudentAddresses VALUES(1, 'Lane1', 'Lane2', '1111111111', '1@dotnettutorials.net');
INSERT INTO StudentAddresses VALUES(2, 'Lane3', 'Lane4', '2222222222', '2@dotnettutorials.net');
INSERT INTO StudentAddresses VALUES(3, 'Lane5', 'Lane6', '3333333333', '3@dotnettutorials.net');
INSERT INTO StudentAddresses VALUES(4, 'Lane7', 'Lane8', '4444444444', '4@dotnettutorials.net');
GO
-- StudentCourse table data
INSERT INTO CourseStudent VALUES(1,1);
INSERT INTO CourseStudent VALUES(2,1);
INSERT INTO CourseStudent VALUES(3,2);
INSERT INTO CourseStudent VALUES(4,2);
INSERT INTO CourseStudent VALUES(1,3);
INSERT INTO CourseStudent VALUES(6,3);
INSERT INTO CourseStudent VALUES(5,4);
INSERT INTO CourseStudent VALUES(6,4);
GO
How many ways can we load the Related Entities in Entity Framework Core?
In Entity Framework Core, we can load the related entities in three ways. They are Eager Loading, Lazy Loading, and Explicit Loading. All these three terms, i.e., Eager Loading, Lazy Loading, and Explicit Loading, are referring to the process of loading the related entities. They define when to load the related entities or child entities.
First of all, we need to understand what is related or child entities in the Entity Framework Core. For a better understanding, please have a look at the following Student Entity. Inside this Student Entity, you can see we are having three navigation properties, i.e., Standard, StudentAddress as Reference Navigation Property, and Courses as Collection Navigation Property. These Navigation properties are nothing but pointing to some other Entities. So, related entities are only entities created using Foreign Keys. These other entities are nothing the related entities of the Student Entity.
Now, when we are loading the Student entity, i.e., retrieving the data from the Student database table, how can we retrieve the related entities Standard, StudentAddress, and Courses? We can load these related entities in three ways while retrieving the Student entity. They are Eager Loading, Lazy Loading, and Explicit Loading. In this article, we will discuss Eager Loading in detail, and in our next two articles, we are going to discuss Lazy Loading and Explicit Loading with Examples.
What is Eager Loading in Entity Framework Core?
Eager loading is a Process where Entity Framework Core loads the related entities along with the main entity. Entity Framework will not execute separate SQL queries to load the related entities in this case. So, all the entities are loaded from the database with a single query, saving bandwidth and server CPU time. Entity Framework uses JOINs to load the related entities.
How to Implement Eager Loading in EF Core?
Entity Framework Core supports eager loading of related entities, same as EF 6, using the Include() extension method and projection query. In addition to this, it also provides the ThenInclude() extension method to load multiple levels of related entities. (EF 6 does not support the ThenInclude() method.)
Example to Understand Eager Loading in EF Core:
What our requirement is, when loading the Students entities, we also need to eager-load the corresponding Standards entities. The students and their Standards will be retrieved in a single query using the SQL join.
In the following example, we are fetching all the students from the Student database table along with its standards using the DbSet Include() method. Unlike EF 6, we can specify a lambda expression as a parameter in the Include() method to specify a navigation property, as shown in the below example. To use the Include method, we need to import Microsoft.EntityFrameworkCore namespace. In the below example, I am showing how to specify the related entity name using string name as well as using lambda expression using both Method and Query syntax.
using EFCoreCodeFirstDemo.Entities;
using Microsoft.EntityFrameworkCore;
namespace EFCoreCodeFirstDemo
{
internal class Program
{
static void Main(string[] args)
{
try
{
var context = new EFCoreDbContext();
//Loading Related Entities using Eager Loading
//While Loading the Student table data, it also load the Standard table data
//Eager Loading using Method Syntax
//Specifying the Related Entity Name using Lambda Expression
var students = context.Students
.Include(std => std.Standard)
.ToList();
//Specifying the Related Entity Name using String Name
//var students = context.Students
// .Include("Standard")
// .ToList();
//Eager Loading using Query Syntax
//Specifying the Related Entity Name using Lambda Expression
//var students = (from s in context.Students.Include(std => std.Standard)
// select s).ToList();
//Specifying the Related Entity Name using Lambda Expression
//var students = (from s in context.Students.Include("Standard")
// select s).ToList();
//Printing all the Student and Standard details
foreach (var student in students)
{
Console.WriteLine($"Firstname: {student.FirstName}, Lastname: {student.LastName}, StandardName: {student.Standard?.StandardName}, Description: {student.Standard?.Description}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}"); ;
}
}
}
}
Output:
As you can see in the above output, EF Core uses SQL Join to fetch the data.
Note: Using the Include() method with a lambda expression is recommended. This is because, with the Include method with a string name, we will get a runtime exception if the property name is misspelled or does not exist. So, always use the Include() method with the lambda expression to detect the error during compile time.
FromSql() Method in EF Core:
Using FromSql() Method in EF Core, we can specify the RAW T-SQL Statements which is going to be executed in the database. The Include() extension method in EF Core can also be used after the FromSql() method. For a better understanding, please have a look at the following example.
using EFCoreCodeFirstDemo.Entities;
using Microsoft.EntityFrameworkCore;
namespace EFCoreCodeFirstDemo
{
internal class Program
{
static void Main(string[] args)
{
try
{
var context = new EFCoreDbContext();
//Loading Related Entities using Eager Loading
//While Loading the Student Information, also load the related Standard data
//Create the SQL Statement using FormattableString object
FormattableString sql = $"Select * from Students WHERE FirstName = 'Pranaya'";
//Pass the FormattableString Object to the FromSql Method
var StudentWithStandard = context.Students
.FromSql(sql)
.Include(s => s.Standard) //Eager Load the Related Standard data
.FirstOrDefault();
//Printing the Student and Standard details
Console.WriteLine($"Firstname: {StudentWithStandard?.FirstName}, Lastname: {StudentWithStandard?.LastName}, " +
$"StandardName: {StudentWithStandard?.Standard?.StandardName}, Description: {StudentWithStandard?.Standard?.Description}");
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}"); ;
}
}
}
}
Output:
How to Load Multiple Related Entities Using Include Method in EF Core?
If you look at the Student Entity, you will see that the Student Entity Has three related entities as Standard, StudentAddress as Reference Navigational Entities, and Courses as Collection Navigation Entity, as shown in the image below.
Our requirement is to load the Standard, StudentAddreess, and Courses Entities while loading the Student Entity. Is it possible in Entity Framework Core? Yes, it is possible. We can eagerly load multiple related entities using the Include method multiple times in Entity Framework Core.
So, we need to use the Include() method multiple times to load multiple navigation properties of the same entity. In the below example, we eagerly load the Student, Standard, StudentAddress, and Courses entities while loading the Student Entity.
using EFCoreCodeFirstDemo.Entities;
using Microsoft.EntityFrameworkCore;
namespace EFCoreCodeFirstDemo
{
internal class Program
{
static void Main(string[] args)
{
try
{
var context = new EFCoreDbContext();
//Loading Related Entities using Eager Loading
//While Loading the Student table data, it is also going to load the Standard, StudentAddress and Courses tables data
//Eager Loading Multiple Entities using Method Synatx
var students = context.Students
.Include(x => x.Standard)
.Include(x => x.StudentAddress)
.Include(x => x.Courses)
.ToList();
//Eager Loading Multiple Entities using Query Synatx
//var students = (from s in context.Students
// .Include(x => x.Standard)
// .Include(x => x.StudentAddress)
// .Include(x => x.Courses)
// select s).ToList();
//Printing all the Student and Standard details
foreach (var student in students)
{
Console.WriteLine($"Student Name: {student.FirstName} {student.LastName}, StandardName: {student.Standard?.StandardName}, Address: {student.StudentAddress?.Address1}");
foreach (var course in student.Courses)
{
Console.WriteLine($"\tCourse ID: {course.CourseId} Course Name: {course.CourseName}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}"); ;
}
}
}
}
Now, run the application, and you should get the Student and all the related entities data as expected, as shown in the below image.
ThenInclude Method in EF Core:
It is also possible to eagerly load multiple levels of related entities in Entity Framework. Entity Framework Core introduced the new ThenInclude() extension method to load multiple levels of related entities.
So, first here, we need to understand what it means by multiple levels of related entities. If you go to the Student entity or Student class, then you will see that it includes one related entity called Standard, i.e., it includes it as a Navigation property. Now, if you go to the Standard entity or Standard class, then you will see that it includes one related entity called Teachers, i.e., the Standard Entity includes the Teachers entity as a collection navigation entity.
Now, what we want is, we want to load the Student, Standard, and Teacher entities. This is nothing but multiple levels of related entities. For a better understanding, please have a look at the following example.
using EFCoreCodeFirstDemo.Entities;
using Microsoft.EntityFrameworkCore;
namespace EFCoreCodeFirstDemo
{
internal class Program
{
static void Main(string[] args)
{
try
{
var context = new EFCoreDbContext();
//Loading Related Entities using Eager Loading
//While Loading the Student table data, it is also going to load the Standard, StudentAddress and Courses tables data
//Method Synatx
var student = context.Students.Where(s => s.FirstName == "Pranaya")
.Include(s => s.Standard)
.ThenInclude(std => std.Teachers)
.FirstOrDefault();
Console.WriteLine($"Firstname: {student?.FirstName}, Lastname: {student?.LastName}, StandardName: {student?.Standard?.StandardName}, Description: {student?.Standard?.Description}");
if(student?.Standard != null)
{
//You can also access the Teacher collection here
foreach (var teacher in student.Standard.Teachers)
{
Console.WriteLine($"\tTeacher ID: {teacher.TeacherId}, Name: {teacher.FirstName} {teacher.LastName}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}"); ;
}
}
}
}
Output:
Projection Query in EF Core:
We can also load multiple related entities by using the projection query instead of the Include() or ThenInclude() methods. The following example demonstrates the projection query to load the Student, Standard, and Teacher entities. In the below example, the Select extension method is used to include the Student, Standard, and Teacher entities in the result. This will execute the same SQL query as ThenInclude() method.
using EFCoreCodeFirstDemo.Entities;
using Microsoft.EntityFrameworkCore;
namespace EFCoreCodeFirstDemo
{
internal class Program
{
static void Main(string[] args)
{
try
{
var context = new EFCoreDbContext();
//Loading Related Entities using Eager Loading
//While Loading the Student table data, it is also going to load the Standard, StudentAddress and Courses tables data
var teachers = new List<Teacher>();
var std = context.Students.Where(s => s.FirstName == "Pranaya")
.Select(s => new
{
Student = s,
Standard = s.Standard,
Teachers = (s.Standard != null)? s.Standard.Teachers : teachers
})
.FirstOrDefault();
Console.WriteLine($"Firstname: {std?.Student?.FirstName}, Lastname: {std?.Student?.LastName}, StandardName: {std?.Student?.Standard?.StandardName}, Description: {std?.Student?.Standard?.Description}");
if(std?.Student?.Standard != null)
{
//You can also access the Teacher collection here
foreach (var teacher in std.Student.Standard.Teachers)
{
Console.WriteLine($"\tTeacher ID: {teacher.TeacherId}, Name: {teacher.FirstName} {teacher.LastName}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}"); ;
}
}
}
}
Output:
Advantages of using Eager Loading in EF Core
Eager loading in Entity Framework Core provides several advantages that can lead to improved performance and more efficient use of database resources. Here are some of the key advantages of using eager loading:
- Reduced Database Round-Trips: Eager loading allows you to retrieve related data in a single query, reducing the number of round-trips between your application and the database. This can significantly improve performance, especially when dealing with complex object graphs or large datasets.
- Improved Performance: By retrieving all necessary data in a single query, eager loading can lead to faster execution times and lower latency compared to lazy loading (where related data is fetched on demand).
- Consistent Data Access Patterns: Eager loading ensures that all related data is loaded upfront, providing a consistent and predictable data access pattern. This can lead to more efficient use of memory and fewer unexpected queries triggered during runtime.
- Avoiding the N+1 Query Problem: Eager loading helps mitigate the “N+1 query problem,” where lazy loading can result in N+1 database queries when iterating over a collection of entities. Eager loading reduces this overhead by fetching all related data in a single query.
- Simplified Code: Eager loading can simplify your code by allowing you to access related properties and collections directly without worrying about triggering additional database queries. This can lead to cleaner and more maintainable code.
- Optimal Use of Database Resources: Eager loading enables the database to optimize query execution plans, potentially resulting in better utilization of indexes and caching mechanisms.
- Better Performance for Complex Queries: When you need to perform queries involving multiple levels of related data, eager loading can help maintain reasonable query complexity and execution time.
- Enhanced User Experience: Faster data retrieval times through eager loading can lead to a more responsive and pleasant user experience, particularly in applications that display data to end users.
-
Reduced Risk of Timing Issues: Eager loading eliminates the possibility of lazy loading causing timing-related issues, where related data might be loaded at unexpected moments, affecting application behavior.
Disadvantages of using Eager Loading in EF Core
While eager loading in Entity Framework Core offers several advantages, it also comes with certain disadvantages and potential drawbacks that you should be aware of. Here are some of the key disadvantages of using eager loading:
- Over-Fetching of Data: Eager loading can lead to over-fetching of data, where you retrieve more data than is actually needed for a specific operation. This can result in larger query results and increased memory usage, which may negatively impact performance.
- Performance Impact for Large Data Sets: Eager loading can become inefficient when dealing with large data sets or deeply nested object graphs. Retrieving all related data in a single query might cause performance issues, especially if the data is not used immediately.
- Complex Queries: Eager loading can result in complex and potentially inefficient SQL queries, especially when you’re eager to load multiple levels of related entities. This can affect database performance and query execution time.
- Increased Initial Query Time: Eager loading can lead to increased initial query execution time, especially if the query needs to join multiple tables or retrieve significant data. This can impact the perceived responsiveness of your application.
- Inflexible Loading Strategy: Eager loading forces you to load all related data upfront, which might not be suitable for all scenarios. In cases where you only need a subset of related data, eager loading can lead to unnecessary data retrieval.
- Maintenance Overhead: As your application evolves, changes to your data access patterns or requirements may require adjustments to eager loading configurations. This can introduce maintenance overhead, especially in complex object graphs.
- Potential for Data Duplication: Eager loading can lead to data duplication when multiple related entities are loaded, causing redundancy and potential data consistency issues.
- Increased Complexity: While eager loading can simplify code in some cases, it can also introduce complexity by pulling in more data than necessary. Developers need to manage and optimize eager loading configurations carefully.
- Limited Control Over Query Optimization: Eager loading may limit your ability to fine-tune and optimize individual SQL queries, as EF Core generates the queries automatically based on your eager loading configuration.
- Impact on Serialization: Eager loading can affect serialization and deserialization performance, especially when transferring data between different layers or components of your application.
-
Cascading Load: Eager loading can lead to cascading loading of related data, where each related entity’s data triggers additional data loading. This can lead to unexpected and unintended data retrieval.
When to use Eager Loading in EF Core?
Eager loading in Entity Framework Core can be beneficial in various scenarios, helping to optimize performance and improve user experience. Here are some situations where using eager loading might be appropriate:
- Fetching Related Data for Display: When you know that you will need to access related data along with the main entity, you want to avoid additional database round-trips. This is common when displaying data to users, such as a list of authors and their books.
- Complex Queries: Eager loading can simplify queries involving multiple levels of related data, preventing the need for multiple separate queries. This is especially useful when dealing with deeply nested object graphs.
- Data-Heavy Operations: If the related data is relatively small and the number of entities is manageable, eager loading can be efficient. This can be the case when fetching configuration data, reference tables, or look-up data.
- Reporting: Eager loading can be useful for generating reports involving aggregations, calculations, or related data analysis. It can help ensure that the report can be generated with minimal database interaction.
- Read-Intensive Scenarios: In scenarios where your application reads data more frequently than it writes, eager loading can help improve performance by reducing the number of database queries.
- Batch Operations: If you need to perform batch operations on related data, eager loading can help fetch the required data in a single query rather than executing multiple queries for each item in the batch.
- Situations with Known Data Needs: When you clearly understand your application’s data needs and can confidently predict which related data will be accessed together.
-
Avoiding Lazy Loading Pitfalls: Eager loading can help avoid the N+1 query problem associated with lazy loading, which can occur when iterating over collections of entities.
However, it’s important to consider the following factors and potential pitfalls before deciding to use eager loading:
- Data Volume: Eager loading may lead to over-fetching of data, which can impact performance and memory usage, particularly for large data sets.
- Complexity: Deeply nested or complex object graphs can result in complex and potentially inefficient SQL queries.
- Maintenance: Changes to your data access patterns or requirements may require adjustments to eager loading configurations, which can introduce maintenance overhead.
- Flexibility: Eager loading forces you to load all related data upfront, which may not be suitable for all scenarios.
-
Performance Testing: Consider conducting performance tests and profiling to ensure that eager loading is actually improving performance in your specific use case.
Remember that while eager loading can improve performance by reducing database round-trips, it can also lead to over-fetching of data if not used carefully. You should consider your application’s specific use cases and performance requirements when deciding whether to use eager loading.
In the next article, I am going to discuss Lazy Loading in Entity Framework Core. In this article, I try to explain Eager Loading in Entity Framework Core with Examples, and I hope you enjoyed this Eager Loading in EF Core with Examples article. Please give your valuable feedback and suggestions about this article.
