По долгу службы и просто для своего удовольствия и интереса в нерабочее мне приходится переводить на русский язык стандарт языка C#, а в последствии возможно и спецификайции на CLI...
Работа только-только начата, но тем не менее есть некоторые результаты.
Предлагается обсудить то, что получилось в процессе перевода, а также все что связанно с этой темой.
Принимаются все предложения, исправления, замечания, пожелания, указания, корректировки и так далее...
Английский вариант стандарта можно скачать отсюда или отсюда
Если кому-то станет интересно, я могу выслать Word'овский файл с текущей версией перевода - там все оформлено гораздо красивее и читать приятнее
Перевод я буду выкладывать сюда по мере продвижения работы, а пока первая часть:

-------------------------------------------------------------------
Спецификация языка C#

Краткая история

Этот Международный Стандарт основывается на предложении Hewlett-Packard, Intel и Microsoft, которое описывает язык, называемый C#, разработанный Microsoft. Главными разработчиками языка были Anders Hejlsberg, Scott Wiltamuth и Peter Golde. Первая широко распространенная реализация C# была выпущена в свет компанией MicroSoft в июле 2000 года, как часть платформы .NET FrameWork.
В сентябре 2000 года была сформирована 2-я исследовательская группа Технического комитета 39 ECMA, для того чтобы разработать стандарт языка С#. Параллельно была сформирована 3-я рабочая группа, для того чтобы разработать стандарт библиотеки и условий выполнения программы, называемой Common Language Infrastructure (CLI). (CLI основывается на подмножестве .NET Framework.). Хотя реализация С# компании MicroSoft, зависит от CLI для библиотек и поддержки во время исполнения, другие реализации C# в CLI не нуждаются, при условии, что они поддерживают иной путь достижения того минимума свойств CLI, который требуется настоящим Стандартом.
При разработке C# ставились следующие требования:
- подразумевается, что C# это простой, современный, универсальный, объектно-ориентированный язык программирования;
- язык и реализации должны обеспечивать поддержку таких принципов создания программного обеспечения, как: строгий контроль типов данных, проверку границ массивов, обнаружение попыток использования неинициализированных переменных и автоматическую сборку мусора. Важны также устойчивость к сбоям и производительность программ;
- язык предполагается использовать для разработки программных компонент, пригодных для установки в распределенных средах;
- очень важна переносимость исходного кода, также как и переносимость программ, особенно для тех программистов, которые уже знакомы с С и С++.
- очень важна поддержка независимости от особенностей языка и стандартов страны пользователя;
- предполагается, что C# - язык подходящий для написания приложений как для ведущих, так и для встроенных систем, размеры которых варьируются от очень больших, использующих усложненные операционные системы до очень маленьких, имеющих специализированные функции.
- хотя предполагается, что приложения C# будут экономны в требованиях к памяти и мощности процессора , язык не претендует на конкуренцию по производительности и размеру с С или языками низкого уровня.
Разработка настоящего Стандарта начата в Ноябре 2000 года.
Ожидается, что в будущем стандарт будет пересмотрен, преимущественно для добавления новых функций.
Одобрен как ECMA Standart в окончательной сборке в Декабре 2000 года.



1. Сфера рассмотрения

Этот раздел является информативным

Настоящий Международный стандарт устанавливает форму интерпретации программ написанных на языке программирования C#. Он определяет:
- представления программ, написанных на C#;
- синтаксис и ограничения языка C#;
- семантические правила, для интерпретации программ, написанных на C#;
- ограничения и препятствия, налагаемые согласованной реализацией C#.
Настоящий Стандарт не определяет:
- механизм, с помощью которого программы написанные на C#, преобразуются для использования в системах обработки данных;
- механизм, с помощью которого приложения C# запускаются для использования в системах обработки данных;
- механизм, с помощью которого преобразуются входные данные для использования в приложениях C#;
- механизм, с помощью которого преобразуются выходные данные после их синтеза приложением С#;
- размер или сложность программ и их данных, если они превосходят возможности некоторой специфичной системы обработки данных или возможности отдельного процессора;
- минимальные требования к системе обработки данных, способной поддерживать соответствующую реализацию.

Конец информативного текста

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

