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

Перевод статьи 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 кода:

//////// // 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 */

///////// // 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.

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