Перевод статьи From AS3 to C#, Part 5: Static Classes, Destructors, and Constructor Tricks

В прошлый раз мы с вами рассмотрели абстрактные классы, но уже на этой неделе мы обсудим даже более абстрактный тип классов (чем абстрактные классы): статические классы. Так же, мы рассмотрим анти-конструкторы C#, которые более известны, как “деструкторы”, и, в дополнение ко всему, мы рассмотрим некоторые забавные трюки при работе с конструкторами классов.

Статические классы

Давайте начнём сегодняшнюю статью с “даже более абстрактных” классов: статических классов. Работая с абстрактными классами, вы всё ещё можете расширять их и создавать экземпляры дочерних классов:

abstract class Shape
{
}
 
class Square : Shape // legal
{
}
 
new Shape(); // illegal
new Square(); // legal

Работая со статическими классами, вы не можете ни инстанциировать, ни наследовать их. Вы никогда не сможете создать экземпляр подобного класса:

static class Shape
{
}
 
class Square : Shape // illegal
{
}
 
new Shape(); // illegal
new Square(); // illegal

Но для чего вообще могут понадобиться подобные классы? Подобные классы могут быть хорошим местом для хранения статических функций, полей и свойств. И, так как вы не можете создавать экземпляры подобных классов, в них запрещено использование не статических полей любых типов данных. Конструкторы экземпляров класса так же запрещены, т.к. класс автоматически приравнивается к sealed классам. Довольно популярный пример использования подобных классов – класс Math. Вам вряд ли когда-либо нужно будет создать экземпляр этого класса, но внутри него содержится большое количество полезных статических функций (например Abs) и полей (например PI). Вот, как может выглядеть реализация подобного класса:

public static class Math
{
    // remember that 'const' is automatically static
    // also, this would surely have more precision
    public const double PI = 3.1415926;
 
    public static double Abs(double value)
    {
        return value >= 0 ? value : -value;
    }
}
 
new Math(); // illegal

В AS3 по-умолчанию нет поддержки статических классов на этапе компиляции, но вы можете обойти это ограничение, используя проверки на этапе проигрывания (run-time). Всё, что вам нужно будет сделать – это объявить класс, как final, и всегда бросать ошибку в конструкторе этого класса:

public final class Math
{
    public static const PI:Number = 3.1415926;
 
    public function Math()
    {
        throw new Error("Math is static");
    }    
 
    public static function abs(value:Number): Number
    {
        return value >= 0 ? value : -value;
    }
}
 
new Math(); // legal, but throws an exception

Деструкторы

Следующим пунктом в сегодняшней программе идут деструкторы, которые являются “анти-конструкторами”, потому что они отвечают за уничтожение класса, а не за его создание, как в случае с обычными конструкторами. Деструкторы вызываются сборщиками мусора (Garbage Collector) непосредственно перед тем, как объект освобождает занимаемую им память. Вот, как они выглядят:

class TemporaryFile
{
    ~TemporaryFile()
    {
        // cleanup code goes here
    }
}

Для создания деструктора, достаточно добавить ~ к имени класса. Деструктор может быть только один, и с ним нельзя использовать модификаторы доступа. Обычно, необходимости в создании деструкторов нет, но в некоторых случаях они могут быть полезными, в качестве способа очистки ресурсов после использования класса. В примере ниже деструктор используется для удаления из операционной системы временного файла, который в другом случае не будет удалён, т.к. GC никогда не сделает этого:

using System.IO;
 
class TemporaryFile
{
    public String Path { get; private set; }
 
    TemporaryFile(String path)
    {
        Path = path;
        File.Create(path);
    }
 
    ~TemporaryFile()
    {
        File.Delete(Path);
    }
}
 
// Create the temporary file
TemporaryFile temp = new TemporaryFile("/path/to/temp/file");
 
// ... use the temporary file
 
// Remove the last reference to the TemporaryFile instance
// GC will now collect temp, call the destructor, and delete the file
temp = null;

В данном примере класс TemporaryFile создаёт файл в конструкторе экземпляра класса, и удаляет файл, когда на экземпляр класса нет ссылок и класс готов быть собранным GC, чтобы освободить память. В AS3 нет функций, которые бы вызывались, когда экземпляр класса готов быть собранным GC. Обычно, чтобы реализовать подобное поведение, необходимо вручную создавать и вызывать “псевдо-деструкторы” (обычно их называют dispose или destroy):

