Василий Банников

WPF

Лучше по возможности переиспользовать Random, тк создание его экземпляра достаточно дорогое
Но стоит учитывать следующие моменты:
1. Он по умолчанию не является потокобезопасным, а это значит, что нельзя один экземпляр использовать в нескольких потоках. Это черевато дублированием случайных значений
2. Random - генератор псевдослучайных чисел, а это значит, что его нельзя использовать для криптографии

Ну и вот результаты замеров

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

BenchmarkRunner
    .Run<RandomBenchmarks>();

[MemoryDiagnoser]
public class RandomBenchmarks
{
    private static readonly Random Random = new();

    [Benchmark]
    public void Reuse()
    {
        Random.Next();
    }

    [Benchmark]
    public void CreateNew()
    {
        new Random().Next();
    }
}

// * Summary *

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.22463
AMD Ryzen 5 4600H with Radeon Graphics, 1 CPU, 12 logical and 6 physical cores
.NET SDK=6.0.100-rc.1.21463.6
  [Host]     : .NET 6.0.0 (6.0.21.45113), X64 RyuJIT
  DefaultJob : .NET 6.0.0 (6.0.21.45113), X64 RyuJIT


|    Method |       Mean |     Error |    StdDev |  Gen 0 | Allocated |
|---------- |-----------:|----------:|----------:|-------:|----------:|
|     Reuse |   3.128 ns | 0.0987 ns | 0.1351 ns |      - |         - |
| CreateNew | 114.934 ns | 2.3160 ns | 4.8852 ns | 0.0343 |      72 B |

// * Legends *
  Mean      : Arithmetic mean of all measurements
  Error     : Half of 99.9% confidence interval
  StdDev    : Standard deviation of all measurements
  Gen 0     : GC Generation 0 collects per 1000 operations
  Allocated : Allocated memory per single operation (managed only, inclusive, 1KB = 1024B)
  1 ns      : 1 Nanosecond (0.000000001 sec)

Может показаться, что 72 байта на операцию - это не много, но это:
1. Это 70мб на 1млн операций, против 72байт
2. Это миллион лишних объектов в куче против одного, что добавляет лишней работы для GC

Можно как-то так через кастомный IComparer:

var arr = new int[] { 1, 1, 1, 2, 3, 3, 4, 4, 4, 4, 5, 6, 6, 7, 8 };

var index = arr.GroupBy(x => x).ToDictionary(x => x.Key, x => x.Count());
var result = arr.OrderByDescending(x => x, new CountComparer(index)).ToArray();

class CountComparer : IComparer<int>
{
    private readonly IReadOnlyDictionary<int, int> _index;
    public CountComparer(IReadOnlyDictionary<int, int> index)
    {
        _index = index;
    }

    public int Compare(int x, int y)
    {
        var comparsion = _index[x].CompareTo(_index[y]);
        if (comparsion == 0)
            return x.CompareTo(y);
        return comparsion;
    }
}

Ну или можно самому написать алгоритм, но всё равно первым шагом надо будет пройтись по всему массиву с подсчётом повторений.
Хотя мб можно как-то оптимизировать, если предположить, что изначально массив отсортирован по возрастанию.

Эммм. Просто вынести их в переменные?

using System;

for (var i = 1; i < 100; i++)
{
    var dividesBy3 = i % 3 == 0;
    var dividesBy5 = i % 5 == 0;

    if (dividesBy3 && dividesBy5)
        Console.WriteLine("OuuMay");
    else if (dividesBy3)
        Console.WriteLine("Ouu");
    else if (dividesBy5)
        Console.WriteLine("May");
    else
        Console.WriteLine(i);
}
Console.ReadKey();

Например вариант через регулярки:

var regex = new Regex(@"\d+", RegexOptions.Compiled);
var text=  "is2 Thi1s T4est 3a";
var matches = regex.Matches(text);
var result = matches.Select(x=>x.Value).Select(int.Parse).ToArray(); // {2, 1, 4, 3}

Кроме этого только циклом вручную

Все варианты по своему допустимы и "правильного" пути тут нет.
1. Проблема может возникнуть, если БД системы изменится или понадобится какая-нибудь дополнительная валидация
2. Вроде ок, но нужно добавлять и поддерживать методы в каждой API-шке, и следить за совместимостью
3. Дополнительное звено в инфраструктуре. Придётся потратиться на развёртывание и поддержку, ну и заплатить задержками.

Я бы выбрал вариант с API тк он кажется самым адекватным в соотношении цена/качество.

Можно через новый тип

class Value {
    public int Id {get; set;}
    public string File {get;set;}
}
var dictionary = new Dictionary<string, Value> {
    ["asd"] = new Value { Id = 1, File = "File.png" }
}

Можно через кортежи (хз доступны ли они в юнити)

var dictionary = new Dictionary<string, (int Id, string File)> {
    ["asd"] = (1, "File.png")
}

Никак. С# так не умеет

В этом случае можно без женерика - просто int.

class Text {
            private static byte maxCharIndex = 255;

        public static string generateText(int textLength = 1)
        {
            char[] chars = new char[textLength]; // всё равно размер для массивов задаётся интом
            Random r = new Random();

            for (T i = 0; i < textLength; i++)
            {
                chars[i] = Convert.ToChar(r.Next(0, maxCharIndex));
            }

            return new string(chars);
        }
}

2. Не избыточна ли тут ConcurrentQueue?

Вместо неё лучше использовать System.Threading.Channels (https://www.stevejgordon.co.uk/an-introduction-to-...)

3. Как сообщить основному потоку из Task.run() что все готово к обновлению карт? Я понимаю что есть Task.Result, но если Task выполняется постоянно (while true), смогу ли я это использовать?

При помощи канала.
А Task.Result испольщовать не следует

В остальном всё звучит правдоподобно

var key = Console.ReadKey();
if(key == ConsoleKey.Backspace)
  WriteDataToFile();

Вообще-то можно их скомбинировать :)

А первый вариант нужен, чтобы можно было кастануть к ICloneable и не знать, что мы там клонируем

Попробуй поправить pg_hba.conf
https://stackoverflow.com/questions/18580066/how-t...