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

Проблема в том, что код пишется в текстовом формате, и компилятор должен понять, где начало и где конец строки. В некоторых языках (например, php и javascript) для строки можно использовать одинарные кавычки 'строка "с кавычками" внутри'. Но в c# так нельзя, приходится экранировать кавычки, одним из двух способов:

string s1 = "строка \"с кучей\" ковычек";
string s2 = @"строка ""с кучей"" ковычек";

https://learn.microsoft.com/ru-ru/dotnet/csharp/pr...

Неплохая книга для "нулёвых" новичков, которые хотят делать игры в Юнити.

В главах 1-5 рассказывают самые базовые вещи языка (переменные, ветви/циклы, методы) и самые простые вещи, связанные с классами. За эти главы научиться программированию невозможно, для них цель - дать нужные термины, с которыми потом можно идти дальше. Потом эти же вещи обрастут нужными подробностями и примерами во второй и третьей частях.

В главах 6-9 больше автор говорит о Юнити, тоже довольно коротко, но если читатель хоть немного уже раньше ознакомился Юнити, то тут будет попроще. Хорошо то, что здесь рассказано, как писать скрипты о нужных частях игры, о которых рассказывает - движение объектов в скрипте, физика, поведение объектов, а также коротко о программировании ИИ (некоротко не получится - об этом пишут толстенные тома).

Главы 10-12 углубляют понимание языка и добавляют новые концепции (разные коллекции, дженерики, делегаты, обработка ошибок). Тут поменьше кода и побольше теории. Но и тут каждый факт о языке подкрепляется примером.

В общем, в книге показаны основы программирования на языке c# и его использование для создания базовых скриптов в Юнити. Некоторым минусом могу отметить, что тут автор больше учит собственно языку, а не программированию - то есть, как писать, а не почему писать так. Но такое в подобных книгах и не пишут - понимание приходит позже, с опытом.

Да, всё верно поняли. Дизайнер XAML не совсем "дружит" с кодом - он ищет только те, которые уже скомпилированы. Видимо, дизайнер ищет классы стандартным способом - через тип Type (и т.п.), а тот ищет среди сборок (exe/dll) проекта.

Нужно сразу скомпилировать новый тип, даже просто пустой class Test {} - и всё, будет работать. Лучше делать это пораньше - до того, как пытаетесь связать его в xaml, иначе билд не срабатывает, и приходится выпиливать его из xaml-а.

У объектов тип разный - string или string[], их невозможно поместить в один массив напрямую. Но можно сделать по другому - по сложному или по простому.

Сложный - сделать отдельный тип, который принимает либо строку, либо коллекцию объектов такого же типа. И теперь в коллекцию таких типов можно поместить иерархично.

А можно по простому - просто использовать массив объектов. И строка, и массив строк - объекты. Но придётся явно проверять реальный тип.

object[] arr = new object[]
{
    "Hello World!",
    new object[]
    {
        "Hello_1",
        "Hello_2"
    }
};

foreach (object item in arr)
{
    if (item is string str)
    {
        Console.WriteLine(str);
    }
    else if (item is object[] subarr)
    {
        foreach (object subitem in subarr)
        {
            Console.WriteLine(subitem);
        }
    }
}

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

object[] arr = new object[]
{
    "Hello World!",
    new object[]
    {
        "Hello_1",
        "Hello_2",
        new object[]
        {
            "Hello_11",
            "Hello_22"
        }
    }
};
foreach (object item in arr)
{
    ItemAction(item, str => Console.WriteLine(str));
}

static void ItemAction(object item, Action<string> action)
{
    if (item is string str)
    {
        action(str);
    }
    else if (item is object[] arr)
    {
        foreach (object subitem in arr)
        {
            ItemAction(subitem, action);
        }
    }
}

Compile time - выбор в коде, во время компиляции (comple time). То есть, компилятор видит код и понимает, какой тип нужен при создании объекта.

var figure = new Circle(); // тип известен заранее (при компиляции)
Console.WriteLine(figure.CalcArea());

