Complex ideas.
Clean solutions.

if (!string.Equals(user.TenantId, tenant.Id, StringComparison.Ordinal))
{
    throw new UnauthorizedAccessException("The authenticated user does not belong to this tenant.");
}

tenantContext.TenantId = tenant.Id;
tenantContext.CurrentTenant = tenant;

if (target == WorkItemStatus.Done)
{
    Guard.Against(!allTasksDone,
        "Cannot complete UserStory until all linked Tasks are Done.");

    Guard.Against(!noOpenBugs,
        "Cannot complete UserStory while there are open Bugs.");

    Guard.Against(!allTestsPassed,
        "Cannot complete UserStory until all linked TestCases are Passed.");
}

var comment = await mediator.Send(
    new AddComment.Command {
        CreateCommentDto = createCommentDto
    });

await Clients.Group(createCommentDto.ActivityId)
    .SendAsync("ReceiveComment", comment.Value);

await using var tx = await _dbContext.Database.BeginTransactionAsync(cancellationToken);
try
{
    await action(cancellationToken);

    await _dbContext.SaveChangesAsync(cancellationToken);
    await tx.CommitAsync(cancellationToken);
}
catch
{
    await tx.RollbackAsync(cancellationToken);
    throw;
}

return await _dbContext.WorkItems
.AsNoTracking()
.Where(workItem =>
    workItem.Id == wId &&
    workItem.ProjectId == pId &&
    workItem.Project.TenantId == tId)
.Select(workItem =>
    workItem.Code + " - " + workItem.Title)
.FirstOrDefaultAsync(cancellationToken);

storedToken.RevokedAtUtc = DateTime.UtcNow;
storedToken.ReplacedByToken = newRefreshToken;

var newRefreshTokenEntity = new RefreshTokenEntity
{
    Token = newRefreshToken,
    UserId = user.Id,
    CreatedAtUtc = DateTime.UtcNow,
    ExpiresAtUtc = DateTime.UtcNow.AddDays(7)
};

_dbContext.RefreshTokens.Add(newRefreshTokenEntity);
await _dbContext.SaveChangesAsync(cancellationToken);

NormalizeSuggestion(workItemType, suggestion, summary);

if (!IsSuggestionUsable(workItemType, suggestion, out error))
    return false;

return true;

var oldRawValue =
    property.GetValue(oldObject)?.ToString();

var newRawValue =
    property.GetValue(newObject)?.ToString();

if (string.Equals(
        oldRawValue,
        newRawValue,
        StringComparison.Ordinal))
{
    continue;
}

await workItemsRepository
    .MoveIncompleteWorkItemsFromSprintToBacklogAsync(
        tenantId,
        sprint.Id,
        sprint.ProjectId,
        transactionCancellationToken);

sprint.Complete();

public static PatchStringDecision DecideStringPatch(string? input)
{
    return input is null
        ? new PatchStringDecision(PatchStringAction.Ignore, null)
        : string.IsNullOrWhiteSpace(input)
        ? new PatchStringDecision(PatchStringAction.Clear, null)
        : new PatchStringDecision(PatchStringAction.Set, input.Trim());
}

var recipientUserIds = notification.TeamMembers
    .Select(m => m.Id)
    .Where(id => !string.IsNullOrWhiteSpace(id))
    .Distinct()
    .ToList();

using var timer = new PeriodicTimer(CheckInterval);

while (await timer.WaitForNextTickAsync(stoppingToken))
{
    await ProcessAsync(stoppingToken);
}