public static void Main(string[] args) {
int a;
Add(out a);
Console.WriteLine(a);
}
public static void Add(out int a) {
a = 100;
}
Еще одним удачным способом в C# является сокрытие метода. Концепция сокрытия метода обсуждалась ранее в этом приложении. Она позволяет иметь такую же сигнатуру, как и у метода базового класса, не переопределяя базовый метод. Это делается с помощью ключевого слова new, которое помещается перед реализацией метода. Отметим, что, как описано ранее, отсутствие ключевого слова new в экземпляре this по прежнему создаст то же поведение и не будет вызывать ошибки компиляции, будет создано только предупреждение. Однако, лучше его использовать, по крайней мере для того, чтобы знать, где сталкиваются сигнатуры этих методов. Вот пример сокрытия метода:
namespace Sample {
using System;
public class SuperHider {
public string Test() {
return "parent test";
}
}
public class Hider: SuperHider {
public Hider() {
}
new public string Test() {
return "child test";
}
}
}
Следующий листинг показывает, как вызывается любая версия метода Test():
Rider hider = new Hider();
Console.WriteLine(hider.Test());
Console.WriteLine(((SuperHider)h).Test());
Результатом этих вызовов будет:
Child test
Parent test
Сокрытие методов существенно отличается от переопределения методов. В C# переопределение метода является явной процедурой. Это отличается от подхода Java, где переопределение является поведением по умолчанию, когда сигнатура члена суперкласса совпадает с сигнатурой в его подклассе. Чтобы переопределить метод базового класса в C#, необходимо пометить его как virtual. К счастью нельзя просто изменить класс Hider, что показано в данном примере:
namespace Samples {
using System; public class SuperHider {
public string Test() {
return "parent test";
}
}
public class Hider: SuperHider {
public Hider() {
}
public override string Test() {
return "child test";
}
}
}
Этот код не будет компилироваться. Надо сначала проинформировать компилятор, что указанный метод, в данном случае SuperHider.test(), может быть переопределен классами потомками. Для этого в C# используется ключевое слово virtual, а методы, к которым применяется этот модификатор, называются виртуальными методами. Возьмем пример подходящего способа выполнения переопределения метода:
namespace Samples {
using System;
public class SuperHider {
public virtual string Test() {
return "parent test";
}
}
public class Hider: SuperHider {
public Hider() { }
public override string Test() {
return "child test";
}
}
}
Достоинством переопределения метода является гарантия, что будет вызван самый производный метод. Взгляните на код вызова, представленный ниже, такой же код, что и в примере сокрытия метода, создает два других значения:
Hider hider = new Hider();
Console.WriteLine(hider.Test());
Console.WriteLine(((SuperHider)hider).Test());
Так как гарантировано, что всегда вызывается версия test из Hider, мы знаем, что компиляция и выполнение кода всегда дадут следующие результаты:
Child test
Child test
Единственное синтаксическое различие между абстрактными классами в Java и C# состоит в размещении ключевого слова abstract. Как и в Java, определение абстрактных методов в C# делает класс абстрактным.
Раньше методы get() и set() использовались для доступа к внутренним атрибутам объекта. Сегодня C# вводит концепцию аксессоров (accessor), которые предоставляют безопасный и гибкий способ получения внутри лих полей, Существует два типа аксессоров. Аксессор get разрешает чтение внутренних полей объекта, а аксессор set позволяет изменять значение внутреннего поля. Ключевое слово value представляет новое значение справа от знака равенства во время присваивания. Отсутствие соответствующего аксессора в объявлении свойства приведет к тому, что свойство будет предназначаться либо только для чтения (нет set), либо только для записи (нет get):
namespace Samples {
using System;
public class Properties {
private int age;
private string name;
public Properties(string name) {
this.name = name;
}
public int Age {
get {
return age;
}
set {
age = value;
}
}
public string Name {
get {
return name;
}
}
}
}
В указанном примере свойство Age имеет аксессоры get и set, поэтому можно читать или записывать в это свойство. Свойство Name, однако, создается один раз, когда создается новый экземпляр объекта свойств, после чего можно только прочитать значение Name. Свойства доступны, как если бы они были открытыми полями:
Properties props = new Properties("john");
props.Age = 21;
Console.WriteLine("My name is {0}, and I am {1} years old.", props.Name, props.Age);
Результатом этого кода является:
My name is john, and I am 21 years old.
Примечание. Имена свойств должны быть уникальными.
Как предполагает название, индексаторы позволяют легко индексировать атрибуты объектов. Предположим, что нам необходимо предоставить аналогичную функциональность, не создавая двух отдельных свойств. Можно проиндексировать имеющиеся поля, чтобы они были доступны с помощью некоторого ключа (ключ является значением, используемым для доступа к индексу, для массивов ключ является целым значением), или извлечь объявления двух свойств в примере выше и заменить их следующим:
public string this[string a] {
get {
if (a.Equals("Age")) return int.ToString(age);
else if (a.Equals("Name")) return name;
else {
throw new Exception("can only accept 'name' or 'age' key");
}
}
set {
if (a.Equals("Age")) age = int.Parse(value);
else {
throw new Exception(a + " is read only or does not exist");
}
}
}
Затем можно обратиться к атрибутам свойств следующим образом:
Properties props = new Properties("john");
props["Age"] = "21";
Console.WriteLine("my name is {0}, I am {1} years old.", props["Name"], props["Age"]);
В результате мы получим:
My name is john, I am 21 years old.
События C# предоставляют значительно более надежный и гибкий паттерн наблюдателя, чем в Java. Более того, они могут быть объявлены либо как поля, либо как свойства. Создание события является процессом из трех частей. Сначала мы получаем делегата, а затем событие, связанное с этим делегатом, и наконец, когда происходит некоторое действие, вызывается событие.
Проиллюстрируем это, удаляя исключения из класса Properties и используя вместо этого события. Наиболее привлекательным свойством событий является гибкость, которая наблюдается при использовании модели делегата. По сути можно использовать любую специальную сигнатуру, которую желательно связать с событием, а затем подписчик на событие должен предоставить целевой метод, который соответствует требуемому списку параметров. Создание этой специальной сигнатуры начинается с определения делегата в коде пространства имен. Для класса Properties необходимо, чтобы он инициировал строковые события, аналогичные исключениям, которые необходимо порождать:
public delegate void ObservableDelegate(string message);
Затем объявляется delegate как поле event в классе:
public event ObservableDelegate ExceptionEventListener;
Наконец, переписывается реализация индексатора для активизации приемника события всякий раз, когда возникает условие исключения:
public string this[string а] {
get {
if (a.Equals("Age")) {
return int.ToString(age);
} else if (a.Equals("Name")) {
return name;
} else {
ExceptionEventListener(can only accept 'name' or 'age' key");
return null; // поток программы продолжается после того, как
// событие было инициировано, поэтому необходимо
// вернуть значение. В этом случае, так как ключ
// является недействительным (не 'name' или 'age'),
// возвращается null, указывая отсутствие значения