import flash.filesystem;
 
class TemporaryFile
{
    private var _path:String;
    public function get path(): String { return _path; }
    public function set path(p:String): void { _path = p; }
 
    private var _file:File;
 
    function TemporaryFile(path:String)
    {
        _path = path;
        _file = new File(path);
        var stream:FileStream = new FileStream();
        stream.open(_file, FileMode.WRITE);
    }
 
    function dispose(): void
    {
        _file.deleteFile();
    }
}
 
// Create the temporary file
var temp:TemporaryFile = new TemporaryFile("/path/to/temp/file");
 
// ... use the temporary file
 
// Manually call dispose() to delete the temporary file
temp.dispose();
 
// Remove the last reference to the TemporaryFile instance
// GC will now collect temp
temp = null;

Трюки при работе с конструкторами

Последней темой на сегодня будут трюки при работе с конструкторами. Мы уже разбирали способ вызова конструктора базового класса, используя ключевое слово base (аналогично использованию ключевого слова super в AS3):

class Polygon
{
    Polygon(int numSides)
    {
    }
}
class Triangle : Polygon
{
    Triangle()
        : base(3) // call the Polygon constructor
    {
    }
}

Так же, мы рассматривали возможность создания более чем одного конструктора, используя “перегрузку”:

class Vector3
{
    double X;
    double Y;
    double Z;
 
    Vector3()
    {
        X = 0;
        Y = 0;
        Z = 0;
    }
 
    Vector3(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }
 
    Vector3(Vector3 vec)
    {
        X = vec.X;
        Y = vec.Y;
        Z = vec.Z;
    }
}
 
Vector3 v1 = new Vector3();        // (0, 0, 0)
Vector3 v2 = new Vector3(1, 2, 3); // (1, 2, 3)
Vector3 v3 = new Vector3(v2);      // (1, 2, 3)

Обычно этот способ приводит к дублированию кода внутри конструкторов. Но, т.к. версия конструктора , которая принимает 3 параметра наиболее общая из всех, то можно просто вызывать её из 2 других конструкторов:

class Vector3
{
    double X;
    double Y;
    double Z;
 
    Vector3()
        : this(0, 0, 0)
    {
    }
 
    Vector3(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }
 
    Vector3(Vector3 vec)
        : this(vec.X, vec.Y, vec.Z)
    {
    }
}
 
Vector3 v1 = new Vector3();        // (0, 0, 0)
Vector3 v2 = new Vector3(1, 2, 3); // (1, 2, 3)
Vector3 v3 = new Vector3(v2);      // (1, 2, 3)

Мы можем использовать this() для вызова других конструкторов в рамках нашего класса (по аналогии с base(), что позволяло вызывать конструктор родительского класса). И снова, в AS3 не было подобного функционала по-умолчанию, поэтому его приходилось “эмулировать” с помощью статических псевдо-конструкторов, которые вызывали функции наподобие init/setup/contruct у создаваемых объектов:

class Vector3
{
    var x:Number;
    var y:Number;
    var z:Number;
 
    function Vector3()
    {
        init(0, 0, 0);
    }
 
    // pseudo-constructor
    static function fromComponents(x:Number, y:Number, z:Number)
    {
        var ret:Vector3 = new Vector3();
        ret.init(x, y, z);
        return ret;
    }
 
    // pseudo-constructor    
    static function fromVector(Vector3 vec)
    {
        var ret:Vector3 = new Vector3();
        ret.init(vec.X, vec.Y, vec.Z);
        return ret;
    }
 
    // helper function
    function init(x:Number, y:Number, z:Number): void
    {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}
 
var v1:Vector3 = new Vector3();                   // (0, 0, 0)
var v2:Vector3 = Vector3.fromComponents(1, 2, 3); // (1, 2, 3)
var v3:Vector3 = Vector3.fromVector(v2);          // (1, 2, 3)

На этом мы сегодня закончим и, как обычно, в завершении статьи мы сравним описанные сегодня особенности работы с C# и AS3:

////////
// C# //
////////
 
// Static class
public static class MathHelpers
{
	public const double DegreesToRadians = Math.PI / 180.0;
	public const double RadiansToDegrees = 180.0 / Math.PI;
 
 
 
 
 
 
	public static double ConvertDegreesToRadians(double degrees)
	{
		return degrees * DegreesToRadians;
	}
 
