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

Original author: Jackson Dunstan
  • Translation
  • Tutorial
image

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

Оставайтесь на связи!
Ads
AdBlock has stolen the banner, but banners are not teeth — they will be back

More

Comments 11

    +1
    Конвенция названий говорит, что названия переменных должны начинаться с большой буквы.
    Что?! С большой буквы должны начинаться свойства, а переменные — с маленькой; поля же (почему-то обозванные тут переменными) — либо с маленькой, либо с подчеркивания и маленькой, либо с m_ и маленькой буквы.
      +2
      Нотация с m_ вроде как не рекомендуется. В ответах на SO есть все необходимые ссылки: C# Field Naming Guidelines?
        +1
        Я потому и привел три разных варианта, что в разное время разными людьми рекомендовались разные.
        0
        Все правильно сказал человек. Попробуйте заглянуть внутрь, например, класса BundleCollection. Там есть практически все примеры.
          0
          Не нашел опровержения своим словам в этом классе…
          Скрытый текст
            0
            Ну так я вас и имел ввиду(=
        +1
        Хорошая статья, жду продолжение!
        +1
        Легкая и понятная подача материала — то что нужно!
        Огромное Спасибо!
        Продолжение очень нужно!
          –2
          Политрук лжёт!
          В Юнити вас не обижают, не мучают и не ограничивают в платформах, а обращаются с вами хорошо.
          Флешеры, переходите к нам!

        Only users with full accounts can post comments. Log in, please.