Текст в Международном Стандарте, определяющий требования считается нормативным. Весь остальной текст является информативным, т.е. исключительно с информационным смыслом. Кроме того, нормативный текст разделяется на две категории: требуемую и условную. Условно нормативный текст определяет требования для предопределенных свойств, т.е. тех, для которых синтаксис и семантика должны в точности соответствовать спецификации.
Если какое-либо требования Международного Стандарта нарушено, то поведение не определено. Неопределенное поведение определяется в Международном Стандарте словами “Неопределенное поведение” или отсутствием любого явно определенного поведения. Нет никакого различия в силе приведенных выше трех терминов, все они описывают то, что поведение не определено.
Строго согласованная программа должна использовать только те свойства языка, которые описаны в Стандарте как требуемые. Это означает, что строго согласованная программа не может использовать условно нормативные свойства. Такая программа является независимой от любого не специфицированного, неопределенного или зависящего от реализации поведения.
Согласованная реализация C# должна допускать любую строго согласованную программу.
Согласованная реализация C# должна обеспечивать и поддерживать все типы, значения, объекты, свойства, методы, программный синтаксис и семантику, описанные в Международном Стандарте.
Согласованная реализация C# должна интерпретировать символы в соответствии со стандартом Unicode версии 3.0 или более поздней, а также стандартом ISO/IEC 10646-1. Согласованные реализации должны допускать любой файл исходного кода в стандарте Unicode, закодированный с помощью кодировочной таблицы UTF-8.
Согласованная реализация C# не может успешно транслировать исходный код, содержащий препроцессорную директиву #error, если тольно это не чать группы, пропущенной при условной компиляции.
Согласованная реализация C# должна генерировать как минимум одно диагностическое сообщение или любое отрицательное требование (определенное как “должно” (“shall”), “не должно” (“shall not”), “ошибка” (“error”) или “предупреждение” (“warning”)), за исключением того что это требование помечено словами “диагностика на требуется” (“no diagnostic is required”).
Согласованную реализацию C# допускается снабжать дополнительными типами, значениями, объектами, методами и свойствами сверх тех, что описаны в Международном стандарте, при условии, если только они не изменяют поведения строго согласованных программ. Согласованные реализации нуждаются в диагностике программ, использующих расширения, плохо согласующиеся с Международным Стандартом. Тем не менее такие реализации могут компилировать и исполнять подобные программы. (Возможность иметь расширения предполагает, что Согласованная реализация не резервирует никаких идентификаторов, кроме тех, что явно зарезервированы в Международном Стандарте).
Согласованная реализация C# должна сопровождаться документом, в котором описаны все характеристики, зависящие от реализации, и все расширения.
Согласованная реализация C# должна поддерживать библиотеку классов, описанную в §D. Эта библиотека включена в Международный Стандарт в качестве приложения.
Согласованная программа, это такая, которая допускается согласованной реализацией. (Такая программа может содержать расширения и условно нормативные черты).

3. Ссылки

Следующие документы содержат условия, которые через ссылки составляют условия Международного Стандарта. Для датируемых ссылок более поздние поправки или исправления для любых публикаций не применимы. Тем не менее, некоторые стороны соглашений, основанных на Международном Стандарте, поддерживают исследование возможности применения более свежих изданий нормативных документов, обозначенных ниже. Для недатированных ссылок применяется последнее издание нормативного документа. Члены ISO и EIC поддерживают реестр ныне действующих Международных Стандартов.

ECMA-335, 2nd Edition, December 2002, Common Language Infrastructure (CLI), Partition IV: Base
Class Library (BCL), Extended Numerics Library, and Extended Array Library (also published as ISO/IEC
23271:2002).
ISO 31.11:1992, Quantities and units — Part 11: Mathematical signs and symbols for use in the physical
sciences and technology.
ISO/IEC 2382.1:1993, Information technology — Vocabulary — Part 1: Fundamental terms.
ISO/IEC 10646 (all parts), Information technology — Universal Multiple-Octet Coded Character Set (UCS).
IEC 60559:1989, Binary floating-point arithmetic for microprocessor systems (previously designated IEC
559:1989). (This standard is widely known by its U.S. national designation, ANSI/IEEE Standard 754-1985,
IEEE Standard for Binary Floating-Point Arithmetic.)
The Unicode Consortium. The Unicode Standard, Version 3.0, defined by: The Unicode Standard, Version
3.0 (Reading, MA, Addison-Wesley, 2000. ISBN 0-201-61633-5), Unicode Technical Report #15: Unicode
Normalization Forms, and Unicode Technical Report #19: UTF-32.

Следующие ссылки являются информативными

ISO/IEC 9899:1999, Programming languages — C.
ISO/IEC 14882:1998, Programming languages — C++.
ANSI X3.274-1996, Programming Language REXX. (This document is useful in understanding floating-
point decimal arithmetic rules.)

Конец информативных ссылок

4. Определения

Для целей международного стандарта применяются ниже перечисленные определения. Все остальные термины определяются по мере появления курсивным шрифтом или с левой стороны синтаксического правила. Термины явно определенные в Международном стандарте не допускают ссылок на аналогичные термины, определенные где-либо еще. Термины не определенные в Международном стандарте интерпретируются в соответствии с ISO/IEC 2382.1. Математические символы, не определенные в Международном стандарте, интерпретируются в соответствии с ISO 31.11.

