.NET Разработчик. Страница 5

var builder = WebApplication.CreateBuilder(args);
…
builder.Services.AddControllers();
builder.Services.AddOutputCache();
var app = builder.Build();
…
app.MapControllers();
app.UseOutputCache();
app.Run();

public IResult Get()
  => Results.Ok(Random.Shared.Next(100));

builder.Services.AddOutputCache(opt =>
{
  opt.AddBasePolicy(c =>
    c.Expire(TimeSpan.FromSeconds(5)));
  opt.AddPolicy("CacheTenSec", c =>
    c.Expire(TimeSpan.FromSeconds(10)));
});

[OutputCache(PolicyName="CacheTenSec")]

IHost host = GetTestClient();
var response = await host.GetAsync(…);
var body = await 
 response.Content.ReadAsStringAsync();

var expect = new[] {
  new {
    State = "Active",
    Count = 1
  }
}

var actual = JsonConvert
 .DeserializeAnonymousType(body, expect);

actual.Should().BeEquivalentTo(expect);

… 
var actual = JsonSerializer.Deserialize(
  body, 
  expect.GetType(), 
  new JsonSerializerOptions {
   PropertyNameCaseInsensitive = true
 });

actual.Should().BeEquivalentTo(expect);

public record OrderCreated(Guid OrderId) : INotification;

public class OrderCreatedHandler : 
 INotificationHandler<OrderCreated>
{
  private readonly INotificationService svc;

  public OrderCreatedHandler(
   INotificationService service)
  {
    svc = service;
  }

  public async Task Handle(
   OrderCreated notification,
   CancellationToken ct)
  {
    await svc.SendOrderCreatedEmail(
     notification.OrderId,
     ct);
  }
}

await publisher.Publish(
  new OrderCreated(order.Id), 
  cancellationToken);

public class ForeachAwaitPublisher 
 : INotificationPublisher
{
  public async Task Publish(
    IEnumerable<NotificationHandlerExecutor> executors,
    INotification notification,
    CancellationToken ct)
  {
    foreach (var e in executors)
    {
      await e
       .HandlerCallback(notification, ct)
       .ConfigureAwait(false);
    }
  }
}

var tasks = executors
  .Select(e =>
    e.HandlerCallback(notification, ct))
  .ToArray();
return Task.WhenAll(tasks);

services.AddMediatR(cfg => {
  …
  cfg.NotificationPublisher = 
   new TaskWhenAllPublisher();

  // или 
  cfg.NotificationPublisherType = 
   typeof(TaskWhenAllPublisher);
  cfg.ServiceLifetime = ServiceLifetime.Transient;
});

public class ReusableBuffer : IResettable
{
  public byte[] Data { get; } 
   = new byte[1024 * 1024]; // 1 MB

  public bool TryReset()
  {
    Array.Clear(Data);
    return true;
  }
}

var bufferPool = ObjectPool.Create<ReusableBuffer>();
var buffer = bufferPool.Get();
try
{
  await ProcessDataAsync(buffer.Data);
}
finally
{
  // Данные автоматически сбрасываются
  bufferPool.Return(buffer);
}

var builder = 
 WebApplication.CreateBuilder(args);
builder.WebHost
 .ConfigureKestrel(opts =>
{
  opts.ListenNamedPipe("MyPipeName");
});

var timer = new System.Threading.Timer(
  // обратный вызов может быть выполнен параллельно
  // если предыдущий ещё не завершился
  // до старта следующего
  callback: state => Console.WriteLine("tick"), 
  
  // Используется для передачи данных
  // в метод обратного вызова,
  // чтобы не использовать замыкание
  state: null, 

  // Начать немедленно
  dueTime: TimeSpan.Zero,    
       
  // Повторять каждую секунду
  period: TimeSpan.FromSeconds(1));

// Поставить таймер на паузу
timer.Change(
 dueTime: Timeout.Infinite,
 period: Timeout.Infinite);

var timer = new System.Timers.Timer(
 TimeSpan.FromSeconds(1));

// несколько обработчиков
timer.Elapsed += (sender, e) 
  => Console.WriteLine("Handler 1");
timer.Elapsed += (sender, e)
  => Console.WriteLine("Handler 2");

// Останавливаем после 1го выполнения
timer.AutoReset = false;

// Запускаем
timer.Start();

using var cts = 
 new CancellationTokenSource();
using var timer = 
 new PeriodicTimer(TimeSpan.FromSeconds(1));

while (
 await timer.WaitForNextTickAsync(cts.Token))
{
  Console.WriteLine("Tick");
  await AsyncOperation();
}

public class TrieNode
{
  public bool IsWord { get; set; }
  public Dictionary<char, TrieNode> 
   Children { get; } = new();
}

public class Trie
{
  private readonly TrieNode _root = new();

  public void AddWord(string word)
  {
    var node = _root;
    foreach (char c in word)
    {
      if (!node.Children.ContainsKey(c))
        node.Children[c] = new();
      node = node.Children[c];
    }
    node.IsWord = true;
  }

  public bool Search(string word)
  {
    var node = _root;
    foreach (char c in word)
    {
      if (!node.Children.ContainsKey(c))
        return false;
      node = node.Children[c];
    }
    return node.IsWord;
  }
}

var trie = new Trie();
var text = "The quick brown fox jumps over the lazy dog";
foreach (var word in text.Split(' '))
  trie.AddWord(word);

Console.WriteLine(trie.Search("quick"));

public void Should_Return_Domain(
 string email, string expectedDomain)
{
  var parser = new EmailParser();
  var domain = parser.GetDomain(email);
  Assert.Equal(domain, expectedDomain);
}

[Theory]
[InlineData("[email protected]", "test.com")]
[InlineData("[email protected]", "github.io")]
public void Should_Return_Domain(
 string email, string expectedDomain)
{ … }

[Theory]
[MemberData(nameof(EmailTestData))]
public void Should_Return_Domain(
 string email, string expectedDomain)
{ … }

public static IEnumerable<object[]> 
 EmailTestData => new List<object>
 {
   new object[] { "[email protected]", "test.com" },
   new object[] { "[email protected]", "github.io" }
 };

[Theory]
[ClassData(typeof(EmailTestData))]
public void Should_Return_Domain(
 string email, string expectedDomain)
{ … }

public class EmailTestData : IEnumerable<object[]>
{
  public IEnumerable<object[]> GetEnumerator()
  {
    yield return new object[] { 
     "[email protected]", "test.com" };
    yield return new object[] { 
     "[email protected]", "github.io" };
  }
    
  IEnumerator IEnumerable.GetEnumerator() 
   => GetEnumerator();
};

[Theory]
[ClassData(typeof(EmailTestData))]
public void Should_Return_Domain(
 string email, string expectedDomain)
{ … }

public class EmailTestData :
 TheoryData<string, string>
{
  public EmailTestData()
  {
    Add("[email protected]", "test.com");
    Add("[email protected]", "github.io");
  }
};

services.AddDbContext<CatalogDbContext>(opt =>
  opt.UseSqlServer(
    "CONNECTION_STRING",
    o => o.MigrationsHistoryTable(
      tableName: "efmigrations",
      schema: "catalog")));

services.AddDbContext<OrderDbContext>(opt =>
  opt.UseSqlServer(
    "CONNECTION_STRING",
    o => o.MigrationsHistoryTable(
      tableName: "efmigrations",
      schema: "order")));