Facet 1.6.0

This is a new project, any help, feedback and contributions are highy appreciated.

Facet

"One part of a subject, situation, object that has many parts."

Facet is a C# source generator that lets you define lightweight projections (DTOs, API models, etc.) directly from your domain models — without writing boilerplate.

It generates partial classes or records with constructors, optional LINQ projections, and even supports custom mappings — all at compile time, with zero runtime cost.

• ✅ Generate classes or records from existing types
• ✅ Exclude fields/properties you don't want (basically create a Facetted view of your model))
• ✅ Include public fields (optional)
• ✅ Auto-generate constructors for fast mapping
• ✅ LINQ projection expressions (Expression<Func<TSource,TTarget>>)
• ✅ Custom mapping via IFacetMapConfiguration
• ✅ Use in EF Core queries by using Facet.Extensions

Quick Start

1. Install

dotnet add package Facet

2. Define facet

using Facet;

public class Person
{
    public string Name { get; set; }
    public string Email { get; set; }
    public int Age { get; set; }
}

// Generate a DTO that excludes Email
[Facet(typeof(Person), exclude: nameof(Person.Email))]
public partial class PersonDto;

This generates a PersonDto with only Name and Age, and a constructor that copies values.

3. Use your generated facets

var person = new Person { Name = "Alice", Email = "a@b.com", Age = 30 };
var dto = new PersonDto(person);

LINQ projection support:

var query = dbContext.People
    .Select(PersonDto.Projection)
    .ToList();

Advanced scenarios

Records

[Facet(typeof(Person), Kind = FacetKind.Record)]
public partial record PersonRecord;
`

Custom mapping

Eg. you need to compile extra fields

public class UserMapConfig : IFacetMapConfiguration<User, UserDto>
{
    public static void Map(User source, UserDto target)
    {
        target.FullName = $"{source.FirstName} {source.LastName}";
    }
}

[Facet(typeof(User), Configuration = typeof(UserMapConfig))]
public partial class UserDto;

This lets you add derived properties, formatting, etc.

Facet.Extensions for LINQ/EF Core async

Install Facet.Extensions for one-line mapping helpers:

dotnet add package Facet.Extensions

Then:

using Facet.Extensions;

// Single object
var dto = person.ToFacet<Person, PersonDto>();

// Lists
var dtos = people.SelectFacets<Person, PersonDto>();

// IQueryable deferred projection
var query = dbContext.People.SelectFacet<Person, PersonDto>();

And with EF Core:

var dtos = await dbContext.People.ToFacetsAsync<Person, PersonDto>();

var single = await dbContext.People.FirstFacetAsync<Person, PersonDto>();

Facet - Define less, project more.