	public static double ConvertRadiansToDegrees(double radians)
	{
		return radians * RadiansToDegrees;
	}
}
 
// Class with a destructor
class TemporaryFile
{
	public String Path { get; private set; }
 
 
 
 
 
 
 
 
 
 
 
	TemporaryFile(String path)
	{
		Path = path;
		File.Create(path);
	}
 
 
 
	// Destructor
	~TemporaryFile()
	{
		File.Delete(Path);
	}
}
 
// Class with shared constructor code
class Vector3
{
	double X;
	double Y;
	double Z;
 
	Vector3()
		: this(0, 0, 0)
	{
	}
 
	// shared constructor code
	Vector3(double x, double y, double z)
	{
		X = x;
		Y = y;
		Z = z;
	}
 
	Vector3(Vector3 vec)
		: this(vec.X, vec.Y, vec.Z)
	{
	}
 
 
 
 
 
 
 
 
 
 
}

/////////
// AS3 //
/////////
 
// Static class - runtime only
public class MathHelpers
{
    public static const DegreesToRadians:Number = Math.PI / 180.0;
    public static const RadiansToDegrees:Number = 180.0 / Math.PI;
 
    public function MathHelpers()
    {
        throw new Error("MathHelpers is static");
    }
 
    public static function ConvertDegreesToRadians(degrees:Number): Number
    {
        return degrees * DegreesToRadians;
    }
 
    public static function ConvertRadiansToDegrees(radians:Number): Number
    {
        return radians * RadiansToDegrees;
    }
}
 
// Class with a destructor
class TemporaryFile
{
    private var _path:String;
    public function get path(): String
    {
        return _path;
    }
    public function set path(p:String): void
    {
        _path = p;
    }
 
    private var _file:File;
 
    function TemporaryFile(path:String)
    {
        _path = path;
        _file = new File(path);
        var stream:FileStream = new FileStream();
        stream.open(_file, FileMode.WRITE);
    }
 
    // Destructor - must be called manually
    function dispose(): void
    {
        _file.deleteFile();
    }
}
 
// Class with shared constructor code
class Vector3
{
    var x:Number;
    var y:Number;
    var z:Number;
 
    function Vector3()
    {
        init(0, 0, 0);
    }
 
 
    static function fromComponents(x:Number, y:Number, z:Number)
    {
        var ret:Vector3 = new Vector3();
        ret.init(x, y, z);
            return ret;
    }
 
    static function fromVector(Vector3 vec)
    {
        var ret:Vector3 = new Vector3();
        ret.init(vec.X, vec.Y, vec.Z);
            return ret;
    }
 
    // shared constructor code - helper function required
    function init(x:Number, y:Number, z:Number): void
    {
        this.x = x;
        this.y = y;
        this.z = z;
    }
}

В следующей статье мы разберём новые особенности C#, которых не было в AS3!

Запись С# для AS3 разработчиков. Часть 5: Статические классы, Деструкторы и Приёмы для работы с конструкторами впервые появилась Flashist.

Перевод статьи From AS3 to C#, Part 4: Abstract Classes and Functions

В этой статье мы наконец-то начнём разбираться в нюансах C#, аналогов которых нет в AS3. И первым делом мы рассмотрим абстрактные классы и функции. В AS3 необходимо было придумывать обходные пути, чтобы они работали правильно на этапе исполнения (run-time). Но C# предоставляет возможность заставить их работать на этапе компиляции (compile-time), и сегодня мы разберём эти способы.

Статические инициализаторы

Но, до этого, я бы хотел рассказать об одной особенности AS3 классов, о которой я забыл рассказать в предыдущих статьях: статические инициализаторы (static initializers), так же известные как инициализаторы класса, конструкторы класса или статические конструкторы. Это – функция, которая будет вызвана автоматически, когда статические поля класса должны быть инициализированы. Вот, как это выглядело в AS3:

class Person
{
    private static var NEXT_ID:int;
    private var id:int;
 
    // static initializer:
    {
        NEXT_ID = 1;
    }
 
    // instance constructor
    function Person()
    {
        id = NEXT_ID++;
    }
}

Статические инициализаторы используются не часто, т.к. у нас есть возможность объявлять и инициализировать поля в одно и то же время. Например:

private static var NEXT_ID:int = 1;

Но, они могут быть полезны, если необходимо реализовать более сложную логику поведения приложения. В любом случае, вот, как это может быть реализовано в C#:

class Person
{
    private static int NextID;
    private int id;
 
