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

[MyAttr(typeof(string))] 

public class MyAttr<T> : Attribute { } 
…
[MyAttr<string>] 

public class MyAttr<T> : Attribute { }

public class MyClass<T>
{
  [MyAttr<T>] // Ошибка компиляции
  public MyClass()
  {
  }
}

public bool Is_1_3_5(int[] numbers)
{
  return numbers is [1, 3, 5]; 
  // numbers должен быть длиной 3
  // и иметь элементы 1, 3 и 5
}

numbers is [1, _, 5]; 
// numbers должен быть длиной 3
// и иметь элементы 1, <любое целое число> и 5

numbers is [1, .., 5]; 
// numbers может быть любой длины
// должен начинаться с 1 и заканчиваться 5

numbers is [1, .., >=5]; 
// numbers может быть любой длины
// должен начинаться с 1 
// и заканчиваться числом не меньше 5

public class RequiredMember
{
  public required string Name { get; set; }
}

var requiredMember = new RequiredMember { Name = "Dave" };

public class RequiredMember
{
  public required string Name { get; set; }
  
  [SetsRequiredMembers]
  public RequiredMember(string name)
  {
    Name = name;
  }    
}

public struct AutoDefaultStruct
{
  public int Number { get; set; }
  public AutoDefaultStruct()
  {
    Number = 0;
  }
}

public class RawStringLiteral
{
  public static int MyNumber = 1;
 
  public string MyJsonString =
   $$"""
   {
     "number": "{{MyNumber}}"
   }
   """;            
}

using var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(5));

async Task IssueTimeoutAsync()
{
  using var cts = new CancellationTokenSource(
   TimeSpan.FromSeconds(5));
  
  var token = cts.Token;
  await Task.Delay(TimeSpan.FromSeconds(10), token);
}

void Rotate(
  IEnumerable<Matrix> matrices, 
  float degrees,
  CancellationToken ct)
{
  Parallel.ForEach(matrices,
   new ParallelOptions { CancellationToken = ct },
   m => m.Rotate(degrees));
}

IEnumerable<int> MultiplyBy2(
 IEnumerable<int> values,
 CancellationToken ct)
{
  return values.AsParallel()
    .WithCancellation(ct)
    .Select(item => item * 2);
}

public class Entity
{
  public int Id { get; set; }
  public DateTime CreatedAt { get; set; }
    = DateTime.UtcNow;
  public ICollection<Values> Values { get; set; }
    = new List<Values>();

  public Entity AddValue(string name, string value)
  {
    var existing = Values?.
      FirstOrDefault(v => v.Name.Equals(name));

    if (existing is { })
      existing.Value = value;
    else
      Values?.Add(
       new Values {Name = name, Value = value}
      );

    return this;
  }
}

public class Values
{
  public int Id { get; set; }
  public int EntityId { get; set; }
  public string Name { get; set; }
  public string Value { get; set; }
}

var invertedTable = new Entity()
  .AddValue("Name", "Dotnet")
  .AddValue("Status", "Awesome");

var invertedTable = db
  .EntityWithInvertedTables
  .OrderByDescending(o => o.CreatedAt)
  .Include(x => x.Values)
  .First();

…
  .Include(x => x.Values.Where(v => v.Name == "Name"))
  .First();

public class Entity
{
  public int Id { get; set; }
  public DateTime CreatedAt { get; set; }
   = DateTime.UtcNow;
  public Dictionary<string, string> 
   Values { get; set; } = new();
}

public class Database : DbContext
{
  public DbSet<Entity> Entity { get; set; }

  protected override void 
   OnModelCreating(ModelBuilder mb)
  {
    var opts = new JsonSerializerOptions(
     JsonSerializerDefaults.General);

    mb.Entity<Entity>()
      .Property(x => x.Values)
      .HasColumnName("Values")
      .HasColumnType("BLOB")
      .HasConversion(
       v => JsonSerializer.Serialize(v, options),
       s => JsonSerializer
         .Deserialize<Dictionary<string, string>>(s, options),
       ValueComparer.CreateDefault(
         typeof(Dictionary<string, string>), true)
      );
  }
}

var json = new Entity
{
  Values = new()
  {
    {"Name", "Dotnet"},
    {"Status", "Awesome"}
  }
};

public int Cancelable(CancellationToken ct)
{
  for (int i = 0; i != 100; ++i)
  {
    Thread.Sleep(1000); // вычисления
    ct.ThrowIfCancellationRequested();
  }
  return 42;
}

public int Cancelable(CancellationToken ct)
{
  for (int i = 0; i != 100000; ++i)
  {
    Thread.Sleep(1); // вычисления
    if (i % 1000 == 0)
      ct.ThrowIfCancellationRequested();
  }
  
  return 42;
}

using MassTransit;

foreach (var i in Enumerable.Range(0, 5))
{
  NewId id = NewId.Next();
  Console.WriteLine(id);
}

be170000-f32d-18db-de59-08da26f2ad5a
be170000-f32d-18db-1816-08da26f2ad5b
be170000-f32d-18db-8694-08da26f2ad5b
be170000-f32d-18db-4dbd-08da26f2ad5b
be170000-f32d-18db-65b3-08da26f2ad5c

NewId.SetProcessIdProvider(new CurrentProcessIdProvider());

[TestInitialize]
public async Task TestSetup()
{
  await Context.Tracing.StartAsync(
   new TracingStartOptions {
    Title = TestContext.TestName,
    Screenshots = true,
    Snapshots = true,
    Sources = true
   }
  );
}

[TestCleanup]
public async Task TestCleanup()
{
  await Context.Tracing.StopAsync(
   new TracingStopOptions {
    Path = TestContext.TestName + ".zip"
   }
  );
}

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
  </packageSources>
</configuration>