С# для AS3 разработчиков. Часть 1: Основы классов

 

Перевод статьи From AS3 to C#, Part 1: Class Basics

Эта статья поможет разобраться в основах C# тем AS3 разработчикам, которые решили переключиться на Unity, но абсолютно не знакомы с программированием на C#.

Начнём с главного: С# файлы имеют расширение .cs, а не .as как AS3 файлы. Внутри файлов вы найдёте описание классов, из которых состоят приложения (аналогично AS3 файлам). Например, файл MyClass.cs:

Название классов в C# подчиняется той же конвенции, что и названия классов в AS3: каждое слово в названии класса должно начинаться с большой буквы, остальная часть названия пишется в нижнем регистре. Как вы могли заметить, базовый синтаксис классов в C# такой же, как у классов в AS3.

Теперь давайте добавим переменную:

Определение переменных в C# отличается от AS3. Вместо var x:int, нужно использовать int X. Конвенция названий говорит, что названия переменных должны начинаться с большой буквы.

Давайте посмотрим на функции:

Функции в C# так же отличаются от функций в AS3. В C# не используется ключевое слово function, возвращаемый тип данный указывается вначале (а не в конце, как это было в AS3), название функций должно начинаться с большой буквы, исходя из конвенции названий.

Функция с входящими параметрами:

Параметры функций, так же, как и в AS3, находятся внутри скобок, но записываются они немного по-другому: вначале тип, потом имя, с пробелом между ними. Конвенция говорит, что названия параметров функций должны начинаться с маленькой буквы.

Как и в AS3, параметры функций могут иметь значения по-умолчанию:

Функция-конструктор:

Как и в AS3, нам не обязательно указывать тип возвращаемого значения для функций-конструкторов. Вообще-то, у вас не получится указать даже тип данных void, как это можно было сделать в AS3. Так же, для объявления этого типа функций, не используется ключевое слово function.

Вы можете иметь больше одной функции-конструктора, это называется “перегрузка” функций:

Перезагрузка так же доступна для других функций:

Чтобы компилятор мог определить, какая из функций вызывается, необходимо придерживаться 2 правил. Во-первых, вы не можете иметь 2 функции с одинаковыми параметрами:

Это же касается тех функций, вызов которых может выглядеть одинаково, если не будет указан один из параметров по-умолчанию:

Во-вторых, вы не можете “перегружать” функции по типу данных, который они возвращают:

Придерживаясь этих двух простых правил, вы сможете “перегружать” функции, сколько ваша душа пожелает =)

Как и в AS3, для определения статических функций необходимо добавить ключевое слово static:

То же самое со статическими переменными:

Теперь, когда мы знаем, как внутри классов определять классы, переменные, функции и конструкторы, давайте рассмотрим как использовать их:

Всё это очень похоже на AS3. Обратите внимание, что локальная переменная mc начинается с маленькой буквы, как и параметры функций.

Давайте обсудим модификаторы доступа. Стандартные модификаторы public, private и protected имеют такой же синтаксис и такое же поведение, как и в AS3. Для их использования достаточно просто добавить их перед возвращаемым типом данных функции, типом переменной или ключевым словом class:

В C#, как и в AS3, существует модификатор доступа internal, который имеет такое же название, но немного другое поведение (по-сравнению с AS3). В AS3 модификатор internal означает “доступно для текущего класса и других классов в текущем пакете”. В C# он означает “доступно для текущего класса и остальных классов в текущей сборке”. Я расскажу про понятие “сборки” в других статьях, но пока что, думайте о них, как о группе классов, собранных в одном бинарном файле.

Так же, в C# есть модификатор protected internal, который является комбинацией protected и internal.

В завершении, сравнение описанных особенностей C# и AS3 кода:

C# //////// // C# // //////// ///////////////// // Declaration // ///////////////// // Class public class MyClass { // Field variable public int X; // Class variable static public int Y; // Default constructor public MyClass() { } // Overloaded constructor public MyClass(int x) { } // Instance function public void Foo() { } // Overloaded instance function public void Foo(int x) { } // Class function static public void Goo() { } // Overloaded class function static public void Goo(int x) { } } /////////// // Usage // /////////// // Call the default constructor MyClass mc = new MyClass() // Call a different constructor mc = new MyClass(5); // Call an instance function mc.Foo(); // Call an overloaded instance function mc.Foo(1); // Call a static function MyClass.Goo(); // Call an overloaded static function MyClass.Goo(1); // Get an instance variable mc.X; // Set an instance variable mc.X = 1; // Get a class variable MyClass.Y; // Set a class variable MyClass.Y = 1; // Single-line comment /* Multi-line comment */ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88   //////// // C# // //////// ///////////////// // Declaration // ///////////////// // Class public class MyClass { // Field variable public int X; // Class variable static public int Y; // Default constructor public MyClass() { } // Overloaded constructor public MyClass(int x) { } // Instance function public void Foo() { } // Overloaded instance function public void Foo(int x) { } // Class function static public void Goo() { } // Overloaded class function static public void Goo(int x) { } } /////////// // Usage // /////////// // Call the default constructor MyClass mc = new MyClass() // Call a different constructor mc = new MyClass(5); // Call an instance function mc.Foo(); // Call an overloaded instance function mc.Foo(1); // Call a static function MyClass.Goo(); // Call an overloaded static function MyClass.Goo(1); // Get an instance variable mc.X; // Set an instance variable mc.X = 1; // Get a class variable MyClass.Y; // Set a class variable MyClass.Y = 1; // Single-line comment /* Multi-line comment */

ActionScript ///////// // AS3 // ///////// ///////////////// // Declaration // ///////////////// // Class public class MyClass { // Field variable public var x:int; // Class variable static public var y:int; // Default constructor public function MyClass() { } // Overloaded constructor // {not supported} // Instance function public function foo(): void { } // Overloaded instance function // {not supported} // Class function static public function goo(): void { } // Overloaded class function // {not supported} } /////////// // Usage // /////////// // Call the default constructor var mc:MyClass = new MyClass() // Call a different constructor mc = new MyClass(5); // Call an instance function mc.foo(); // Call an overloaded instance function // {not supported} // Call a static function MyClass.goo(); // Call an overloaded static function // {not supported} // Get an instance variable mc.x; // Set an instance variable mc.x = 1; // Get a class variable MyClass.y; // Set a class variable MyClass.y = 1; // Single-line comment /* Multi-line comment */ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88   ///////// // AS3 // ///////// ///////////////// // Declaration // ///////////////// // Class public class MyClass { // Field variable public var x:int; // Class variable static public var y:int; // Default constructor public function MyClass() { } // Overloaded constructor // {not supported} // Instance function public function foo(): void { } // Overloaded instance function // {not supported} // Class function static public function goo(): void { } // Overloaded class function // {not supported} } /////////// // Usage // /////////// // Call the default constructor var mc:MyClass = new MyClass() // Call a different constructor mc = new MyClass(5); // Call an instance function mc.foo(); // Call an overloaded instance function // {not supported} // Call a static function MyClass.goo(); // Call an overloaded static function // {not supported} // Get an instance variable mc.x; // Set an instance variable mc.x = 1; // Get a class variable MyClass.y; // Set a class variable MyClass.y = 1; // Single-line comment /* Multi-line comment */

Этим завершается первая часть цикла статей “С# для AS3 разработчиков“. Следующие статьи будут касаться более сложных тем, включая такие особенности C#, аналоги которых не существуют в AS3.

Оставайтесь на связи!