В отличие от compile time. может быть run time - во время работы программы, тип объекта выбирается в зависимости от некоторых условий (ввод пользователя, ответ от сервера, настройки в конфиг-файле, изменилась фаза луны).
Самый простой вариант:

var type = Console.ReadLine();
Figure figure = null;
switch (type.ToLower())
{
    case "square": figure = new Square(10); break;
    case "rectangle": figure = new Rect(10, 20); break;
    case "circle": figure = new Circle(10); break;
}
if (figure != null)
{
    Console.WriteLine(figure.CalcArea());
}
else
{
    Console.WriteLine("Неверный тип фигуры");
}

Выбор делается в рантайме между заранее известными типами - конкретные возможные типы указаны в коде (в компайлтайме).

Реальный тип (имя класса) можно спросить у пользователя (или из настройки), и вызвать его активатором:

var typeName = Console.ReadLine();
var type = Type.GetType(typeName);
if (type != null)
    var figure = (Figure)Activator.CreateInstance(type);
    Console.WriteLine(figure.CalcArea());
}
else
{
    Console.WriteLine("Неверный тип");
}

Но тип должен быть полным, с пространством имён, то есть, не "Square", а "MyApp.Figures.Square". Таким образом можно создать объект типа, которого вообще не было во время компиляции - например, тип был объявлен в отдельной библиотеке и добавлен в программу после компиляции (так делаются плагины, например). Но для плагинов код будет посложнее.

Вам не нужно делать кастомный контрол для листбокса, такое поведение делается по другому:
1) создаётся класс Anime, в котором нужно указать необходимые свойства аниме - Название, рейтинг, автор, серия, ссылка на скачивание и пр.
2) создаётся вьюмодель окна (или части окна),
2.1) во вьюмодели нужно сделать коллекцию объектов аниме (можно и List, но лучше ObservableCollection)
3) вьюмодель указывается в окно как датаконтекст (тут есть несколько вариантов, ниже покажу самый прсотой вариант)
4) привязать коллекцию аниме к списку ListBox, и указать имя свойства для показа (тут, видимо - Название).
5) всё, список готов - будет видно в окне. Осталось получить конкретный элемент и его свойства - объект класса Anime указано в свойстве DataContext элемента списка (ListBoxItem) и остаётся привести к нужному классу:
var anime = (Anime)AnimeListBox.Items.First().DataContext;
Console.WriteLine(anime.Name + " " + anime.Rating);

class Anime
{
    public string Name {get; set;}
    public double Rating {get; set;}
    public string Author {get; set;}
    public string Serie {get; set;}
    public string Url {get; set;}
}
class AnimeListViewModel
{
    public ObservableCollection<Anime> AnimeList {get; set;} = new ObservableCollection<Anime>
    {
        new Anime { Name = "Наруто",  Rating = 5, Author = "Масаси Кисимото"},
        new Anime { Name = "Стальной алхимик",  Rating = 5, Author = "Хирому Аракава"},
        new Anime { Name = "X",  Rating = 5, Author = "CLAMP"},
    };
}

<Window ...
    xmlns:app="clr-namespace:Anime">
    <Window.DataContext>
        <app:AnimeListViewModel/>
    </Window.DataContext>
    <Grid>
        <ListBox ItemsSource="{Binding AnimeList}"
                 DisplayMemberPath="Name"/>
                 x:Name="AnimeListBox"/>
    </Grid>
</Window>

Модель описывает данные. Представление определяет внешний вид экрана. Вьюмодель - это модель, которая предназначена для использования данных из модели внутри представления, причём во вьюмодели можно добавлять какие-то поля только для удобства представления. Одна вьюмодель вполне может использовать несколько разных моделей.

Первейший путь для показа данных в представлении - привязка (биндинг) данных, а также - специальные поля контрола (например, DisplayMemberPath).
Команды используются для обратной связи от пользователя в представлении во вьюмодель.
Свойства зависимости сами по себе обычно не используются напрямую, а просто добавляют возможностей для биндинга.
Расширения разметки дают связывать несколько классов в одном контроле.

