Home

Welcome to the EFCore.GenericRepository wiki!

Usage Guidelines: Queries

1. To get all the data:

var employeeList =  await _repository.GetListAsync<Employee>();

var noTrackedEmployeeList = await _repository.GetListAsync<Employee>(asNoTracking: true);

2. To get a filtered list of data:

var employeeList =  await _repository
                            .GetListAsync<Employee>(e => e.Name.Contains("Tanvir") && e.DepartmentName == "Software");

var noTrackedEmployeeList = await _repository
                            .GetListAsync<Employee>(e => e.Name.Contains("Tanvir") && e.DepartmentName == "Software", asNoTracking: true);

3. To get a list of data by Specification:

Specification<Employee> specification = new Specification<Employee>();
specification.Conditions.Add(e => e.Name.Contains("Tanvir"));
specification.Includes = ep => ep.Include(e => e.Department);
specification.OrderBy = sp => sp.OrderBy(e => e.Name).ThenBy(e => e.DepartmentName);
specification.Skip = 0;
specification.Take = 10;

List<Employee> employeeList = await _repository.GetListAsync<Employee>(specification);

List<Employee> noTrackedEmployeeList = await _repository.GetListAsync<Employee>(specification, true);

4. To get the projected entity list:

Expression<Func<Employee, EmployeeDto>> selectExpression = e => new EmployeeDto 
{
   Id = e.Id,
   Name = e.Name 
};
var projectedList = await _repository.GetListAsync<Employee, EmployeeDto>(selectExpression);

5. To get filtered projected entity list:

Expression<Func<Employee, EmployeeDto>> selectExpression = e => new EmployeeDto 
{
   Id = e.Id,
   Name = e.Name 
};
var filteredProjectedList = await _repository.GetListAsync<Employee, EmployeeDto>(e => e.IsActive, selectExpression);

6. To get the projected entity list by Specification<T>:

Specification<Employee> specification = new Specification<Employee>();
specification.Conditions.Add(e => e.Name.Contains("Tanvir"));
specification.Includes = ep => ep.Include(e => e.Department);
specification.OrderBy = sp => sp.OrderBy(e => e.Name).ThenBy(e => e.DepartmentName);
specification.Skip = 0;
specification.Take = 10;

Expression<Func<Employee, EmployeeDto>> selectExpression = e => new EmployeeDto 
{
   Id = e.Id,
   Name = e.Name 
};
var projectedList = await _repository.GetListAsync<Employee, EmployeeDto>(specification, selectExpression);

7. To get an entity by Id (primary key):

Employee employee = await _repository.GetByIdAsync<Employee>(1);

Employee noTrackedEmployee = await _repository.GetByIdAsync<Employee>(1, true);

8. To get a projected entity by Id (primary key):

Expression<Func<Employee, EmployeeDto>> selectExpression = e => new EmployeeDto 
{
   Id = e.Id,
   Name = e.Name
};
var projectedEntity = await _repository.GetByIdAsync<Employee, EmployeeDto>(1, selectExpression);

9. To get a single entity by any condition/filter:

Employee employee = await _repository.GetAsync<Employee>(e => e.Name == "Tanvir");

Employee noTrackedEmployee = await _repository.GetAsync<Employee>(e => e.Name == "Tanvir", true);

10. To get a single entity by Specification<T>:

Specification<Employee> specification = new Specification<Employee>();
specification.Conditions.Add(e => e.Name == "Tanvir");
specification.Includes = sp => sp.Include(e => e.Department);
specification.OrderBy = sp => sp.OrderBy(e => e.Salary);

Employee employee = await _repository.GetAsync<Employee>(specification);

Employee noTrackedEmployee = await _repository.GetAsync<Employee>(specification, true);

11. To get a single projected entity by any condition/filter:

Expression<Func<Employee, EmployeeDto>> selectExpression = e => new EmployeeDto 
{
   Id = e.Id,
   Name = e.Name
};
var projectedEntity = await _repository.GetAsync<Employee, EmployeeDto>(e => e.Name == "Tanvir", selectExpression);

12. To get a single projected entity by Specification<T>:

Specification<Employee> specification = new Specification<Employee>();
specification.Conditions.Add(e => e.Name == "Tanvir");
specification.Includes = sp => sp.Include(e => e.Department);
specification.OrderBy = sp => sp.OrderBy(e => e.Salary);

Expression<Func<Employee, object>> selectExpression = e => new { e.EmployeeId, e.EmployeeName };
var projectedEntity = await _repository.GetAsync<Employee, object>(specification, selectExpression);

13. To check if an entity exists:

bool isExists = await _repository.ExistsAsync<Employee>(e => e.EmployeeName == "Tanvir");

14. To get the count of entities with or without condition:

int count =   await _repository.GetCountAsync<Employee>(); // Count of all
int count =   await _repository.GetCountAsync<Employee>(e => e.EmployeeName = "Tanvir"); // Count with specified condtion

long longCount =   await _repository.GetLongCountAsync<Employee>(); // Long count of all
long longCount =   await _repository.GetLongCountAsync<Employee>(e => e.EmployeeName = "Tanvir"); // Long count with specified condtion

Usage Guidelines: Commands

1. To create or insert a new entity:

Employee employeeToBeCreated = new Employee()
{
   EmployeeName = "Tanvir",
   ..........
}

_repository.Add(employeeToBeCreated);
await _repository.SaveChangesAsync();

2. To create or insert a collection of new entities:

List<Employee> employeesToBeCreated = new List<Employee>()
{
   new Employee(){},
   new Employee(){},
}

_repository.Add(employeesToBeCreated);
await _repository.SaveChangesAsync();

3. To update or modify an entity:

Employee employeeToBeUpdated = new Employee()
{
   EmployeeId = 1,
   EmployeeName = "Tanvir",
   ..........
}

_repository.Update(employeeToBeUpdated);
await _repository.SaveChangesAsync();

4. To update or modify the collection of entities:

List<Employee> employeesToBeUpdated = new List<Employee>()
{
   new Employee(){},
   new Employee(){},
}

_repository.Update(employeesToBeUpdated);
await _repository.SaveChangesAsync();

5. To delete an entity:

Employee employeeToBeDeleted = new Employee()
{
    EmployeeId = 1,
    EmployeeName = "Tanvir",
   ..........
}

_repository.Remove(employeeToBeDeleted);
await _repository.SaveChangesAsync();

6. To delete a collection of entities:

List<Employee> employeesToBeDeleted = new List<Employee>()
{
   new Employee(){},
   new Employee(){},
}

_repository.Remove(employeesToBeDeleted);
await _repository.SaveChangesAsync();