Partial. 9 страница

using System;

class C
{
int i = 123;

public void F() {
Nested n = new Nested(this);
n.G();
}

public class Nested
{
C this_c;

public Nested(C c) {
this_c = c;
}

public void G() {
Console.WriteLine(this_c.i);
}
}
}

class Test
{
static void Main() {
C c = new C();
c.F();
}
}

показан этот способ. Экземпляр C создает экземпляр Nested и передает свой собственный this конструктору Nested, чтобы предоставить последовательный доступ к членам экземпляра C.

10.3.8.5 Доступ к частным и защищенным членам типа-контейнера

Вложенный тип имеет доступ ко всем членам, к которым есть доступ из типа-контейнера, в том числе к членам типа-контейнера с объявленной доступностью private и protected. В примере

using System;

class C
{
private static void F() {
Console.WriteLine("C.F");
}

public class Nested
{
public static void G() {
F();
}
}
}

class Test
{
static void Main() {
C.Nested.G();
}
}

показан класс C, содержащий вложенный класс Nested. Внутри Nested метод G вызывает статический метод F, определенный в C, а F имеет частную объявленную доступность.

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

using System;

class Base
{
protected void F() {
Console.WriteLine("Base.F");
}
}

class Derived: Base
{
public class Nested
{
public void G() {
Derived d = new Derived();
d.F(); // ОК
}
}
}

class Test
{
static void Main() {
Derived.Nested n = new Derived.Nested();
n.G();
}
}

вложенный класс Derived.Nested обращается к защищенному методу F, определенному в Base, базовом классе класса Derived, вызовом через экземпляр класса Derived.

10.3.8.6 Вложенные типы в универсальных классах

Объявление универсального типа может содержать объявления вложенных типов. Параметры типа включающего класса можно использовать внутри вложенных типов. Объявление вложенного типа может содержать дополнительные параметры типа, применяемые только ко вложенному типу.

Каждое объявление типа, содержащееся внутри объявления универсального типа, неявно является объявлением универсального типа. При записи обращения к типу, вложенному в универсальный тип, необходимо указать сформированный тип-контейнер, включая его аргументы типа. Однако изнутри внешнего класса вложенный тип можно использовать без уточнения; тип экземпляра внешнего класса может быть неявно использован при формировании вложенного типа. В следующем примере показаны три разных правильных способа обращения к сформированному типу, созданному из Inner; первые два способа эквивалентны:

class Outer<T>
{
class Inner<U>
{
public static void F(T t, U u) {...}
}

static void F(T t) {
Outer<T>.Inner<string>.F(t, "abc"); // Эти два оператора имеют
Inner<string>.F(t, "abc"); // одинаковый результат

Outer<int>.Inner<string>.F(3, "abc"); // Это другой тип

Outer.Inner<string>.F(t, "abc"); // Ошибка, для Outer требуется аргумент типа
}
}

Хотя это плохой стиль программирования, параметр типа во вложенном типе может скрывать член или параметр типа, объявленный во внешнем типе:

class Outer<T>
{
class Inner<T> // Допустимо, скрывает T в Outer
{
public T t; // Обращается к T в Inner
}
}

10.3.9 Зарезервированные имена членов

Для упрощения лежащей в основе реализации среды выполнения C# для каждого объявления исходного члена, являющегося свойством, событием или индексатором, в реализации должны быть зарезервированы две подписи методов на основе вида объявления члена, его имени и типа. Объявление в программе члена, подпись которого совпадает с одной из этих зарезервированных подписей, даже если лежащая в основе реализация исполняющей среды не использует эти резервирования, является ошибкой времени выполнения.

Зарезервированные имена не вводят объявления, и таким образом не участвуют в поиске членов. Но подписи зарезервированного метода, связанные с объявлением, все же участвуют в наследовании (§10.3.3) и могут быть скрыты с помощью модификатора new (§10.3.4).

Резервирование этих имен служит трем целям:

· разрешить лежащей в основе реализации использовать обычный идентификатор в качестве имени метода для получения или установки доступа к средствам языка C#;

· разрешить другим языкам возможность взаимодействия, используя обычный идентификатор в качестве имени метода для получения или установки доступа к средствам языка C#;

· способствовать тому, чтобы исходный код, принятый одним соответствующим компилятором, был принят и другим, сделав особенности зарезервированных имен членов согласованными по всем реализациям C#.

Объявление деструктора (§10.13) также вызывает резервирование подписи (§10.3.9.1).

10.3.9.1 Имена членов, зарезервированные для свойств

Для свойства P (§10.7) типа T зарезервированы следующие подписи:

T get_P();
void set_P(T value);

Зарезервированы обе подписи, даже если свойство только для чтения или только для записи.

В примере

using System;

class A
{
public int P {
get { return 123; }
}
}

class B: A
{
new public int get_P() {
return 456;
}

new public void set_P(int value) {
}
}

class Test
{
static void Main() {
B b = new B();
A a = b;
Console.WriteLine(a.P);
Console.WriteLine(b.P);
Console.WriteLine(b.get_P());
}
}

класс A определяет свойство P только для чтения, резервируя тем самым подписи для методов get_P и set_P. Класс B производится от A и скрывает обе эти зарезервированные подписи. В результате получается:

123
123
456

10.3.9.2 Имена членов, зарезервированные для событий

Для события E (§10.8) типа делегата T зарезервированы следующие подписи:

void add_E(T handler);
void remove_E(T handler);

10.3.9.3 Имена членов, зарезервированные для индексаторов

Для индексатора (§10.9) типа T со списком параметров L зарезервированы следующие подписи:

T get_Item(L);
void set_Item(L, T value);

Зарезервированы обе подписи, даже если индексатор только для чтения или только для записи.

10.3.9.4 Имена членов, зарезервированные для деструкторов

Для класса, содержащего деструктор (§10.13), зарезервирована следующая подпись:

void Finalize();

10.4 Константы;

Константа – это член класса, представляющий постоянное значение: значение, которое может быть вычислено во время компиляции. Объявление_константы вводит одну или более констант указанного типа.

объявление_константы:
атрибутынеоб модификаторы_константнеоб const тип деклараторы_констант;

модификаторы_констант:
модификатор_константы
модификаторы_констант модификатор_константы