C#•14mo ago•

9 replies

Tighter type constraint

Victor H · 2025-02-24T20:32:45.845Z

Hello. Let's say I have the following ```csharp public abstract class Aggregate where TId : AggregateId { public abstract TId { get; protected set; } } public abstract record AggregateId(Guid Value); ``` and then maybe I have concrete like: ```csharp public record OrderId(Guid Id) : AggregateId(Id); public class Order : Aggregate { public override OrderId Id { get; protected set; } } ``` I can do the following now for type-safety, i.e., that to get `Order` you must provide an `OrderId` and you can't mistakenly provide the wrong strongly typed ID: ```csharp public TAggregate LoadAggregate (TId aggregateId) where TAggregate : Aggregate where TId : AggregateId ``` However, this makes for quite a verbose API, is it possible somehow to constrain this so it is possible that `LoadAggregate (orderId)` is only valid if `orderId` is an `OrderId` and not say `ProductId`?

Hello.

Let's say I have the following

public abstract class Aggregate<TId> where TId : AggregateId
{
    public abstract TId { get; protected set; }
}

public abstract record AggregateId(Guid Value);

public abstract class Aggregate<TId> where TId : AggregateId
{
    public abstract TId { get; protected set; }
}

public abstract record AggregateId(Guid Value);

and then maybe I have concrete like:

public record OrderId(Guid Id) : AggregateId(Id);

public class Order : Aggregate<OrderId>
{
    public override OrderId Id { get; protected set; }
}

public record OrderId(Guid Id) : AggregateId(Id);

public class Order : Aggregate<OrderId>
{
    public override OrderId Id { get; protected set; }
}

I can do the following now for type-safety, i.e., that to get

Order

Order

you must provide an

OrderId

OrderId

and you can't mistakenly provide the wrong strongly typed ID:

public TAggregate LoadAggregate<TAggregate, TId>(TId aggregateId)
    where TAggregate : Aggregate<TId>
    where TId : AggregateId

public TAggregate LoadAggregate<TAggregate, TId>(TId aggregateId)
    where TAggregate : Aggregate<TId>
    where TId : AggregateId

However, this makes for quite a verbose API, is it possible somehow to constrain this so it is possible that

LoadAggregate<Order>(orderId)

LoadAggregate<Order>(orderId)

is only valid if

orderId

orderId

is an

OrderId

OrderId

and not say

ProductId

ProductId

C#•14mo ago•

9 replies

Victor H

Tighter type constraint

Hello.

Let's say I have the following

public abstract class Aggregate<TId> where TId : AggregateId
{
    public abstract TId { get; protected set; }
}

public abstract record AggregateId(Guid Value);

public abstract class Aggregate<TId> where TId : AggregateId
{
    public abstract TId { get; protected set; }
}

public abstract record AggregateId(Guid Value);

and then maybe I have concrete like:

public record OrderId(Guid Id) : AggregateId(Id);

public class Order : Aggregate<OrderId>
{
    public override OrderId Id { get; protected set; }
}

public record OrderId(Guid Id) : AggregateId(Id);

public class Order : Aggregate<OrderId>
{
    public override OrderId Id { get; protected set; }
}

I can do the following now for type-safety, i.e., that to get

Order

Order

you must provide an

OrderId

OrderId

and you can't mistakenly provide the wrong strongly typed ID:

public TAggregate LoadAggregate<TAggregate, TId>(TId aggregateId)
    where TAggregate : Aggregate<TId>
    where TId : AggregateId

public TAggregate LoadAggregate<TAggregate, TId>(TId aggregateId)
    where TAggregate : Aggregate<TId>
    where TId : AggregateId

However, this makes for quite a verbose API, is it possible somehow to constrain this so it is possible that

LoadAggregate<Order>(orderId)

LoadAggregate<Order>(orderId)

is only valid if

orderId

orderId

is an

OrderId

OrderId

and not say

ProductId

ProductId

Tighter type constraint

Similar Threads

Tighter type constraint

Similar Threads

Similar Threads

Similar Threads