Flex и RIA блоги

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