Перевод статьи From AS3 to C#, Part 1: Class Basics
Эта статья поможет разобраться в основах C# тем AS3 разработчикам, которые решили переключиться на Unity, но абсолютно не знакомы с программированием на C#.
Начнём с главного: С# файлы имеют расширение .cs, а не .as как AS3 файлы. Внутри файлов вы найдёте описание классов, из которых состоят приложения (аналогично AS3 файлам). Например, файл MyClass.cs:
class MyClass
{
}
Название классов в C# подчиняется той же конвенции, что и названия классов в AS3: каждое слово в названии класса должно начинаться с большой буквы, остальная часть названия пишется в нижнем регистре. Как вы могли заметить, базовый синтаксис классов в C# такой же, как у классов в AS3.
Теперь давайте добавим переменную:
class MyClass
{
int X;
}
Определение переменных в C# отличается от AS3. Вместо var x:int, нужно использовать int X. Конвенция названий говорит, что названия переменных должны начинаться с большой буквы.
Давайте посмотрим на функции:
class MyClass
{
void Foo()
{
}
}
Функции в C# так же отличаются от функций в AS3. В C# не используется ключевое слово function, возвращаемый тип данный указывается вначале (а не в конце, как это было в AS3), название функций должно начинаться с большой буквы, исходя из конвенции названий.
Функция с входящими параметрами:
class MyClass
{
void Foo(int x, int y, int z)
{
}
}
Параметры функций, так же, как и в AS3, находятся внутри скобок, но записываются они немного по-другому: вначале тип, потом имя, с пробелом между ними. Конвенция говорит, что названия параметров функций должны начинаться с маленькой буквы.
Как и в AS3, параметры функций могут иметь значения по-умолчанию:
class MyClass
{
void Foo(int x = 1, int y = 2, int z = 3)
{
}
}
Функция-конструктор:
class MyClass
{
MyClass()
{
}
}
Как и в AS3, нам не обязательно указывать тип возвращаемого значения для функций-конструкторов. Вообще-то, у вас не получится указать даже тип данных void, как это можно было сделать в AS3. Так же, для объявления этого типа функций, не используется ключевое слово function.
Вы можете иметь больше одной функции-конструктора, это называется «перегрузка» функций:
class MyClass
{
MyClass()
{
}
MyClass(int x)
{
}
MyClass(int x, int y, int z)
{
}
}
Перезагрузка так же доступна для других функций:
class MyClass
{
void Foo()
{
}
void Foo(int x)
{
}
void Foo(int x, int y, int z)
{
}
}
Чтобы компилятор мог определить, какая из функций вызывается, необходимо придерживаться 2 правил. Во-первых, вы не можете иметь 2 функции с одинаковыми параметрами:
class MyClass
{
void Foo(int x, int y, int z)
{
// Какой-то функционал
}
void Foo(int x, int y, int z)
{
// Какой-то другой функционал
}
}
Это же касается тех функций, вызов которых может выглядеть одинаково, если не будет указан один из параметров по-умолчанию:
class MyClass
{
void Foo(int x, int y, int z)
{
// Какой-то функционал
}
void Foo(int x, int y, int z, int w = 0)
{
// Какой-то другой функционал
}
}
Во-вторых, вы не можете «перегружать» функции по типу данных, который они возвращают:
class MyClass
{
int Foo(int x, int y, int z)
{
return 0;
}
uint Foo(int x, int y, int z)
{
return 0;
}
}
Придерживаясь этих двух простых правил, вы сможете «перегружать» функции, сколько ваша душа пожелает =)
Как и в AS3, для определения статических функций необходимо добавить ключевое слово static:
class MyClass
{
static void Foo()
{
}
}
То же самое со статическими переменными:
class MyClass
{
static int X;
}
Теперь, когда мы знаем, как внутри классов определять классы, переменные, функции и конструкторы, давайте рассмотрим как использовать их:
void SomeCode()
{
// Вызов конструктора по-умолчанию (например, без входящих параметров)
MyClass mc = new MyClass()
// Вызов другого конструктора
mc = new MyClass(5);
// Вызов функции
mc.Foo();
// Вызов перегруженной функции
mc.Foo(1, 2, 3);
// Вызов статической функции
MyClass.Foo();
// Получение значения переменной
mc.X;
// Установка значения переменной
mc.X = 1;
// Кстати, однострочные комментарии работают так же, как и в AS3...
/*
... многострочные комментарие тоже.
*/
}
Всё это очень похоже на AS3. Обратите внимание, что локальная переменная mc начинается с маленькой буквы, как и параметры функций.
Давайте обсудим модификаторы доступа. Стандартные модификаторы public, private и protected имеют такой же синтаксис и такое же поведение, как и в AS3. Для их использования достаточно просто добавить их перед возвращаемым типом данных функции, типом переменной или ключевым словом class:
public class MyClass
{
private int X;
protected void Foo()
{
}
}
В C#, как и в AS3, существует модификатор доступа internal, который имеет такое же название, но немного другое поведение (по-сравнению с AS3). В AS3 модификатор internal означает «доступно для текущего класса и других классов в текущем пакете». В C# он означает «доступно для текущего класса и остальных классов в текущей сборке». Я расскажу про понятие «сборки» в других статьях, но пока что, думайте о них, как о группе классов, собранных в одном бинарном файле.
Так же, в C# есть модификатор protected internal, который является комбинацией protected и internal.
В завершении, сравнение описанных особенностей C# и AS3 кода:
|
|
Этим завершается первая часть цикла статей «С# для AS3 разработчиков». Следующие статьи будут касаться более сложных тем, включая такие особенности C#, аналоги которых не существуют в AS3.
Оставайтесь на связи!