Приложение (Application) - ссылка на машинный код, имеющий входную точку (§10.1). При запуске приложения создается новый домен приложения. Несколько различных экземпляров приложения могут существовать в одно и то же время на одной и той же машине и каждое будет иметь свой собственный домен приложения.
Домен приложения (Application domain) – сущность, представляемая как контейнер для состояния приложения, предоставляющая приложению возможность быть изолированным. Домен приложения представляется как некоторый контейнер, в границах которого находятся типы данных, определенные в приложении и библиотеки классов, которые оно использует. Типы, загруженные в один домен приложения, отличны от таких же типов, загруженных в другой домен приложения, а экземпляры объектов прямо не разделяются между доменами приложений. Например, каждый домен приложения содержит свою собственную копию статических переменных типа объекта и статический конструктор типа, который запускается только один раз для каждого домена приложения. Реализации свободны в выборе специфической политики или механизмов создания и удаления доменов приложений.
Параметр (Agument) - выражение в списке, разделенном запятыми, ограниченном круглыми скобками в вызове метода или конструктора экземпляра. Это также называется фактическим параметром (acnual parameter).
Компоновка (Assembly) - один или более файлов, выдаваемых компилятором в результате компиляции программы. Компоновка это скомпонованное множество загружаемых блоков кода и иных ресурсов, которые вместе представляют функциональный модуль. Компоновка может содержать в себе типы, исполняемый код, необходимый для реализации этих типов, а также ссылки на другие компоновки. Физическое представление компоновки не определяется данной спецификацией. По существу, компоновка это выход компилятора.
Поведение (Behavior) - внешнее явление или действие.
Поведение, зависящее от реализации (Behavior, implementation-defined) - не специфицированное поведение, для которого каждая реализация описывает, какой выбор для него сделан.
Неопределенное поведение (Behavior, undefined) - поведение, основанное на использовании непереносимых или ошибочных конструкций или ошибочных данных, на которые Международный Стандарт не накладывает никаких ограничений. Возможно, обработка неопределенного поведения может заключаться в полном игнорировании ситуаций с непредсказуемым результатом, в поступлении во время трансляции или исполнения в документированной манере характеристик среды (с созданием диагностического сообщения или без него), в остановке трансляции или исполнения (с выдачей диагностического сообщения).
Не специфицированное поведение (Behavior, unspecified) – поведение, для которого международный стандарт представляет две или более возможности и не навязывает никаких дополнительных требований, какую выбирать в каждом конкретном случае.
Библиотека классов (Class Library) – компоновка, которая может быть использована другими компоновками. Использование библиотеки классов не является причиной создания нового домена приложения. Вместо этого, библиотека классов загружается в домен приложения, использующий ее. Например, когда приложение использует некоторую библиотеку классов, эта библиотека загружается в домен приложения этого приложения. Если приложение использует библиотеку классов A, которая в свою очередь использует библиотеку классов B, то они обе загружаются в домен приложения.
Диагностическое сообщение (Diagnostic message) – сообщение, принадлежащее к определенному реализаций подмножеству выходных сообщений.
Ошибка компиляции (Error, compile-time) – ошибка, возникающая во время трансляции программы.
Исключение (Exception) – ошибка, условием которой является выход за границы обычно ожидаемого поведения.
Реализация (Implementation) – специфическое множество программных продуктов (запускаемых в специфической среде разработки со специфическими опциями контроля) для трансляции программ, поддерживающее выполнение методов в специфической среде разработки.
Пространство имен (Namespace) – логически организованная система, позволяющая представлять программные элементы, используемые другими программами.
Параметр (Parameter) - переменная, объявленная как часть метода, конструктора экземпляра или определения индексатора, получающая значение при входе в соответствующий метод. Она также называется формальным параметром.
Программа (Program) – один или более исходных файлов, предоставляемых компилятору. По существу, программа – это вход компилятора.
Действительная программа (Program, valid) - программа на языке C#, построенная в соответствии с синтаксическими и семантическими правилами.
Реализация программы (Program Instantition) – выполнение приложения.
Рекомендованная практика (Recomended practice) – спецификация, настоятельно рекомендуемая как соответствующая целям стандарта, но которая может не выполнятся в некоторых реализациях.
Исходный файл (Source file) – упорядоченная последовательность символов Unicode. Исходные файлы, как правило, один в один соответствуют файлам файловой системы, но это соответствие не обязательно.
Небезопасный код (Unsafe code) – код, в котором позволено выполнять операции низкого уровня, такие как объявление и манипулирование с указателями, преобразования между указателями и интегральными типами, взятие адреса переменной. Такие операции предоставляют такие возможности, как обращение к внутренностям операционной системы, доступ к устройствам памяти или реализацию алгоритмов, очень критичных по времени исполнения.
Пердупреждение во время комеиляции (Warning, compile-time) - информационное сообщение, появляющееся во время трансляции программы, которое указывает на потенциально сомнительное использование программной конструкции.

Это сообщение отредактировал(а) Paradox - 1.11.2003, 09:57

А кому это надо?

Что зачит кому надо ? Кому это надо читать, или для чего вообще стандарт нужен, или для чего его на русский переводить ?