    // static initializer:
    static Person()
    {
        NextID = 1;
    }
 
    // instance constructor
    Person()
    {
        id = NextID++;
    }
}

Статические инициализаторы в C# называются “статическими конструкторами” и работают по аналогии с обычными конструкторами, но не для отдельных экземпляров классов, а для всего класса целиком. Синтаксис подобных конструкторов совпадает с обычными, но в начале объявления конструктора добавляется ключевое слово static. У данных конструкторов не может быть модификаторов доступа (private, public и т.п.) и они не могут принимать входящие параметры.

Абстрактные классы

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

class ExtrudedShape
{
    private var depth:int;
 
    protected static const HIDDEN_KEY:Object = {};
 
    function ExtrudedShape(ABSTRACT:Object, depth:int)
    {
        if (ABSTRACT != HIDDEN_KEY)
        {
            throw new ArgumentError("ExtrudedShape is an abstract class");
        }
 
        this.depth = depth;
    }
 
    function get area(): int
    {
        return 0;
    }
 
    function get volume(): int
    {
        return depth * area;
    }
}

В данном случае создание ExtrudedShape напрямую всё ещё возможно, и подобный код будет компилироваться:

var shape:ExtrudedShape = new ExtrudedShape(null, 3);

Но на этапе исполнения сработает проверка первого аргумента, что повлечёт за собой появление ошибки ArgumentError, и экземпляр ExtrudedShape не будет создан. Это произойдёт из-за того, что классы, не унаследованные от ExtrudedShape не будут иметь доступа к protected константе HIDDEN_KEY, но, в то же время, классы-производные от ExtrudedShape смогут обращаться к этой переменной для передачи в родительский конструктор:

class ExtrudedCircle extends ExtrudedShape
{
    function ExtrudedCircle(depth:int)
    {
        super(HIDDEN_KEY, depth);
    }
}

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

abstract class ExtrudedShape
{
    private int depth { get; private set; }
 
    ExtrudedShape(int depth)
    {
        this.depth = depth;
    }
 
    int Area
    {
        get { return 0; }
    }
 
    int Volume
    {
        get { return depth * Area; }
    }
}

Обратите внимание на использование ключевого слова abstract вначале класса. Оно означает, что компилятор не должен разрешать создание данного класса напрямую. Данный подход не требует дополнительного кода или “обходных путей”, которые необходимы в AS3 (производным классам не нужно использовать HIDDEN_KEY, а их инициализация и объявление выглядит точно так же, как и у других классов):

class ExtrudedCircle : ExtrudedShape
{
    ExtrudedCircle(int depth)
        : base(depth)
    {
    }
}

Абстрактные функции

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

class ExtrudedShape
{
    private var depth:int;
 
    protected static const HIDDEN_KEY:Object = {};
 
    function ExtrudedShape(ABSTRACT:Object, depth:int)
    {
        if (ABSTRACT != HIDDEN_KEY)
        {
            throw new ArgumentError("ExtrudedShape is an abstract class");
        }
 
        this.depth = depth;
    }
 
    function get area(): int
    {
        throw new Error("'get area' is an abstract function");
        return 0;
    }
 
    function get volume(): int
    {
        return depth * area;
    }
}

В данном примере класс ExtrudedShape не реализует функционал функции get area, так как он ничего не знает о ней. В данной версии, обращение к функции get area класса ExtrudedShape вызовет ошибку. Данный подход позволяет реализовать абстрактные функции на этапе воспроизведения, но не на этапе компиляции. Например, следующий код будет успешно компилироваться без реализации функции get area:

class ExtrudedCircle extends ExtrudedShape
{
}

Вместо этого, в C# мы можем просто использовать ключевое слово abstract:

abstract class ExtrudedShape
{
    private int depth { get; private set; }
 
    ExtrudedShape(int depth)
    {
        this.depth = depth;
    }
 
    abstract public int Area
    {
        get;
    }
 
    int Volume
    {
        get { return depth * Area; }
    }
}
class ExtrudedCircle : ExtrudedShape
{
    private int area;
 
    override int Area
    {
        get { return area; }
    }
}

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

abstract class GameEntity
{
    abstract void TakeDamage(int damage);
}
 
class Enemy : GameEntity
{
    int health;
 