В представлении вполне можно обойтись без вьюмодели, используя саму модель (передав её как датаконтекст). Но у модели обычно нет интерфейса INotifyPropertyChanged, и вьюмодель как раз реализует её для использования биндинга, а также добавляет команды и доп.свойства. Для одной модели вполне может быть несколько вьюмоделей, по одному для представлений, или наоборот, одна вьюмодель вполне может подходить для нескольких представлений.

В примере можно увидеть, что в представлении можно использовать как свойства вьюмодели, так и исходные данные модели.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string MiddleName { get; set; }
}
public class EditPersonVm : BaseViewModel // который реализует INotifyPropertyChanged
{
    private readonly Person _person;
    public Person Person => _person;

    private string _firstName;
    public string FirstName
    {
        get => _firstName;
        set { _firstName = value; RaisePropertyChanged(); }
    }
    private string _lastName;
    public string LastName 
    {
        get => _lastName;
        set { _lastName= value; RaisePropertyChanged(); }
    }
    private string _middleName;
    public string MiddleName 
    {
        get => _middleName;
        set { _middleName= value; RaisePropertyChanged(); }
    }

    public string InitFullName => $"{_person.LastName} {_person.FirstName[0]}. {_person.MiddleName[0]}.";

    public RelayCommand OkButton { get; set; } = new RelayCommand(Save);

    public EditPersonVm(Person person)
    {
        _person = person;
        FirstName = person.FirstName;
        LastName = person.LastName;
        MiddleName = person.MiddleName;
    }

    private void Save()
    {
        //
    }
}

<Window ...>
    <StackPanel Orientation="Vertical">
        <Label Content="Изначальное имя:"/>
        <StackPanel>
            <TextBlock Text="{Binding Person.LastName}"/>
            <TextBlock> </TextBlock>
            <TextBlock Text="{Binding Person.FirstName}"/>
            <TextBlock> </TextBlock>
            <TextBlock Text="{Binding Person.MiddleName}"/>
        </StackPanel>
        <Label Content="Фамилия:"/>
        <TextBox Text="{Binding LastName, UpdateSourceTrigger=PropertyChanged}"/>
        <Label Caption="Имя:"/>
        <TextBox Text="{Binding FirstName, UpdateSourceTrigger=PropertyChanged}"/>
        <Label Caption="Отчество:"/>
        <TextBox Text="{Binding MiddleName, UpdateSourceTrigger=PropertyChanged}"/>
        <Button Content="OK"  Command="{Binding OkCommand}">
    </StackPanel>
</Window>

>У героя Body Type - Kinematic
У героя Body Type должен быть Dynamic, иначе физика не заработает. Тип Kinematic - положение объектом полностью управляется скриптом, а не физикой. Значит, если вы хотите использовать физику, то используйте тип Dynamic.

Препятствия можно сделать кинематичными или даже статичными (например, земля или неподвижные платформы), тогда они не будут двигаться персонажем (кинематичные можно двигать скриптом), а если вы хотите расшвыривать булыжники или ящики (с помощью физики), то они тоже должны быть динамичными. Плюс для динамичных объектов нужно указывать правильную массу.

Для начала рекомендую серию из трёх статей (во второй см. комментарий для доработки старого кода в новых версиях юнити)

Можно использовать конвертер i:InvokeCommandAction из System.Windows.Interactivity.

1) Добавить сборку System.Windows.Interactivity с помощью добавления ссылки (она в списке расширений).

2) Добавить указанную сборку в xaml:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

3) Использовать i:EventTrigger и i:InvokeCommandAction:

<TextBox>
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="KeyDown">
            <i:InvokeCommandAction Command="{Binding KeyDownCommand}"/>
        </i:EventTrigger>
    </i:Interaction.Triggers>
</TextBox>

Но если вы хотите там вызывать только обработку представления, например, запретить определённые клавиши (то есть, не нужны данные из слоя бизнес-логики), то есть смысл обработку сделать обычным способом - в code-behind (xaml.cs).

Нужно найти все места, где есть нужное слово.