Кому вообще надо это знать? Переводить конечно надо! Молодец! Стандарт то нужен ... но вот я не совсем понимял, кто эот наизусть должен выучить? Может это мне надо ... а может и не надо ... объясни пожалуйста

Зачем учить наизусть ? Совсем необязательно...
Для чего это надо ? Ну во первых и естественно по-моему это единственное стоящее ему применение этот стандарт можно использовать как учебное пособие или справочник по языку (не знаю видел ты вообще английский вариант или нет, но если глянешь - то увидишь что там достаточно подробна на примерно 450 страницах изложен синтаксис и семантика языка, а это вообще иногда требуется вспомнить или посмотреть)
Во вторых знание его, или хотя бы знание что такой стандарт есть и где его можно глянуть может помочь в исправлении некоторых ошибок
В третьих - это замечательное пособие для перехода с ++ на #, т.к. явно видно что стандарт писался именно для таких людей
Ну и может быть каждый может найти в нем что-то для себя, и какую-то пользу извлечь для себя

Я выложил только начало - тут действительно муть (определения, история и так далее, возможно это и не надо, но дальше то идет описание самого языка, а это уже интереснее и полезнее)

Сообщение выше - мое

Paradox, понял, не дурак. Тогда давай, переводи! Ждемс

Next Part------------------------------------------
5. Соглашения о нотации

Лексическая и синтаксическая грамматические системы C# разбросаны по всему тексту данной спецификации. Лексическая грамматика определяет то, каким образом символы могут быть сгруппированы в токены (§9.4), минимальные лексические единицы языка. Синтаксическая грамматика определяет то, каким образом токены могут быть сгруппированы, чтобы получить действительную программу на C#.
Грамматические правила включают как терминальные так и нетерминальные символы. В грамматических правилах нетерминальные символы выделяются курсивным шрифтом, а терминальные символы – шрифтом фиксированной ширины. Каждый нетерминал определяется множеством правил. Первая строка в множестве правил это имя нетерминала, за которым следует одно или два двоеточия. Одно двоеточие используется для правил синтаксической грамматики, а два – для правил лексической грамматики. Каждая следующая строка содержит правую часть для тех правил, которые содержат нетерминальный символ в левой части. Например:
class-modifier:
new
public
protected
internal
private
abstract
sealed
определяется нетерминал class-modifier, имеющий семь альтернатив.
Альтернативы обычно перечисляются по одной на строке, как показано выше, за исключением случаев, когда имеется слишком много альтернатив, тогда фраза “one of” предшествует списку альтернатив. Это просто сокращение места на бумаге, чтобы не перечислять каждую альтернативу на отдельной строчке. Например:
decimal-digit: one of
0 1 2 3 4 5 6 7 8 9
эквивалентно
decimal-digit:
0
1
2
3
4
5
6
7
8
9
Нижний индекс “opt” как например identifieropt используется как удобный способ указания того, что символ является опционным. Например:
for-statement:
for ( for-initializeropt ; for-conditionopt ; for-iteratoropt ) embedded-statement
эквивалентно:
for-statement:
for ( ; ; ) embedded-statement
for ( for-initializer ; ; ) embedded-statement
for ( ; for-condition ; ) embedded-statement
for ( ; ; for-iterator ) embedded-statement
for ( for-initializer ; for-condition ; ) embedded-statement
for ( ; for-condition ; for-iterator ) embedded-statement
for ( for-initializer ; ; for-iterator ) embedded-statement
for ( for-initializer ; for-condition ; for-iterator ) embedded-statement
Все терминальные символы понимаются как соответствующие символы Unicode в кодировке ASCII, а не как похожие на другие символы Unicode в иных кодировках.





6. Аббревиатуры и сокращения

Этот раздел является информативным

В Международном Стандарте используются следующие аббревиатуры и сокращения:
BCL – Base Class Library (Базовая библиотека классов), которая представляет типы данных для представления встроенных типов данных, простые операции доступа к файлам, обычные атрибуты, атрибуты безопасности, операции манипулирования со строками, их форматирование, потоки и коллекции.
CLI – Common Language Infrastructure (Общая Языковая Инфраструктура)
CLS – Common Language Specification (Общая Языковая Спецификация)
IEC – the International Electrotechnical Comission (Международная комиссия по Электротехнике)
IEEE – the Institute of Electical and Electronic Engeneers (Институт Электричества и Электроники)
ISO – the International Organization for Standartization (Международная организация стандартов).

Название C# произносится как “Си шарп”.
Название C# пишется как заглавная латинская буква C (U+0043), за которой следует знак # (U+000D).

Конец информативного раздела

7. Общее описание

Этот раздел является информативным