    override void TakeDamage(int damage)
    {
        health -= damage;
    }
}

Сегодня мы обсудили абстрактные классы и функции, а так же статические инициализаторы. Для закрепления, давайте сравним особенности реализации этого функционала в C# и AS3:

////////
// C# //
////////
 
// Abstract class
abstract class GameEntity
{
    private static int NextID;
 
 
 
    protected int health;
 
    int id;
 
    static GameEntity()
    {
        NextID = 1;
    }
 
    GameEntity(int health)
    {
 
 
 
 
 
        this.health = health;
        this.id = NextID++;
    }
 
    // Abstract property
    bool Friendly
    {
 
        abstract get;
    }
 
    // Abstract function
    abstract void TakeDamage(int amount)
    {
 
    }
}
 
// Non-abstract ("concrete") class
class Enemy : GameEntity
{
    Enemy(int health)
        : base(health)
    {
    }
 
    // Implemented abstract property
    override bool Friendly
    {
        get { return false; }
    }
 
    // Implemented abstract function
    override void TakeDamage(int amount)
    {
        health -= amount;
    }
}

/////////
// AS3 //
/////////
 
// Abstract class - only enforced at run-time
class GameEntity
{
    private static var NEXT_ID:int;
 
    protected static const HIDDEN_KEY:Object = {};
 
    protected var health:int;
 
    var id:int;
 
    // Static initializer
    {
        NEXT_ID = 1;
    }
 
    function GameEntity(ABSTRACT:Object, health:int)
    {
        if (ABSTRACT != HIDDEN_KEY)
        {
            throw new ArgumentError("GameEntity is abstract");
        }
 
        this.health = health;
        this.id = NEXT_ID++;
    }
 
    // Abstract property/getter - only enforced at run-time
    function get friendly(): Boolean
    {
        throw new Error("'get friendly' is abstract");
        return false;
    }
 
    // Abstract function - only enforced at run-time
    function takeDamage(amount:int): void
    {
        throw new Error("takeDamage is abstract");
    }
}
 
// Non-abstract ("concrete") class
class Enemy extends GameEntity
{
    function Enemy(health:int)
    {
        super(HIDDEN_KEY, health);
    }
 
    // Implemented abstract property
    override function get friendly(): Boolean
    {
        return false;
    }
 
    // Implemented abstract function
    override function takeDamage(amount:int): void
    {
        health -= amount;
    }
}

В следующей статье мы поговорим о деструкторах, трюках при работе с перегрузкой конструкторов и о многом другом.

Оставайтесь с нами!

Запись С# для AS3 разработчиков. Часть 4: Абстрактные классы и функции впервые появилась Flashist.

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

Сегодня мы закончим разбираться с классами в C# (с точки зрения AS3 разработчика) и подготовимся к следующей статье, в которой мы сможем познакомиться с понятиями, аналогов которых нет в AS3. В текущей статье мы рассмотрим способ реализации:
– геттеров/сеттеров (getter/setter)
– функций и классов, которые нельзя переопределять/наследовать (final)
– констант
– пакетов

Get/Set функции

Давайте начнём с геттеров и сеттеров. Чтобы освежить память, вот, как они выглядели в AS3:

class Person
{
    private var _name:String;
    public function get name(): String
    {
        return _name;
    }
    public function set name(n:String): void
    {
        _name = n;
    }
}

А вот, эквивалент в С#:

class Person
{
    private String _name;
    public String Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name = value;
        }
    }
}

Как мы можем увидеть, в C#, вместо объявления 2 функций, геттер и сеттер объявлены в виде единственной переменной. Правда, эта переменная не заканчивается точкой с запятой (;), а содержит блок в виде фигурных скобок, внутри которого есть 2 части: get{} и set{}. Эти части являются геттер и сеттер функциями. Внутри сеттера у вас будет доступ к новому ключевому слову value, оно представляет собой значение, которое должно быть установлено и вам не нужно объявлять его, как это приходилось делать в AS3. Если не брать в расчёт это отличие в синтаксисе, геттеры и сеттеры работают одинаково в C# и AS3.

C# предоставляет возможность использовать сокращённую запись для подобных функций, позволяя избежать написание лишнего кода для простых функций:

class Person
{
    public String Name { get; set; }
}

Использование этой конструкции автоматически создаст переменную _name и геттер/сеттер функции, как в примере выше. Но что, если вам не нужна функция-сеттер? Просто уберите её:

