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

Проблема в том, что код пишется в текстовом формате, и компилятор должен понять, где начало и где конец строки. В некоторых языках (например, 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>

Можно использовать конвертер 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;
    }
}

Можно попробовать сделать третье свойство, которое в геттере будет получать нужное свойство.