Предполагается, что настоящий Стандарт будет использоваться разработчиками реализаций, учеными, а также разработчиками приложений. В этой связи он содержит значительное количество пояснительного материала, который, строго говоря, не нужен при формальном описании спецификации языка.
Стандарт разделяется на следующие разделы:
1. Вводная часть (разделы 1-7)
2. Обзор языка (раздел 8)
3. Ограничения, синтаксис и семантика языка (разделы 9-25)
4. Приложения
Примеры приводятся для того, чтобы проиллюстрировать возможные формы описываемых конструкций. Ссылки используются для направления читателя к родственным разделам. Заметки используются для того, чтобы дать совет или руководство для разработчиков реализаций или программистов. Приложения предоставляют дополнительную информацию и обобщают информацию, разбросанную по Международному Стандарту.
Разделы 2-5, 9-24, начало 25 и D представляют нормативную часть настоящего Стандарта; весь 25 раздел, за исключением начала, является условно нормативным; Краткая история, разделы 1, 6-8, приложения A, B, C и большая часть D, заметки, примеры и указатели являются информативными.
Кроме тех разделов и приложений, которые являются информативными, информативный текст, содержащийся внутри нормативного, обозначается двумя способами:
1. [Example: Следующий пример… фрагмент кода, возможно с некоторыми пояснениями end example] .
2. [Note: Пояснения … end note]

Конец информативного текста


8. Обзор языка

Этот раздел является информативным

C# (произносится как “Си шарп”) является простым, современным, объектно-ориентированным, типо-безопасным языком программирования. Он покажется знакомым для программистов, пишущих на C и С++. C# объединяет в себе высокую производительность языков Быстрой Разработки Приложений (Rapid Application Development – RAD) и мощность С++.
Оставшаяся часть этого раздела описывает важнейшие черты языка. В то время как последующие главы детально и порой в математической манере описывают правила и исключения, в этой главе приводится краткое и доходчивое описание. Ее цель – дать читателю представление о языке, которое облегчит написание первых программ и чтение последующих глав.

8.1. Начало
Каноническая программа “Hello, World!” может быть написана следующим образом:

using System;
class Hello
{
static void Main() {
Console.WriteLine("hello, world");
}
}

Исходный код программы на C# хранится в одном или нескольких исходных файлов с расширением .cs, как например hello.cs. При использовании компилятора, встроенного в командную строку, такая программа может быть скомпилирована с помощью команды:
csc hello.cs
в результате будет создано приложение с именем hello.exe. При запуске, вывод приложения будет следующим:
hello, world
Исследуем более подробно текст этой программы:
- using System; директива, указывающая ссылку на пространство имен System, представленное в библиотеке классов CLI. Это пространство имен содержит класс Console, на который имеется ссылка в методе Main.Пространства имен представляют иерархическую структуру для организации элементов одной или более программ. Директива использования позволяет явное использование типов, являющихся членами пространства имен. “Hello, world” использует Console.WriteLine как более короткую запись для System.Console.WriteLine.
- Метод Main является членом класса Hello. Он имеет модификатор static и является методом класса, а не экземпляра.
- Точкой входа для приложения является метод, вызываемый в начале исполнения приложения - это всегда статический метод Main.
- Вывод программы “Hello, world” производится с использованием библиотеки классов. Настоящий Стандарт не включает описание этой библиотеки, вместо этого в нем содержится ссылка на библиотеку классов, предоставляемую CLI.
Для разработчиков на C и С++ будет интересно заметить, что некоторые вещи не появились в программе “Hello, world”:
- Программа не использует глобальный метод Main. Методы и переменные не поддерживаются на глобальном уровне. Такие элементы всегда содержаться внутри определения типа (т.е. класса или структуры).
- Программа не использует операторы “::” или “->”. “::” не является оператором вовсе, а “->” используется только в небольших фрагментах программы (которые находятся внутри небезопасного кода).
- Программа не содержит заблаговременных объявлений. Заблаговременные объявления вообще не нужны, не важен также и порядок объявлений.
- Программа не использует #include для импортирования текстов программ. Зависимости между программами управляются символическим, а не текстовым образом. Это помогает устранению препятствий между приложениями, написанными с использованием нескольких языков. Например класс Console не обязательно должен быть написан на C#.