class Person
{
    public String Name { get; }
}

Скорее всего, вам необходимо будет, как минимум, предоставить возможность классу Person устанавливать значения этой переменной. Для этого сеттер может быть объявлен private:

class Person
{
    public String Name { get; private set; }
}

И ещё, немного терминологии C#: поля класса, у которых есть get и/или set функции (Name), называются “свойства”. Переменные, которые используются для хранения этих данных (_name), называются “вспомогательные поля”.

Final/sealed функции

А теперь, давайте поговорим о final функциях, которые не могут быть переопределены (AS3):

class Person
{
    final function print(): void
    {
        trace("I'm a Person");
    }
}
 
class MyPerson extends Person
{
    // illegal
    override function print(): void
    {
        trace("I'm not just a Person, I'm a MyPerson too");
    }
}

С# предоставляет идентичный функционал, используя слово sealed:

class Person
{
    sealed void Print()
    {
        Debug.Log("I'm a Person");
    }
}
 
class MyPerson extends Person
{
    // illegal
    override void Print()
    {
        Debug.Log("I'm not just a Person, I'm a MyPerson too");
    }
}

Пакеты и namespace

Пакеты в AS3:

package com.jacksondunstan.examples
{
    class Person
    {
    }
}

В C#, пакеты называются namespace, вот и всё:

namespace com.jacksondunstan.examples
{
    class Person
    {
    }
}

Чтобы получить доступ к пакету внутри .as файла, вы можете импортировать пакет:

import com.jacksondunstan.examples;
 
class Printer
{
    function print(person:Person): void
    {
        trace("person has name: " + person.name);
    }
}

В C# вы используете ключевое слово using для namespace:

using com.jacksondunstan.examples;
 
class Printer
{
    void Print(Person person)
    {
        Debug.Log("person has name: " + person.name);
    }
}

Константы и readonly переменные

И напоследок, давайте поговорим о константах. Вот, как в AS3 может быть создано поле, которое нельзя изменить после объявления:

class Person
{
    private static const MIN_TEEN_AGE:int = 13;
    private static const MAX_TEEN_AGE:int = 19;
    var age:int;
 
    function IsTeen(): Boolean
    {
        return age >= MIN_TEEN_AGE && age <= MAX_TEEN_AGE;
    }
}

Вот, как это можно сделать в C#:

class Person
{
    private const int MinTeenAge = 13;
    private const int MaxTeenAge = 19;
    int Age;
 
    bool IsTeen()
    {
        return Age >= MinTeenAge && Age <= MaxTeenAge;
    }
}

Важный нюанс: в C# для констант можно использовать только базовые типы (например, int) и строки. Это необходимо потому, что подобное поле не будет существовать на самом деле, вместо этого, везде, где оно используется, будут подставлены значения этого поля. Так же, это означает, что подобные поля автоматически становятся статическими (static), и их не нужно объявлять, как static отдельно. После компиляции класс Person в C# будет выглядеть следующим образом:

class Person
{
    int Age;
 
    bool IsTeen()
    {
        return Age >= 13 && Age <= 19;
    }
}

В AS3 ключевое слово const использовалось исключительно для проверки на этапе компиляции и не приводило к изменениям/подстановкам в коде. Если необходимо добиться похожего поведения в C# или необходимо использовать не базовый тип данных (например, Person), то нужно использовать ключевое слово readonly:

class Person
{
    static readonly Person Newborn = new Person(0);
    readonly int Age;
 
    Person(int age)
    {
        Age = age;
    }
}

В примере выше присутствует 2 readonly поля:

1) Newborn – поле, которое было объявлено с ключевым словом static (readonly поля, в отличии от констант, не обязательно являются static). Данное поле будет инициализировано в том месте, где оно объявлено (по-аналогии с константами в AS3).

2) Age – поле, которое является readonly, но не является static. Оно будет инициализировано в конструкторе.

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

////////
// C# //
////////
 
// Collection of classes being used by this file
using org.apache.coolstuff;
 
// Collection of classes
namespace com.jacksondunstan.examples
{
    class Person
    {
        // Complex getters and setters
        private String _name;
        String Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
            }
        }
 
        // Simple getters and setters
        int Age { get; set; }
 
        // Read-only field
        readonly int ID;
 
        // Inlined field
        const int AdultAge = 18;
 
        // Function that can't be overridden
        sealed void Print()
        {
            Debug.Log("Name: " + name + ", ID: " + ID);
        }
    }
}

