Алексей Павлов

class TestClass
{
    private int _a;
    public int A
    {
        get { return _a; }
        set { _a = value; }
    }

    public int B { get; set; }
}

var testClass = typeof(TestClass);
var fields = testClass.GetFields(BindingFlags.NonPublic | BindingFlags.Instance);
foreach (var fieldInfo in fields)
{
    Console.WriteLine(fieldInfo.Name);
}
// результат:
// _a
// <B>k__BackingField

class A { public virtual void Print() { Console.WriteLine("A"); } }
class B : A { public override void Print() { Console.WriteLine("B"); } }
class C : B { public new virtual void Print() { Console.WriteLine("C"); } }
class D : C { public override void Print() { Console.WriteLine("D"); } }

A ad = new D();
ad.Print(); // покажет B

public class Item : BaseViewModel
{
    private string _name;
    public string Name 
    { 
        get => _name;
        set
        {
            _name = value;
            RaisePropertyChanged();
        }
    }
    
    private int _itemMode;
    public int ItemMode 
    { 
        get => _itemMode;
        set
        {
            _itemMode = value;
            RaisePropertyChanged();
        }
    }
}

public class ItemsList
{
    public ObservableCollection<Item> Items { get; } = new ObservableCollection<Item>
    {
        new Item { Name = "Один", ItemMode = 1 },
        new Item { Name = "Два", ItemMode = 2 },
        new Item { Name = "Три", ItemMode = 3 },
    };
}

<Grid>
    <Grid.Resources>
        <converters:IntToBoolConverter x:Key="IntToBoolConverter"/>
        <DataTemplate DataType="{x:Type viewModels:Item}">
            <Border x:Name="Data">
                <Grid x:Name="ContentBase" Margin="1,0">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="Auto"/>
                        <ColumnDefinition/>
                        <ColumnDefinition/>
                        <ColumnDefinition/>
                    </Grid.ColumnDefinitions>
                    <Label Name="DisplayText" Grid.Column="0" Content="{Binding Name}"/>
                    <RadioButton Name="_1" Grid.Column="1" Content="1" 
                                 IsChecked="{Binding ItemMode, Converter={StaticResource IntToBoolConverter}, ConverterParameter=1}"/>
                    <RadioButton Name="_2" Grid.Column="2" Content="2" 
                                 IsChecked="{Binding ItemMode, Converter={StaticResource IntToBoolConverter}, ConverterParameter=2}"/>
                    <RadioButton Name="_3" Grid.Column="3" Content="3" 
                                 IsChecked="{Binding ItemMode, Converter={StaticResource IntToBoolConverter}, ConverterParameter=3}"/>
                </Grid>
            </Border>
        </DataTemplate>
    </Grid.Resources>        
    <Grid.DataContext>
        <viewModels:ItemsList/>
    </Grid.DataContext>
    <ListBox ItemsSource="{Binding Items}"/>
</Grid>

public class BaseViewModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    
    protected virtual void RaisePropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

public class IntToBooleanConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value != null 
            && parameter != null 
            && value.ToString() == parameter.ToString();
    }
 
    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        if (value == null || parameter == null) return Binding.DoNothing;

        int result;
        if ((bool)value && int.TryParse(parameter.ToString(), out result))
        {
            return result;
        }

        return Binding.DoNothing;
    }
}

//m = new Message();
m = MessageFactory.GetMessage();

foreach (var newOrder in newOrders)
{
    // ищем минимальное количество заявок среди всех менеджеров
    var minOrdersCount = managers.Min(m => m.Orders.Count);
    // ищем менеджера с найденным количеством (если несколько - берём первого)
    var manager = managers.First(m => m.Orders.Count == minOrdersCount);
    // даём заявку менее занятому менеджеру
    manager.Orders.Add(newOrder);
}

class Manager
{
    public string Name { get; private set; }
    public List<int> Orders { get; private set; }

    public Manager(string name, int ordersCount = 0)
    {
        Name = name;
        Orders = ordersCount > 0
            ? Enumerable.Range(1, ordersCount).ToList()
            : new List<int>();
    }
}

static void Main(string[] args)
{
    var managers = new Manager[]
    {
        new Manager("Лена", 1), 
        new Manager("Оля", 10), 
        new Manager("Иван", 35), 
        new Manager("Сергей", 75), 
    };
    var newOrders = Enumerable.Range(1, 35).ToList();
    var newOrdersCount = newOrders.Count;
    var ordersAssigned = 0;

    while (ordersAssigned < newOrdersCount)
    {
        var ordersCounts = managers.Select(m => m.Orders.Count).OrderBy(count => count).Distinct().ToArray();
        var addingOrdersCount = ordersCounts.Length > 1 ? ordersCounts[1] - ordersCounts[0] : ordersCounts.First();
        var managersWithMinOrders = managers.Where(m => m.Orders.Count == ordersCounts[0]).ToArray();
        // нашли менеджеров с минимальным количеством заявок
        if (managersWithMinOrders.Length * addingOrdersCount < newOrdersCount)
        { // заполняем самых незанятых менеджеров до того же уровня занятости
          // т.е. добавляем Лене (10 - 1) = 9 заявок
            foreach (var manager in managersWithMinOrders)
            {
                for (int i = 0; i < addingOrdersCount; i++)
                {
                    manager.Orders.Add(newOrders[ordersAssigned]);
                    ordersAssigned++;
                }
            }
        }
        else
        {
            // незанятых менеджеров нет, заполняем оставшиеся заявки по менеджерам по очереди
            while (ordersAssigned < newOrdersCount)
            {
                var managerIndex = ordersAssigned % managersWithMinOrders.Length;
                managersWithMinOrders[managerIndex].Orders.Add(newOrders[ordersAssigned]);
                ordersAssigned++;
            }
        }
    }

    foreach (var manager in managers)
    {
        Console.WriteLine("{0}: {1} заявок", manager.Name, manager.Orders.Count);
    }
    Console.ReadKey();
}

var isLeftPressed = Input.GetButton("LeftArrow");
var isUpPressed = Input.GetButton("UpArrow");
var isRightPressed = Input.GetButton("RightArrow");
var isDownPressed = Input.GetButton("DownArrow");
if (isUpPressed && isDownPressed && Time.time > timeToFire)
{
    timeToFire = Time.time + 1 / fireRate;
    Instantiate(fireSphere, firePoint.position, firePoint.rotation);
}