8.2. ТипыC# поддерживает два вида типов данных: типы-значения и ссылочные типы. Типы-значения включают в себя простые типа (такие как int, char и float), типы-перечисления и структуры. К ссылочным типам относятся классы, интерфейсные типы, делегируемые типы и массивы.
Типы-значения отличаются от ссылочных типов тем, что переменные типов-значений содержат свое значение непосредственно внутри переменной, а переменные ссылочных типов хранят только ссылку на объект. Для ссылочных типов возможна ситуация когда две переменных ссылаются на один и тот же объект, таким образом возможно что, операции над одной переменной затронут объект, на который ссылается другая переменная. Для типов-значений переменные содержат свою собственную копию данных, и при операциях над одной невозможно затронуть другую.
Пример:
using System;
class Class1
{
public int Value = 0;
}
class Test
{
static void Main() {
int val1 = 0;
int val2 = val1;
val2 = 123;
Class1 ref1 = new Class1();
Class1 ref2 = ref1;
ref2.Value = 123;
Console.WriteLine("Values: {0}, {1}", val1, val2);
Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
}
}
показывает эту разницу. Вывод имеет следующий вид:
Values: 0, 123
Refs: 123, 123
Присваивание в локальную переменную var1 не оказывает воздействия на локальную переменную var2, потому что эти переменные являются переменными типа-значения (типа int), и каждая переменная хранит свои собственные данные. Напротив, присваивание ref2.Value = 123 действует на объект, на который ссылаются как ref2 так и ref1.
Строки
Console.WriteLine("Values: {0}, {1}", val1, val2);
Console.WriteLine("Refs: {0}, {1}", ref1.Value, ref2.Value);
заслуживают дополнительного комментария, так как они демонстрируют возможности форматирования строк методом Console.WriteLine, который принимает различное число аргументов. Первый аргумент это строка, которая может содержать пронумерованные заполнители, такие как {0} или {1}. Каждый заполнитель ссылается на следующий аргумент, так {0} ссылается на второй аргумент, {1} на третий и так далее. Перед выводом вместо каждого заполнителя подставляется отформатированное значение соответствующего аргумента.
Разработчики могут определять новые типы значения с помощью объявления типа перечисления или структуры, а также новые ссылочные типы м помощью объявления класса, интерфейса или делегата. Пример:
using System;
public enum Color
{
Red, Blue, Green
}
public struct Point
{
public int x, y;
}
public interface IBase
{
void F();
}
public interface IDerived: IBase
{
void G();
}
public class A
{
protected virtual void H() {
Console.WriteLine("A.H");
}
}
public class B: A, IDerived
{
public void F() {
Console.WriteLine("B.F, implementation of IDerived.F");
}
public void G() {
Console.WriteLine("B.G, implementation of IDerived.G");
}
override protected void H() {
Console.WriteLine("B.H, override of A.H");
}
}
public delegate void EmptyDelegate();
иллюстрирует каждый из способов объявления типа данных. Следующие разделы детально описывают объявления типов данных.

8.2.1. Встроенные типы
С# предоставляет множество встроенных типов, большинство из которых будет знакомо разработчикам на С и С++.
Встроенные ссылочные типы это object и string. object это исходный базовый тип для всех остальных типов. Тип string используется для представления значений строк Unicode. Значения типа string неизменны.
Встроенные типы-занчения включают в себя знаковые и беззнаковые интегральные типы, действительные типы, а также типы bool, char и decimal. Знаковыми интегральными типами являются: sbyte, short, int и long; к беззнаковым интегральным типам относятся: byte, ushort, uint и ulong; действительные типы это float и double.
Тип bool используется для представления логических значений: значениями могут быть только true и false. Включение типа bool упрощает написание самодокументированного кода, а также помогает избежать широко распространенной ошибки разработчиков на С++, когда вместо использования “==”, по ошибке используется “=”. В C#, пример
int i = …;
F(i);
if (i = 0) // Bug: the test should be (i == 0)
G();
приведет к ошибке во время компиляции, так как выражение i=0 имеет тип int, а инструкция if нуждается в значении типа bool.
Тип char используется для представления символов Unicode. Переменная типа char представляет один 16-битный символ Unicode.
Тип decimal предназначен для вычислений, в которых ошибки округления, вызываемые операциями с плавающей точкой, недопустимы. Примером могут является такие финансовые операции, как расчет налогов или валютного курса. Тип decimal предоставляет 28 значащих цифр.
Таблица ниже перечисляет все встроенные типы и показывает как писать для них их буквенное значение.
Тип Описание Пример
object Основной базовый тип для всех типов object o = null;
string Строковый тип; строка это последовательность символов Unicode string s = "hello";
sbyte 8-битовый знаковый интегральный тип sbyte val = 12;
short 16-битовый знаковый интегральный тип short val = 12;
int 32-битовый знаковый интегральный тип int val = 12;
long 64-битовый знаковый интегральный тип long val1 = 12;
long val2 = 34L;
byte 8-битовый беззнаковый интегральный тип byte val1 = 12;
ushort 16-битовый беззнаковый интегральный тип ushort val1 = 12;
uint 32-битовый беззнаковый интегральный тип uint val1 = 12;
uint val2 = 34U;
ulong 64-битовый беззнаковый интегральный тип type ulong val1 = 12;
ulong val2 = 34U;
ulong val3 = 56L;
ulong val4 = 78UL;
float Действительный тип одинарной точности type float val = 1.23F
double Действительный тип двойной точности double val1 = 1.23;
double val2 = 4.56D;
bool Логический тип; значениями могут быть только true и false false bool val1 = true;
bool val2 = false;
char Символьный тип, значение – символ Unicode char val = 'h';
decimal Точный десятичный тип с 28 значащими цифрами decimal val = 1.23M;