/////////
// AS3 //
/////////
 
// Collection of classes being used by this file
import org.apache.coolstuff;
 
// Collection of classes
package com.jacksondunstan.examples
{
    class Person
    {
        // Complex getters and setters
        private var _name:String;
        function get name(): String
        {
            return _name;
        }
        function set name(value:String): void
        {
            _name = value;
        }
 
 
 
 
        // Simple getters and setters
        // {not supported. use complex instead.}
 
        // Read-only field
        const var ID:int;
 
        // Inlined field
        // {not supported. use compile-time constants via command-line instead.}
 
        // Function that can't be overridden
        final function print(): void
        {
            trace("Name: " + name + ", ID: " + ID);
        }
    }
}

В следующей статье мы, наконец-то, начнём рассматривать понятия, аналогов которых нет в AS3.

Не переключайте канал!

Запись С# для AS3 разработчиков. Часть 3: get, set, sealed, using, const, readonly впервые появилась Flashist.

Перевод статьи From AS3 to C#, Part 2: Extending Classes and Implementing Interfaces

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

Начнём с наследования классов. Вот, как это выглядит в AS3:

class Shape
{
}
 
class Circle extends Shape
{
}

А вот, как это выглядить в C#:

class Shape
{
}
 
class Circle : Shape
{
}

Как вы могли заметить, вместо ключевого слова extends, используется : (двоеточие).

Похожим образом обстоят дела с реализацией интерфейсов. Как это выглядит в AS3:

interface IHasArea
{
    function GetArea(): int;
}
 
interface IRound
{
    function GetSmoothness(): int;
}
 
class Shape
{
}
 
class Circle extends Shape implements IHasArea, IRound
{
    function GetArea(): int
    {
        return 33; // TODO рассчитать
    }
 
    function GetSmoothness(): int
    {
        return 44; // TODO рассчитать
    }
}

Та же самая структура кода, но в C#:

interface IHasArea
{
    int GetArea();
}
 
interface IRound
{
    int GetSmoothness();
}
 
class Shape
{
}
 
class Circle : Shape, IHasArea, IRound
{
    int GetArea()
    {
        return 33; // TODO рассчитать
    }
 
    int GetSmoothness()
    {
        return 44; // TODO рассчитать
    }
}

В С#, двоеточие используется вместо ключевого слова implements, по такому же принципу, как и с extends. Описание интерфейсов в C# похоже на описание оных в AS3.

Пример расширения интерфейсов в AS3:

interface ISuper
{
}
 
interface ISub extends ISuper
{
}

Скорее всего, вы уже догадываетесь, как этот код выглядит в C#…

interface ISuper
{
}
 
interface ISub : ISuper
{
}

Давайте разберёмся, как описываются отношения между родительскими и дочерними классами/интерфейсами в C#. В AS3 вы можете использовать ключевые слова this и super в любых не статических функциях, чтобы обратиться к экземпляру текущего класса (this) или к экземпляру родительского класса (super). Например:

class Polygon
{
    var numVertices:uint;
 
    function printDescription(): String
    {
        return "Polygon (numVertices=" + numVertices + ")";
    }
}
 
class Triangle extends Polygon
{
    var color:String;
    var polygonDescriptionAtConstructionTime:String;
 
    function Triangle(color:String)
    {
        this.color = color;
        polygonDescriptionAtConstructionTime = super.printDescription();
    }
 
    function printDescription(): String
    {
        return "Triangle (color=" + color + ")";
    }
}

В данном примере, ключевое слово super обращается исключительно к переменным и функциям класса Polygon. Такой способ обращения к функциям используется крайне редко, но иногда он может помочь избежать в коде двусмысленностей, относительно того, какая из функций printDescription будет вызвана. Если бы в данном примере не использовалось слово super, то вызывалась бы функция printDescription класса Triangle, т.к. поиск в текущем классе происходит раньше родительского класса.

Ключевое слово this обращается исключительно к переменным и функциям класса Triangle. В примере, this используется, чтобы компилятор понимал, что нужно обрщаться к переменной color класса Triangle, а не к одноимённой переменной, передаваемой в конструктор.

А теперь версия на C#:

class Polygon
{
    uint NumVertices;
 
    String PrintDescription()
    {
        return "Polygon (numVertices=" + numVertices + ")";
    }
}
 
