.NET Разработчик

public class RepositoryLoggerDecorator<T> : IRepository<T>
{
  private readonly IRepository<T> _decoratedRepo;
  public RepositoryLoggerDecorator(
   IRepository<T> decoratedRepo)
  {
    _decoratedRepo = decoratedRepo;
  }
  public IEnumerable<T> GetAll()
  {
     Console.WriteLine("Retrieved list of users");
     return _decoratedRepo.GetAll();
  }
}

builder.Services
 .Decorate<IRepository<User>, 
   RepositoryLoggerDecorator<User>>();

builder.Services.Scan(s => s
  .FromCallingAssembly()
  .AddClasses(c =>
   с.InNamespaces("MyApp.Services"))
  .AsImplementedInterfaces()
);

builder.Services.Scan(s => s
  .FromAssemblyOf<ICustomerService>()
  .AddClasses(c =>
   c.AssignableTo<ICustomerService>())
  .AsMatchingInterface());

…
.AddClasses(c => 
 c.AssignableTo(typeof(IService<>)))
…

builder.Services.Scan(s => s
  …
  .WithTransientLifetime()
);

builder.Services.Scan(s => s
  …
  .UsingRegistrationStrategy(RegistrationStrategy.Skip)
  .AsImplementedInterfaces()
);

3. Ответы
Возвращайте тип объекта

/v1/customers/:customer/payment_methods/:payment_method

{
  "id": "pm_123",
  "object": "payment_method",
  "created": 1672217299,
  "customer": "cus_123",
  …
}

if (response.Data.Object != "payment_method") 
{
  // не тот объект, который ожидался
  return;
}

https://api.example.com/v1/orders/9

card.pan = 4242424242424242;

card.number = 4242424242424242;

Subscription.canceled={true, false}

Subscription.canceled={true, false}
Subscription.paused={true, false}

Subscription.status={"active", "canceled"}

Subscription.status={"active", "canceled", "paused"}

customer.address = {
  line1: "Main Street 123",
  city: "San Francisco",
  postal_code: "12345"
};

customer.address_line1 = "Main street 123";
customer.address_city = "San Francisco";
customer.address_postal_code: "12345";

public class ApiClient : HttpClient
{
  private string _myField = "";
  public string MyProperty { get; set; }
  public ApiClient() 
  { 
    BaseAddress = new Uri("http://api.com"); 
  }
  public string MyMethod()
   => "hello";
}

public struct GeoLocation
{
  private double _latitude;
  private double _longitude;
  public GeoLocation(double lat, double lng)
  {
    _latitude = lat;
    _longitude = lng;
  }
  public override string ToString()
   => $"(lat: {_latitude}, lon:{_longitude})";
}

// обычный
public record ApiData
{
  public int Id { get; init; }
}
// с позиционными параметрами
public record ApiData(int Id);

pg=# create table t1 as select 1 as id;
SELECT 1
pg=# select ctid, xmin, xmax, * from t1;
 ctid  | xmin  | xmax | id
-------+-------+------+----
 (0,1) | 47496 |    0 |  1
(1 row)

pg=# update t1 set id = id where id = 1;
UPDATE 1
pg=# select ctid, xmin, xmax, * from t1;
 ctid  | xmin  | xmax | id
-------+-------+------+----
 (0,2) | 47497 |    0 |  1
(1 row)

public class ApplicationDbContext : DbContext
{
  public override async Task<int> SaveChangesAsync(
    CancellationToken ct = default)
  {
    var result = await 
     base.SaveChangesAsync(ct);

    await PublishDomainEventsAsync();

    return result;
  }
}

private async Task PublishDomainEventsAsync()
{
  var events = ChangeTracker
   .Entries<Entity>()
   .Select(e => e.Entity)
   .SelectMany(ent =>
   {
     var evnts = ent.GetDomainEvents();
     ent.ClearDomainEvents();
     return evnts;
   })
   .ToList();

   foreach (var ev in events)
     await _mediator.Publish(ev);
}

public class CourseCompletedDomainEventHandler
 : INotificationHandler<CourseCompleted>
{
  private readonly IBus _bus;

  public CourseCompletedDomainEventHandler(IBus bus)
  {
    _bus = bus;
  }

  public async Task Handle(
   CourseCompleted de,
   CancellationToken ct)
  {
    await _bus.Publish(
     new CourseCompletedIntegrationEvent(de.CourseId),
     ct);
  }
}

using MediatR;
public interface IDomainEvent : INotification
{
}

public class CourseCompleted : IDomainEvent
{
  public Guid CourseId { get; init; }
}

public abstract class Entity : IEntity
{
  private readonly List<IDomainEvent> 
   _events = new();

  public IReadOnlyList<IDomainEvent> 
   GetDomainEvents() => _events.ToList();
  
  public void ClearDomainEvents()
   => _events.Clear();

  protected void RaiseDomainEvent(
   IDomainEvent domainEvent)
   => _events.Add(domainEvent);
}

public class Course : Entity
{
  public Guid Id { get; private set; }
  public CourseStatus Status { get; private set; }
  public DateTime? Completed { get; private set; }

  public void Complete()
  {
    Status = CourseStatus.Completed;
    Completed = DateTime.UtcNow;

    RaiseDomainEvent(
     new CourseCompleted { 
      CourseId = this.Id 
    });
  }
}

public class BasicTests :
 IClassFixture<WebApplicationFactory<Program>>
{
  private WebApplicationFactory<Program> factory;
  public BasicTests(
   WebApplicationFactory<Program> f) 
   => factory = f;

  [Fact]
  public async Task GetRequest()
  {
    var mf = factory.Services
     .GetRequiredService<IMeterFactory>();
    var col = new MetricCollector<double>(
     mf, 
     "Microsoft.AspNetCore.Hosting", 
     "http-server-request-duration"
    );
    var cl = factory.CreateClient();

    var resp = await cl.GetAsync("/");

    Assert.Equal("Hello World!", 
     await resp.Content.ReadAsStringAsync());

    await col.WaitForMeasurementsAsync(
     minCount: 1);
    Assert.Collection(col.GetMeasurementSnapshot(),
     m => {
      Assert.Equal("http", m.Tags["scheme"]);
      Assert.Equal("GET", m.Tags["method"]);
      Assert.Equal("/", m.Tags["route"]);
    });
  }
}

// Создание продукта
POST /v1/products

// Обновление продукта
POST /v1/products/:id

// Получение продукта
GET /v1/products/:id

// Получаем список продуктов
GET /v1/products

// Запрос
POST /v1/customers 
{ "name": "John Watson",
  "email": "[email protected]",
  "address": "221B Baker Street" }

// Ответ
{
  "id": "cus_123",
  "object": "customer",
  "name": "John Watson",
  "email": "[email protected]",
  "address": "221B Baker Street"
}

// Запрос
POST /v1/customers/cus_123 
{ "address": "London SW1A 1AA" }

// Ответ
{
  "id": "cus_123",
  "object": "customer",
  "name": undefined,
  "email": undefined,
  "address": "London SW1A 1AA"
}