Каждый из встроенных типов – это короткая запись для типа, поставляемого в составе системы. Например, ключевое слово int это ссылка на структуру System.Int32. Считается хорошим стилем использовать ключевое слово, вместо указания полного наименования системного типа.
Встроенные типы, такие как int в некоторых местах подверглись переработке, но большая часть переработок в точности такая же как соответствующая структура. Перегрузка операторов позволяет разработчикам определять новые типы-структуры, которые ведут себя почти точно также как встроенные типы. Например, структура Digit поддерживает те же математические операции, что и встроенные интегральные типы, но может определять преобразование между Digit и встроенными типами.
Встроенные типы сами используют перегрузку операторов. Например, операторы сравнения “==” и “!=” имеют различную семантику для различных встроенных типов.
- Два выражения типа int считаются равными, если они представляют одно и тоже целое число
- Два выражения типа object считаются равными, если они ссылаются на один и тот же объект или оба равны null
- Два выражения типа string считаются равными, если строки, которые они представляют имеют одинаковую длину и одинаковые символы в соответствующих позициях, или оба равны null.
Пример
using System;
class Test
{
static void Main() {
string s = "Test";
string t = string.Copy(s);
Console.WriteLine(s == t);
Console.WriteLine((object)s == (object)t);
}
}
выведет:
True
False
потому что первое сравнение сравнивает два значения типа string, а второе – два значения типа object. (Заметьте, что когда Стандартная Библиотека производит строковое представление логического значения, как в случае System.WriteLine выше, она использует “True” и “False”, как соответствующие логическим значениям языка C#, представляемыми true и false).

8.2.2. Преобразования
Встроенные типы имеют также встроенные преобразования. Например, существует преобразование между встроенными типами int и long. C# различает два вида преобразований: скрытые преобразования и явные преобразования. Скрытые преобразования применяются, когда преобразование может быть безопасно выполнено без проведения тщательного исследования. Например, преобразование между int и long это скрытое преобразование. Это преобразование всегда выполняется успешно, и в его результате никогда не произойдет потеря информации. В следующем примере:
using System;
class Test
{
static void Main() {
int intValue = 123;
long longValue = intValue;
Console.WriteLine("{0}, {1}", intValue, longValue);
}
}
int неявно преобразуется в long.
Напротив, явное преобразование выполняется с указанием преобразующего выражения. Пример:
using System;
class Test
{
static void Main() {
long longValue = Int64.MaxValue;
int intValue = (int) longValue;
Console.WriteLine("(int) {0} = {1}", longValue, intValue);
}
}
использует явное преобразование для перевода long в int. Вывод этого примера имеет вид:
(int) 9223372036854775807 = -1
потому что происходит переполнение. Преобразующее выражение разрешается применять как при явном, так и при скрытом преобразовании.

8.2.3. Массивы
Массивы могут быть одномерными или многомерными. Поддерживаются как прямоугольные, так и зубчатые массивы.
Одномерный массив это наиболее общий тип. В примере:
using System;
class Test
{
static void Main() {
int[] arr = new int[5];
for (int i = 0; i < arr.Length; i++)
arr = i * i;
for (int i = 0; i < arr.Length; i++)
Console.WriteLine("arr[{0}] = {1}", i, arr[i]);
}
}
создается одномерный массив из значений типа int, инициализируются элементы массива, а затем каждый из них печатается. Выход имеет следующий вид:
arr[0] = 0
arr[1] = 1
arr[2] = 4
arr[3] = 9
arr[4] = 16
Тип int[] используется в предыдущем примере как тип-массив. Типы-массивы записываются, используя имя типа-не-массива, за которым следуют одно или более определений размерности. Пример:
class Test
{
static void Main() {
int[] a1; // single-dimensional array of int
int[,] a2; // 2-dimensional array of int
int[,,] a3; // 3-dimensional array of int
int[][] j2; // "jagged" array: array of (array of int)
int[][][] j3; // array of (array of (array of int))
}
}
иллюстрирует разницу в объявлении локальной переменной, в котором используется тип int, как тип элементов массива.
Массивы – это ссылочные типы, поэтому объявление переменной как массива просто выделяет пространство под ссылку на массив. Действительно массив создается посредством выражений, производящих его инициализации или создание. Пример:
class Test
{
static void Main() {
int[] a1 = new int[] {1, 2, 3};
int[,] a2 = new int[,] {{1, 2, 3}, {4, 5, 6}};
int[,,] a3 = new int[10, 20, 30];
int[][] j2 = new int[3][];
j2[0] = new int[] {1, 2, 3};
j2[1] = new int[] {1, 2, 3, 4, 5, 6};
j2[2] = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9};
}
}
иллюстрирует разницу между выражениями создания массивов. Переменные a1, a2 и a3 указывают на прямоугольные массивы, а переменная j2 указывает на зубчатый массив. Не секрет, что эти термины основаны на форме фигуры, которой представляется массив. Прямоугольный массив всегда имеет вид прямоугольника. Этот прямоугольник задается заданием размерностей каждого измерения массива. Например, длина измерений массива a3 - 10, 20 и 30 соответственно, и очевидно, что массив содержит 10*20*30 элементов.
Напротив, переменная j2 указывает на зубчатый массив, или массив массивов. В частности, j2 указывает на массив массивов из int, или на одномерный массив из int[]. Каждая из этих переменных типа int[] может быть проинициализирована индивидуально, и это позволяет массиву принимать зубчатую форму. В примере каждому int[] дается различная длина. В частности, длина j2[0] равна 3, длина j2[1] равны6, а длина j2[2] равна 9.
[Note: В С++ массив, объявленный как int x[3][5][7] будет считаться трехмерным прямоугольным массивом, в то время как в C# объявления int[][][] объявляет зубчатый массив. end note]
Тип элементов и форма массива, которая может быть прямоугольной или зубчатой, а также число его размерностей являются частью типа-массива. С другой стороны – размер массива, представленный как длина каждого из его измерений не является частью типа-массива. Это расщепление делает очевидным синтаксис языка, когда задание длин измерений производится при инициализации массива, а не при объявлении его типа. Например, в объявлении
int[,,] a3 = new int[10, 20, 30];
имеется тип-массив int[,,] и выражение создания массива new int[10, 20, 30].
Для локальных переменных и объявлений полей возможна короткая форма записи, в которой нет необходимости повторно указывать тип массива. Например:
int[] a1 = new int[] {1, 2, 3};
можно сократить до:
int[] a1 = {1, 2, 3};
без изменения семантики программы.
Контекст, в котором используется инициализатор массива, такой как {1,2,3} определяет тип массива, который инициализируется. Пример:
class Test
{
static void Main() {
short[] a = {1, 2, 3};
int[] b = {1, 2, 3};
long[] c = {1, 2, 3};
}
}
показывает, как одна и та же синтаксическая конструкция может быть использована, для инициализации нескольких различных массивов. Так как контекст требуется для того, чтобы определить тип инициализатора массива, невозможно использовать инициализатор массива в контексте выражения без явного указания типа массива.

[I]8.2.4. Унификация системы типов
C# предоставляет унифицированную систему типов. Все типы, включая типы-значения, наследуются от типа object. Возможно вызывать методы типа object для любых значений, кроме значений примитивных типов, таких как int. В примере:
using System;
class Test
{
static void Main() {
Console.WriteLine(3.ToString());
}
}
производится вызов метода ToString, определенного в object для значения 3. Результатом является “3”.
Пример:
class Test
{
static void Main() {
int i = 123;
object o = i; // boxing
int j = (int) o; // unboxing
}
}
более интересный. Значение типа int может быть преобразовано к object и наоборот. Этот пример показывает как упаковку (boxing), так и распаковку (unboxing). Когда необходимо преобразовать переменную типа-значения к ссылочному типу выделяется объект box, чтобы получить значение, и значение копируется в объект box. Распаковка делает все с точностью наоборот. Когда объект box необходимо преобразовать к его исходному типу-зачению, это значение из box в присвоенное место для хранения.
Такая унификация системы типов обеспечивает типы-значения преимуществами объектности без дополнительных накладок. В программах, в которых не нужно представление значений типа int как объектов, они являются просто 32-битными значениями. В программах, в которых необходимо, чтобы значения типа int вели себя как объекты, эта возможность доступна по требованию. Возможность рассматривать типы-значения как объекты перекидывает мост через пропасть между типами-значениями и ссылочными типами, которая существует во многих языках. Например, класс Stack способен предоставить операции Push и Pop, которые принимают и возвращают значения типа object.
public class Stack
{
public object Pop() {.}
public void Push(object o) {.}
}
Так как C# имеет унифицированную систему типов, класс Stack может быть использован с элементами любого типа, включая такой как int.

Это сообщение отредактировал(а) Paradox - 4.11.2003, 20:08

Думаю, за год управишся.

Всем отправлю после нового года...
Переведено практически все, но в Ворде только то что выложено, так как нет времени набирать...
Мне приходится читать что-то вроде лекций по этому стандарту перевожу писменно только там, где не могу перевести с листа...
Надеюсь в следующем году времени будет побольше - начну набирать...
И еще вопрос: можно набирать перевод дословно и всего стандарта, а можно по смыслу и только важные фрагменты, кроме того набирать можно одним шрифтом, а можно в соответствии со стандартом...
Если делать не все, это будет быстрее - вобщем я специально оставил ссылку на исходник, кому будет мало перевода всегда может глянуть туда...
Так-что я наверное буду набирать по быстрому пути ...
Вы ЗА ? Если да то после нового года постораюсь обновить....

Paradox Конечно лучше сократить. Мой респект, дело нужное.

Модератор: Давайте не будем в этом топике развивать список тех, кто бы хотел получить перевод. Отправляйте письма в приват. За дальнейший флуд буду наказывать