string s = "<div>Здесь нам нужно заменить некоторый текст, текст, текст</div>";
var word = "текст";
var replaceTo = "ТЕКСТ";
var words = new List<int>();
int lastPos = 0;
int pos = 0;
do
{
    pos = s.IndexOf(word, lastPos);
    if (pos >= 0)
    {
        words.Add(pos);
        lastPos = pos + word.Length;
    }
}
while (pos >= 0);

А теперь уже можно сделать с ними всё что угодно - заменять хоть все, хоть по одному.
Например, замена первого слова

var result = s.Substring(0, words[0]) + replaceTo + s.Substring(words[0] + word.Length);

UPD. Можно вместо цикла найти слова с помощью регулярного выражения:

string s = "<div>Здесь нам нужно заменить некоторый текст, текст, текст</div>";
var word = "текст";
var replaceTo = "ТЕКСТ";
var words = new Regex(word).Matches(s).OfType<Match>().Select(match => match.Index).ToList();
var result = s.Substring(0, words[0]) + replaceTo + s.Substring(words[0] + word.Length);

Регекс может работать дольше, чем цикл. Зато код поиска в одну строку!
Если нужны только слова целиком (не нужно искать "текстовый", например), то алгоритм поиска в цикле усложняется (проверять символ перед и после найденного текста, является ли пробел или пунктуация или ещё что-либо). А в регексе можно написать new Regex(@"\b" + word + @"\b").Matches(s), и регулярное выражение всё сделает само.

Т.е. data[index] - это у нас объект класса Person

Не совсем так, это не объект класса Person, а элемент с индексом index в массиве data.
Индексатор, как и обычные свойства, - это просто сахарный синтаксис для создания методов геттера и сеттера (например, поля).

Обычное свойство заменяется на методы GetProperty() и SetProperty(<type> value).
А индексатор заменяется на методы GetIndexator(int index) и SetIndexator(int index, <type> value).

В этих методах можно писать что угодно, в вашем первом варианте вы пишете код доступа к массиву data. Но тип аргументов (index и value) определяются типом индексатора, то есть, вы можете сделать вот так:

Person[] data;

public string this[int index]
{
    get
    {
        return data[index]?.Name;
    }
    set
    {
        if (data[index] == null) data[index] = new Person();
        data[index].Name = value;
    }
}

Или даже вот так:

Person[] data;

public Person this[string name]
{
    get
    {
        return data.FirstOrDefault(p => p.Name == name);
    }
    set
    {
        for (var index = 0; index < data.Length; index++)
        {
            if (person.Name == name)
            {
                data[index] = value;
                break;
            }
        }
    }
}

То есть, вы не можете сделать так, как вы написали:

set
{
     data[index].Name = value;
}

потому что типом value будет Person, а не string. (вряд ли, что у вас у свойства Name тоже тип Person, или у вас есть implicit приведение из Person в string).

А что если там не один только Name будет, ещё поля ??..

А если у вас там больше свойств, то будьте добры указать это в коде. Точно так же, как и если только один Name, в общем-то.

Использовать KeyDown вместо KeyPress. В KeyDown приходит не печатаемый символ, а код клавиши, в том числе, и управляющие клавиши.

В вашем случае нужно вызывать оба события. Вначале вызывается KeyDown, и если он не выполнил работу обработки (не указан e.Handled = true), то вызовется обработчик KeyPress.

Вот примерный код обработки backspace:

private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
    if (e.KeyCode == Keys.Back)
    {
        var selectionStart = textBox1.SelectionStart;
        if (textBox1.SelectionLength > 0)
        {
            textBox1.Text = textBox1.Text.Substring(0, selectionStart) + textBox1.Text.Substring(selectionStart + textBox1.SelectionLength);
            textBox1.SelectionStart = selectionStart;
        }
        else if (selectionStart > 0)
        {
            textBox1.Text = textBox1.Text.Substring(0, selectionStart - 1) + textBox1.Text.Substring(selectionStart);
            textBox1.SelectionStart = selectionStart - 1;
        }
        
        e.Handled = true;
    }
}