Myth.Specification 3.0.4-preview.16

Myth.Specification

It is a .NET library for constructing queries in a very readable way, keeping the business rules in mind.

⭐ Features

• Easy readability
• Easy writing
• Business rules ahead
• Simplified use

🔮 Usage

To use, the following pattern must be followed:

var spec = SpecBuilder<Entity>
	.Create()
	.And(...)
	.Or(...)
	.Not()
  ...

The main idea is that every bit of your filter is built with the business rule in mind.

Suppose I have a Person table and I need to filter people with a female gender identity, who are from generation Z and who live in city X.

To do this, I should create a static class with the creation of each part of this filter, as follows:

public static class PersonSpecifications {
	public static ISpec<Person> IsGenerationX(this ISpec<Person> spec) {
		return spec.And(person => person.Birthdate.Year >= 2000);
	}

	public static ISpec<Person> IsIdentifiedAsFemale(this ISpec<Person> spec) {
		return spec.And(person => person.Gender == "female");
	}

	public static ISpec<Person> LivesOnCity(this ISpec<Person> spec, string city) {
		return spec.And(person => person.Address.City == city);
	}
}

And then when building my filter, search:

public class PersonService {
	private IPersonRepository _personRepository;

  ...

	public IEnumerable<Person> GetFemalePersonsOfGenerationXOfCityAsync( string city, CancellationToken cancellationToken ) {
		var spec = SpecBuilder<Person>
			.Create()
			.IsGenerationX()
			.IsIdentifiedAsFemale()
			.LivesOnCity(city);

		var result = _repository.SearchAsync(spec, cancellationToken);

		return result;
  }
}

So it's very clear that I'm looking for people with a female gender identity, from generation X and who live in the city I'm looking for.

🪄 Specifications

Specifications can be of three types and worked individually or in groups.

Applying all types can be done as follows:

var enumerable = Enumerable.Empty<Person>();

var spec = SpecBuilder<Person>
	.Create()
	.And(x => x.PersonId != null)
	.Distinct()
	.Order(x => x.Name)
	.Order(x => x.Address)
	.Skip(10)
	.Take(10);

var result = enumerable
	.Specify(spec)
	.ToList();

🔽 Filters

Filters can be applied directly as follows:

var enumerable = Enumerable.Empty<Person>();

var spec = SpecBuilder<Person>
	.Create()
	.And(x => x.PersonId != null);

var result = enumerable
	.Filter(spec)
	.ToList();

The following filters are available:

• And
• AndIf
• Or
• OrIf
• Not

⬇️ Ordering

Ordering can be applied directly as follows:

var enumerable = Enumerable.Empty<Person>();

var spec = SpecBuilder<Person>
	.Create()
	.Order(x => x.Name);

var result = enumerable
	.Sort(spec)
	.ToList();

The following orderings are available:

• Order
• OrderDescending

• 📃 Pagination and post processing

Paginations and post processing can be applied directly as follows:

var enumerable = Enumerable.Empty<Person>();

var spec = SpecBuilder<Person>
	.Create()
	.DistinctBy(x => x.Name)
	.Skip(10)
	.Take(10);

var result = enumerable
	.Paginate(spec)
	.ToList();

The following functions are available:

• Skip
• Take
• DistinctBy
• WithPagination - Convenient method using Pagination value object

WithPagination

You can also use the convenient WithPagination method that accepts a Pagination value object from Myth.Commons:

using Myth.ValueObjects;

var enumerable = Enumerable.Empty<Person>();
var pagination = new Pagination(2, 10); // Page 2, 10 items per page

var spec = SpecBuilder<Person>
	.Create()
	.And(x => x.PersonId != null)
	.Order(x => x.Name)
	.WithPagination(pagination);

var result = enumerable
	.Specify(spec)
	.ToList();

This replaces the manual calculation:

// Instead of:
.Skip((pagination.PageNumber - 1) * pagination.PageSize)
.Take(pagination.PageSize)

// Use:
.WithPagination(pagination)

Special cases:

• Pagination.All (-1, -1): Returns all items without pagination
• PageNumber <= 0: Treated as page 1
• PageSize <= 0: Returns all items without pagination

Combining with Skip/Take: You can still combine WithPagination with additional Skip and Take operations:

var spec = SpecBuilder<Person>
	.Create()
	.WithPagination(pagination)  // Skip 10, Take 10 (page 2)
	.Skip(5)                     // Skip 5 more
	.Take(3);                    // Limit to 3 items total