class Triangle : Polygon
{
    String Color;
    String PolygonDescriptionAtConstructionTime;
 
    Triangle(String color)
    {
        this.Color = color;
        PolygonDescriptionAtConstructionTime = base.printDescription();
    }
 
    String printDescription()
    {
        return "Triangle (color=" + color + ")";
    }
}

Эти два примера очень похожи, за исключением того, что в C#, вместо ключевого слова super, используется ключевое слово base. В C# base выполняет те же функции, что и super в AS3.

Другой пример использования super в AS3 (вызов родительского конструктора):

class Polygon
{
    var numVertices:uint;
 
    function Polygon(numVertices:uint)
    {
        this.numVertices = numVertices;
    }
}
 
class Triangle extends Polygon
{
    var color:String;
 
    function Triangle(numVertices:uint, color:String)
    {
        super(numVertices);
        this.color = color;
    }
}

C# версия:

class Polygon
{
    uint NumVertices;
 
    Polygon(uint numVertices)
    {
        NumVertices = numVertices;
    }
}
 
class Triangle : Polygon
{
    String Color;
 
    Triangle(uint numVertices, String color)
        : base(numVertices)
    {
    }
}

Помимо того, что мы снова заменили super на base, вы можете заметить, что вызов происходит до выполнения кода в конструкторе (до фигурных скобок {}). Так же, вызову конструктора родительского класса предшествует двоеточие (:). Обратите внимание, что в конце строки вызова, не ставится точка с запятой (;).

Давайте разберём, как в AS3 сделать так, чтобы класс нельзя было расширить:

final class FinalClass
{
}
 
// Этот класс не будет компилироваться
class DerviedClass extends FinalClass
{
}

Похожий функционал в C#:

sealed class FinalClass
{
}
 
// Этот класс не будет компилироваться
class DerviedClass : FinalClass
{
}

В данном случае различия между C# и AS3 состоят только в названии ключевых слов. В C# класс, котоырй нельзя расширить обозначается ключевым словом sealed, а в AS3 для этого используется final, но эффект – абсолютно одинаковый.

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

////////
// C# //
////////
 
// Interface
interface IShape
{
    String GetDescription();
}
 
// Sub-interface (one that extends another)
interface IPolygon : IShape
{
    uint GetNumEdges();
}
 
// Class
class Shape
{
    String Name;
 
    Shape(String name)
    {
        Name = name;
    }
}
 
// Derived class (one that extends another)
class Circle : Shape
{
    int Radius;
 
    Circle(String name, int radius)
        : base(name)
    {
        Radius = radius;
    }
}
 
// Derived class that also implements an interface
class Triangle : Shape, IPolygon
{
    Triangle()
        : base("Triangle")
    {
    }
 
    uint GetNumEdges()
    {
        return 3;
    }
 
    String GetDescription()
    {
        return "A three-sided polygon";
    }
}
 
// Class that can't be extended
sealed class NoDerivatives
{
}

/////////
// AS3 //
/////////
 
// Interface
interface IShape
{
    function getDescription(): String;
}
 
// Sub-interface (one that extends another)
interface IPolygon extends IShape
{
    function getNumEdges(): uint;
}
 
// Class
class Shape
{
    var name:String;
 
    function Shape(name:String)
    {
        this.name = name;
    }
}
 
// Derived class (one that extends another)
class Circle extends Shape
{
    var Radius:int;
 
    function Circle(name:String, radius:int)
    {
        super(name);
        Radius = radius;
    }
}
 
// Derived class that also implements an interface
class Triangle extends Shape implements IPolygon
{
    function Triangle()
    {
        super("Triangle");
    }
 
    function GetNumEdges(): uint
    {
        return 3;
    }
 
    function GetDescription(): String
    {
        return "A three-sided polygon";
    }
}
 
// Class that can't be extended
final class NoDerivatives
{
}

На этом мы сегодня закругляемся. В следующей статье мы поговорим о геттерах и сеттерах (getter/setter) и закончим описание основ классов. После чего, мы сможем перейти к нюансам C#, аналогов которых нет в AS3.

Запись С# для AS3 разработчиков. Часть 2: Расширение классов и реализация Интерфейсов впервые появилась Flashist.

Перевод статьи 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;
 
	// By the way, single-line comments are the same...
	// Кстати, однострочные комментарии работают так же, как и в 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.

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

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