Myth.Specification 3.0.0.1-preview

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