Пример кода на языке C #.
Примеры по Созданию консольных приложений (Visual C#) доступны по ссылке https://msdn.microsoft.com/ru-ru/library/0fyc0azh.aspx
Пример. Создание консольного приложения Visual C# Console Application.
//директива using с перечислением пространств имен библиотеки классов платформы .NET Framework //определяет префикс System
using System;
// объявление собственного пространства имен
namespace ConsoleApplication2
{
//Класс Program объявлен с единственным членом - статическим методом Main
class Program
{
//Метод Main - точка входа в программу
static void Main(string[] args)
{
string text;
Console.Write("Введите текст\n");
text = Console.ReadLine();
//статический метод WriteLine–класса Console пространства имен System
Console.WriteLine(text);
}
}
}
Результат выполнения программы:
Метод Main объявляется внутри класса или структуры.
Файлы исходного кода С# имеют расширение .cs. C# программы состоят из одного или более исходных файлов. При компиляции C# программ получаются сборки. Сборки имеют расширение .exe или .dll, они реализованы как приложения или как библиотеки.
Общие сведения о системе общих типов (CTS).
Система общих типов определяет способ объявления, использования и управления типами во время выполнения.
Типы и переменные
There are two kinds of types in C#: value types and reference types.
Система общих типов поддерживает две общие категории типов: типы значений и ссылочные типы.
Переменные типа значений содержат данные.
Переменные ссылочного типа хранят ссылки на соответствующие данные (объекты).
К типам значений в C# относятся простые типы, перечисляемые типы, типы структур и обнуляемые типы. К ссылочным типам в C# относятся типы классов, типы интерфейсов, типы массивов и типы делегатов.
Система общих типов CTS в платформе .NET Framework поддерживает следующие категории типов: (из Спецификации языка C# версии 3.0)
Category
Value
types
Simple types
Reference
types
Class types
Для создания нового типа в программах на языке C# его необходимо определить. Можно определить пять пользовательских типов: классы, структуры, интерфейсы, перечисления и делегаты.
Классы и объекты
Класс — это структура данных, объединяющая состояние (поля) и действия (методы и другие функции-члены). Экземпляры класса создаются с помощью оператора new. Класс может содержать статические члены или члены экземпляра. Статические члены принадлежат классам. Члены экземпляра принадлежат объектам (экземплярам класса).
В типе можно определить следующие члены: (Джеффри Рихтер CLR via C#. Программирование на платформе Microsoft .NET Framework 2.0 на языке C# Питер, Русская Редакция 2007)
Константа. Идентификатор, определяющий постоянную величину. Константы связаны с типом, а не с экземпляром.
Поле. Представляет неизменяемое или изменяемое значение. Поле может быть статическим – тогда оно является частью типа и экземплярным - тогда оно является частью объекта.
Метод. Представляет собой функцию, выполняющую операции, которые изменяют или запрашивают состояние типа (статический метод) или объекта (экземплярный метод).
Конструктор экземпляра– метод, используемый для инициализации полей экземпляра при его создании.
Конструктор типа – метод, используемый для инициализации статических полей типа.
Свойство. Для того чтобы можно было изменить значение (получить значение) закрытой переменной, необходимо использовать свойства или функции доступа (accessors). Для вызывающей стороны этот член выглядит как поле, но в реализации типа он выглядит как метод.
Перегруженный оператор.
Оператор преобразования.
Событие.
Тип. Позволяет определять другие вложенные в него типы.
Встроенные числовые типы (из Спецификации языка C# версии 3.0).
| Category | Bits | Type | Range/Precision |
| Signed integral
| 8 | sbyte | –128...127 |
| 16 | short | –32,768...32,767 | |
| 32 | Int | –2,147,483,648...2,147,483,647 | |
| 64 | Long | –9,223,372,036,854,775,808...9,223,372,036,854,775,807 | |
| Unsigned integral | 8 | Byte | 0...255 |
| 16 | ushort | 0...65,535 | |
| 32 | Uint | 0...4,294,967,295 | |
| 64 | ulong | 0...18,446,744,073,709,551,615 | |
| Floating point | 32 | float | 1.5 × 10−45 to 3.4 × 1038, 7-digit precision |
| 64 | double | 5.0 × 10−324 to 1.7 × 10308, 15-digit precision | |
| Decimal | 128 | decimal | 1.0 × 10−28 to 7.9 × 1028, 28-digit precision |
Тип bool используется для представления логических значений true или false.
Тип char используется для объявления символа Юникода (кода UTF-16).
Для создания переменных в программах C# используются оператор объявления. В операторе объявления необходимо указать тип и имя создаваемой переменной. Каждая переменная по значению должна быть инициализирована перед использованием (ей должно быть присвоено значение). Простые типы можно инициализировать с помощью литералов.Пример. Объявление и инициализация переменных: sbyte, short, int, long. Форматирование числовых результатов при выводе данных на консоль.
using System;
namespace ConsoleApplication2
{
class Program
static void Main(string[] args)
{
sbyte sByte1 = 127;
short x = 32767;
int i = 123;
long long1 = 4294967296;
Console.WriteLine("Переменная sbyte{0,4:d} Переменная short{1,6:d} " +
" Переменная int{2,4:d} Переменная long{3,11:d}", sByte1, x, i,long1);
}
}
}
Для форматирования числовых результатов при выводе данных на консоль можно использовать составное форматирование. Общая форма записи спецификатора формата в составном форматировании имеет следующий вид: {номер_ аргумента[, ширина][: формат]}. Парные фигурные скобки ("{" и "}") здесь обязательны.
номер_ аргумента – описатель параметра, число, определяющее соответствующий объект из списка; индексация элементов ведется от нуля. Например, если имеется три объекта, то можно отформатировать сначала второй, а затем первый и третий объекты, задав следующую строку составного форматирования: "{1} {0} {2}".
Необязательный компонент ширина (alignment) — это целое число со знаком, которое служит для указания желательной ширины поля форматирования.
Необязательный компонент формат — это строка формата, соответствующая типу форматируемого объекта.
Пример. Объявление и инициализация переменных: float, double, decimal. Форматирование числовых результатов.
using System;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
float x = 3.5555F;
double y = 3.5555;
decimal myMoney = 300.5m;
Console.WriteLine("Переменная float {0:f} Переменная double {1:f}" +
" Переменная decimal {2:c}", x, y, myMoney);
}
}
}
using System;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
float x = 3.5555F;
double y = 3.5555;
decimal myMoney = 300.5m;
Console.WriteLine("Переменная float {0:##.#} Переменная double {1:#.###}" +
"Переменная decimal {2:c}", x, y, myMoney);
}
}
}
Литералы
Литерал — это представление значения в исходном коде.
Символьные литералы
char[] chars = new char[4];chars[0] = 'X'; // Character literalchars[1] = '\x0058'; // Hexadecimalchars[2] = (char)88; // Cast from integral typechars[3] = '\u0058'; // Unicodeлогические литералы
true
false
Литерал_null
null
Целочисленные литералы
Цифры от 0 до 9. Чтобы указать, что литерал представляет собой число без знака, он снабжается
суффиксом u или U, например:
uint i = 12u;
Console.WriteLine("{0:d}", i);
Суффиксы l или L применяются для создания литералов типа long и ulong:
long i = 1222L;
Console.WriteLine("{0:d}", i);
шестнадцатеричные числа
long i = 0xFFFF;
Console.WriteLine("{0:x}", i);
Литералы с плавающей точкой
float i = 10.0f;
Console.WriteLine("{0:f}", i);
double i = -3.7E-10D;
Console.WriteLine("{0:e}", i);
Строковые литералы
string i = "eeeeee\nyyyyyyyyy";
Console.WriteLine(i);
В языке С# строковый литерал может иметь префикс @. Он задает так называемый
буквальный литерал
string i =@"c:\";
Console.WriteLine(i);
Подробнее в спецификации языка C#.Встроенные числовые типы являются структурами, и к их свойствам и методам и другим членам можно получить доступ.
Пример. Объявление и инициализация переменной типа bool. Вывод данных на консоль.
using System;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
bool b = true;
// WriteLine автоматически конвертирует значение переменной b в текст.
Console.WriteLine(b);
}
}
}
Тип char представляет 16-разрядные целые числа без знака в диапазоне от 0 до 65535. Набор возможных значений для типа char соответствует набору символов Юникода.
Пример. Объявление и инициализация четырех переменных типа char, имеющих одно и тоже значение - символ X.using System;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
char char0 = 'X'; // Символьный литерал
char char1 = '\x0058'; // шестнадцатеричная escape-последовательность
char char2 = (char)88; // Преобразование типа int в char
char char3 = '\u0058'; // Юникод
Console.WriteLine("{0} {1} {2} {3}", char0, char1, char2, char3);
}
}
}
Тип char классифицируется как целый тип, однако имеет два отличия от других целых типов:
· Не поддерживается неявное преобразование из других типов к типу char. В частности, несмотря на то, что диапазоны значений для типов sbyte, byte и ushort могут быть полностью представлены с помощью типа char, неявное преобразование из типов sbyte, byte и ushort к типу char не существует.
· Константы типа char должны записываться в виде символьных или целочисленных_литералов в сочетании с приведением к типу char. Например, записи (char)10 и '\x000A' аналогичны.
Типы операторов.
Операторы объявления
Операторы выражений
Операторы выбора
Операторы итераций
Операторы перехода
Внедренный оператор. В операторах do, while, for и foreach, всегда есть внедренный оператор, следующий за ними. Этот внедренный оператор может быть либо одним оператором, либо несколькими операторами, заключенными в скобки ({}) в блоке оператора. Даже однострочные внедренные операторы могут быть заключены в скобки ({}).
Вложенные блоки операторов. Блоки операторов могут быть вложенными.
Оператор объявления объявляет локальную переменную или константу. Операторы объявления разрешается использовать в блоках, но запрещается использовать как внедренные операторы.
Оператор = называется простым оператором присваивания.
Области объявления
Объявление определяет имя в области объявления, которому принадлежит объявление.
Нельзя использовать одно имя для двух или более объявлений в одной области объявления за исключением перегруженных членов.
Пространства имен могут содержать объявления типов и вложенных пространств имен.
Пространства имен и типы, имеющие родительское пространство имен, являются членами глобального пространства имен.
Пространства имен и типы, объявленные в рамках пространства имен, являются членами данного пространства имен.
Каждое объявление типа: класса, структуры, интерфейса, делегата, перечисляемого типа создает новую область объявления.
Каждое объявление метода, объявление индексатора, объявление оператора, объявление конструктора экземпляров создает новую область объявления, которая называется областью объявлений локальных переменных.
Каждый блок или блок_switch, а также инструкции for, foreach и using создают область объявлений для локальных переменных и локальных констант .
Блоки, встречающиеся в качестве тела члена функции, вложены в область объявлений локальных переменных, объявленной этими функциями для соответствующих параметров. Следовательно, наличие, к примеру, метода с одинаковыми именами локальной переменной и параметра является ошибкой.
Области видимости
Областью видимости имени является часть текста программы, в рамках которой можно ссылаться на переменную, имеющее данное имя. Области могут быть вложенные, в рамках вложенного блока невозможно объявить локальную переменную с именем, совпадающим с именем локальной переменной во внешнем блоке.
Пример программы, которая завершится с ошибкой «Невозможно объявить локальную переменную с именем "a" в этой области видимости, т.к. другое значение "a", уже используется в области видимости "родительский или текущий"
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int a = 0;
Console.WriteLine(a);
{
int a = 6;
Console.WriteLine(a);
}
}
}
}
Пример. Объявление локальных переменных, которое не приведет к ошибке.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
{
int a = 0;
Console.WriteLine(a);
}
{
int a = 6;
Console.WriteLine(a);
}
}
}
}
Областью члена пространства имен, объявленного объявлением члена пространства имен, является полный текст программы.
Областью члена, объявленного объявлением члена типа, является тело типа, в котором сделано объявление.
Областью параметра, объявленного в объявлении метода, является тело метода данного объявления метода.
Областью локальной переменной, объявленной в объявлении локальной переменной, является блок, в котором содержится объявление.
Областью локальной переменной, объявленной в блоке ветвления оператора switch, является блок ветвления.
Областью локальной переменной, объявленной в инициализаторе for оператора for, является инициализатор for, условие for, итератор for и содержащий оператор оператора for.
Областью локальной константы, объявленной в объявлении локальной константы, является блок, в котором содержится объявление. Ссылка на локальную константу в текстовой позиции, предшествующей декларатору константы, является ошибкой времени компилирования.
Переменные
В C# определено семь категорий переменных: статические переменные, переменные экземпляра, элементы массива, параметры по значению, параметры по ссылке, выходные параметры и локальные переменные.
Локальные переменные
Локальную переменную можно объявить в блоке, в операторе for, в операторе switch или операторе using, а также в операторе foreach или в конструкции catch в операторе try.
Объявление локальной переменной состоит из типа локальной переменной, идентификатора, определяющего имя переменной, за которым могут следовать оператор присваивания
и инициализатор локальной переменной, присваивающий переменной начальное значение.
При объявлении локальная переменная не инициализируется автоматически и поэтому не имеет значения по умолчанию (считается не имеющей начального значения).
Пример. Объявление нескольких локальных переменных.
int x = 1, y, z = x * 2;
Примеры. Операторы языка.
Оператор_итераций for
Цикл for повторно выполняет оператор или блок операторов, пока определенное выражение не примет значение false.
В цикле for может содержаться инициализатор for, условие for, итератор for, содержащий оператор оператора for (внедренный оператор)
оператор_for:
for ( инициализатор_forнеобязательно ; условие_forнеобязательно ; итератор_forнеобязательно ) внедренный_оператор
Инициализатор содержит объявление локальной переменной
Условием является логическое выражение
Итератор это выражение
В следующем примере значение переменной int i записывается в консоль, и i увеличивается на 1 за каждое прохождение цикла.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int i = 0;
for (i = 1; i <= 5; i++)
{
Console.WriteLine(i);
}
Console.WriteLine(i);
}
}
}
Все выражения оператора for являются необязательными. Например, следующий оператор используется для создания бесконечного цикла:
C #
for (; ; )
{
// ...
}
Оператор_итераций while
Оператор while выполняет внедренный оператор несколько раз (возможно, ни разу) в зависимости от соблюдения условия.
оператор_while:
while ( логическое_выражение ) внедренный_оператор
Оператор while выполняется следующим образом.
Вычисляется логическое_выражение Если результатом логического выражения является true, управление передается внедренному оператору. Если управление достигает конечной точки внедренного оператора (возможно, в результате выполнения оператора continue), управление передается в начало оператора while.
Если значением логического выражения является false, управление передается в конечную точку оператора while.
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int n = 1;
while (n < 6)
{
Console.WriteLine("Current value of n is {0}", n);
n++;
}
}
}
}
Оператор выбора if
Оператор if выбирает оператор языка для выполнения на основании значения логического выражения.
оператор_if:
if ( логическое_выражение ) внедренный_оператор
if ( логическое_выражение ) внедренный_оператор else внедренный_оператор
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
// Проверяем четность числа
// Вводим проверяемое значение
int Num;
string Str;
Console.Write("Введите число: ");
Str = Console.ReadLine();
Num = int.Parse(Str);
// если число делится на 2 без остатка то четное
// оператор % - это остаток от целочисленного деления
if (Num % 2 == 0)
{
Console.WriteLine("Число {0} - четное", Num);
}
else
{
Console.WriteLine("Число {0} - нечетное", Num);
}
Console.ReadKey();
}
}
}
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
// Найти чему будет равно выражение C = min(A,B)
// A и B целые числа, которые нужно ввести с клавиатуры
// Вывести результат и исходное выражение, подставив числа
// Введем исходные значения A и B
int A, B, C;
string Str;
Console.Write("A = ");
Str = Console.ReadLine();
A = int.Parse(Str); // Parse - статический метод структуры int
Console.Write("B = ");
Str = Console.ReadLine();
B = int.Parse(Str);
//Находим значение выражения
int min;
if (A < B)
min = A;
else
min = B;
C = min;
// Выводим результат
Console.WriteLine("min({0},{1})) = {2}", A, B, C);
Console.ReadKey();
}
}
}
Оператор выбора switch
Оператор switch выбирает для выполнения список операторов, метка которого соответствует значению switch-выражения.
оператор_switch:
switch ( выражение ) блок_switch
блок_switch:
{ разделы_switchнеобязательно }
разделы_switch:
раздел_switch
разделы_switch раздел_switch
раздел_switch
метки_switch список_операторов
метки_switch:
метка_switch
метки_switch метка_switch
метка_switch:
case константное_выражение :
default :
Вычисляется switch-выражение.
Если значение константы, указанной в метке case, совпадает со значением switch-выражения, управление передается списку операторов, следующему за меткой case.
Если ни одна из констант, указанных в метках case оператора switch, не совпадает со значением switch-выражения и при этом имеется метка default, управление передается списку операторов, следующему за меткой default, если метка default отсутствует, управление передается в конечную точку оператора switch.
Если после выполнения одного раздела (раздел заключен в {} скобки) switch должно следовать выполнение другого раздела switch, необходимо явным образом указывать оператор goto case или goto default.
Ошибка времени компиляции возникает, если несколько меток case в одном операторе switch задают одно и то же константное значение.
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int caseSwitch = 5;
switch (caseSwitch)
{
case 1:
Console.WriteLine("Case 1");
break;
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}
}
}
}
Список операторов раздела switch обычно заканчивается оператором break, goto case или goto default.
Если за меткой case нет списка операторов, то операторы break, goto case или goto default необязательны
В примере управление передается списку операторов, следующему за меткой case 2
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
int caseSwitch = 1;
switch (caseSwitch)
{
case 1:
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}
}
}
}
Оператор итераций do
Оператор do выполняет внедренный оператор один или несколько раз в зависимости от соблюдения условия.
оператор_do:
do внедренный_оператор while ( логическое_выражение ) ;
Управление передается внедренному оператору.
Если управление достигает конечной точки внедренного оператора, вычисляется логическое выражение.
Если результатом логического выражения является true, управление передается в начало оператора do. В противном случае управление передается в конечную точку оператора do.
Пример.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int x = 0;
do
{
Console.WriteLine(x);
x++;
} while (x < 5);
}
}
}
Операторы перехода
Операторы перехода осуществляют безусловную передачу управления. Операторы перехода могут передавать управление за пределы блока, но они никогда не передают управление внутрь блока.
Оператор break осуществляет выход из ближайшего объемлющего оператора switch, while, do, for или foreach.
Оператор continue начинает новую итерацию ближайшего объемлющего оператора while, do, for или foreach goto
Оператор return возвращает управление в программу, вызвавшую функцию-член, в которой используется оператор return. Оператор return с выражением может использоваться только в функции-члене, вычисляющей значение, т. е. в методе с типом возвращаемого значения, отличным от void, в методе доступа get для свойства или индексатора или в операторе, определенном пользователем.
Приведение и преобразование типов.
Преобразования бывают явными и неявными.
int a = 123;
long b = a; // implicit conversion from int to long
// неявное перобразование типов, из int к long
int c = (int) b; // explicit conversion from long to int
// явное перобразование типов, из long к int
Неявные преобразования.
При вызове члена функции (метода). Для параметра имеющего тип значения вычисляется выражение аргумента и выполняется неявное преобразование в соответствующий тип параметра. Пример.
using System;
namespace ConsoleApplication5
{
class Program
{
static double f(double a, double b)
{
return a + b;
}
static void Main(string[] args)
{
int r = 2222;
double rez = f(r, 42222);
Console.WriteLine(rez);
}
}
}
Неявное преобразование при использовании оператора присваивания.
Пример. Неявное преобразование числового типа: из int к long. Компилятор неявно преобразует значение справа в тип long перед присвоением его переменной bigNum. Преобразование от меньшего к большему целому типу.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int num = 2147483647;
long bigNum = num;
}
}
}
Неявные преобразования числовых типов.
Существуют следующие неявные преобразования числовых типов:
· из sbyte к short, int, long, float, double или decimal;
· из byte к short, ushort, int, uint, long, ulong, float, double или decimal;
· из short к int, long, float, double или decimal;
· из ushort к int, uint, long, ulong, float, double или decimal;
· из int к long, float, double или decimal;
· из uint к long, ulong, float, double или decimal;
· из long к float, double или decimal;
· из ulong к float, double или decimal;
· из char к ushort, int, uint, long, ulong, float, double или decimal;
· из float к double.
Преобразования из типов int, uint, long или ulong к float, а также из long или ulong к double могут привести к потере точности, но не величины. Другие неявные преобразования числовых типов никогда не приводят к потере данных.
Неявных преобразований к типу char не существует, поэтому значения любых других целых типов не могут быть преобразованы к типу char.
Неявные преобразования ссылочных типов
Существуют следующие неявные преобразования ссылочных типов:
Из любого ссылочного типа к object.
Из производного класса к базовому классу.
Из типа класса S к типу интерфейса T (где S реализует T).
Из типа интерфейса S к типу интерфейса T (где S является производным от T).
Из любого типа массива к System.Array и реализуемым им интерфейсам.
Из типа_массива S, который имеет тип элементов SE, к типу_ массива T, который имеет тип элементов TE, если выполняются следующие условия:
S и T различаются только по типу элементов. Другими словами, типы S и T имеют одинаковое число измерений.
SE и TE являются ссылочными_типами.
Существует неявное преобразование ссылочного типа из SE к TE.
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
string[] t = new string[2] { "vv", "kkk" };
object[] tt = new object[2];
tt = t;
}
}
}
Пример
Если элемент массива ссылочного типа передается в качестве параметра ссылки или вывода, во время выполнения необходимо убедиться, что фактический тип элементов массива идентичен типу параметра.
using System;
namespace ConsoleApplication5
{
class Program
{
static void F(ref object x) { }
static void Main()
{
object[] a = new object[10];
object[] b = new string[10];
F(ref a[0]); // Ok
F(ref b[1]); // ArrayTypeMismatchException
}
}
}
Понятие упаковки и распаковки является ключевым в системе типов C#. С помощью данных операций осуществляется связь между типами значений и ссылочными типами за счет возможности преобразования любого значения типа значений к типу object и обратно.
Преобразования упаковки
Преобразование упаковки обеспечивает неявное преобразование типа значений в ссылочный тип.
из любого типа значений к типу object. Пример .
int i = 123;
object box = i;
Явные преобразования
Выражение приведения типа используется для явного преобразования выражения в данный тип.
выражение_приведения_к_типу:
( тип ) унарное_выражение
Выражение_приведения_типа вида (T)E, где T является типом, а E —унарным_выражением, выполняет явное преобразование значения E в тип T.
Явные преобразования числовых типов.
Явные преобразования числовых типов предназначены для преобразования из одного числового_типа к другому числовому_типу, для которого не существует неявного преобразования:
· из sbyte к byte, ushort, uint, ulong или char;
· из byte к sbyte и char;
· из short к sbyte, byte, ushort, uint, ulong или char;
· из ushort к sbyte, byte, short или char;
· из int к sbyte, byte, short, ushort, uint, ulong или char;
· из uint к sbyte, byte, short, ushort, int или char;
· из long к sbyte, byte, short, ushort, int, uint, ulong или char;
· из ulong к sbyte, byte, short, ushort, int, uint, long или char;
· из char к sbyte, byte или short;
· из float к sbyte, byte, short, ushort, int, uint, long, ulong, char или decimal;
· из double к sbyte, byte, short, ushort, int, uint, long, ulong, char, float или decimal;
· из decimal к sbyte, byte, short, ushort, int, uint, long, ulong, char, float или double.
Пример. Для выполнения явного преобразования числового типа необходимо
заключить тип, в который производится преобразование (приведение), в скобки перед преобразуемым значением или переменной. Следующая программа выполнят приведение типа double в тип int.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
double x = 1234.7;
int a;
// Cast double to int.
a = (int)x;
System.Console.WriteLine(a);
}
}
}
Если x и y являются идентификаторами, то (x)y, (x)(y) и (x)(-y) являются выражениями приведения типа, а (x)-y не является, даже если x обозначает тип. Однако если x является ключевым словом, которое обозначает стандартный тип (например, int), то все четыре вида выражения являются выражениями приведения типа (потому что такое ключевое слово не может само быть выражением). Пример .
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
double x = 1234.7;
int a;
// Cast double to int.
a = (int)-x;
System.Console.WriteLine(a);
}
}
}
Результат
Пример использования оператора unchecked .
Явное преобразование из int к short, где
| short | От -32 768 до 32 767 | 16-разрядное целое число со знаком | System.Int16 |
| int | От -2 147 483 648 до 2 147 483 647 | 32-разрядное целое число со знаком | System.Int32 |
int i = 2147483647;
short ixx = unchecked((short)i);
Пример использования оператора checked.
Для неконстантных выражений (выражений, которые вычисляются во время выполнения), не заключенных в операторы или инструкции checked или unchecked, контекстом проверки переполнения по умолчанию является unchecked, если внешние факторы (например, переключатели компилятора и конфигурация среды исполнения) не заставляют установить контекст checked.
Пример.
int i = 2147483647;
short ixx = (short)i;
Если размер исходного типа превышает размер конечного, дополнительные самые старшие разряды исходного значения отбрасываются. Пример:
int i = 1000000;
short a = (short)i;
Console.WriteLine(a);
Если размер исходного типа меньше размера конечного, размер исходного значения расширяется до размера конечного типа за счет добавления знака или нулей.
short s = -72;
int i = (int) s;
Console.WriteLine(s);
Для преобразований из типа decimal к целому типу исходное значение округляется в сторону нуля до ближайшего целого значения. Результатом преобразования является полученное целое значение.
Пример.
decimal d = 10000.5m;
int i =(int)d;
Console.WriteLine(i);
Для типов с плавающей запятой и типа decimal отсутствует неявное преобразование, поэтому для преобразования между этими двумя типами следует использовать приведение. Пример.
Пример .
decimal myMoney = 99.9m;
double x = (double)myMoney;
Console.WriteLine(x);
Если убрать оператор явного преобразования, то программа завершится с ошибкой
Ошибка 1 Не удается неявно преобразовать тип "decimal" в "double". Существует явное преобразование (возможно, пропущено приведение типов)
Преобразования из double к float .
Значение типа double округляется до ближайшего значения типа float. При переполнении арифметической операции или делении на ноль исключение никогда не вызывается, потому что типы чисел с плавающей запятой основаны на стандарте IEEE 754 и включают правила для представления бесконечности и нечисловых значений (NaN).
Пример
double mydouble = 111111111111111111116666666666666666666666666666666666666666666666666666666666666666661111.11;
float x = (float)mydouble;
Console.WriteLine(x);
Явные преобразования ссылочных типов.
Поддерживаются следующие явные преобразования ссылочных типов:
· Из object любому другому ссылочному_типу.
· Из любого типа_класса S к любому типу_класса T, если S является базовым классом для T.
(Более подробно будет рассмотрено далее)
Пользовательские явные преобразования
будет рассмотрено далее
Преобразования с помощью вспомогательных классов.
Пример
int numVal = Convert.ToInt32("29");
Преобразования распаковки.
Преобразование распаковки обеспечивает явное преобразование ссылочного_типа к типу_значений.
Пример .
int i = 123;
object box = i;
i = 666;
i = (int)box;
Выражения.
Значения выражений.
Значение переменной — это значение, которое хранится в данный момент в расположении, указанном переменной.
Процесс определения значения операции на основе типа или значения составляющих выражений называют привязкой. Если значение операции определяется во время компиляции, то этот метод называется статической привязкой. Если выражение является динамическим, то это указывает на то, что любая участвующая привязка должна быть основана на типе времени выполнения. Привязка такой операции откладывается до времени выполнения операции при работающей программе. Это называется динамической привязкой.
Операторы
Выражения состоят из операндов и операторов. Операторы в выражении указывают, какие операции производятся с операндами. К операторам относятся, например, +, -, *, / и new. К операндам относятся, например, литералы, поля, локальные переменные и выражения. Операторы выражений, вычисляют значение и должны сохранить его в переменной.
Существует три типа операторов.
· Унарные операторы. У унарного оператора есть только один операнд и оператор может записываться в префиксной форме (например, –x) или постфиксной форме (например, x++).
· двоичные операторы; У бинарных операторов два операнда и они записываются в виде инфикса (например, x + y).
· Тернарный оператор. Существует только один тернарный оператор, ?:. В нем три операнда и используется инфиксная запись (c? x: y).
Порядок вычисления операторов в выражении определяется приоритетом и ассоциативностью операторов.
Ассоциативностью операторов называют последовательность их выполнения. Операнды в выражении вычисляются слева направо.
Приоритет оператора задается в определении связанной с ним грамматической структуры. Например, аддитивное_выражение состоит из последовательности мультипликативных_выражений, разделенных операторами + или –, таким образом, операторы + или – имеют более низкий приоритет, чем операторы *, / и %.
В следующей таблице приводятся все операторы в соответствии с их приоритетом от самого высокого до самого низкого (спецификация языка C#).
| Категория | Операторы |
| Основной | x.y f(x) a[x] x++ x-- new (Создание объекта и делегата ) typeof default (Получение значения по умолчания для типа T) checked unchecked delegate |
| Унарный | + - ! ~ ++x (Постфиксное приращение ) --x (Постфиксное уменьшение) (T)x |
| Мультипликативный | * / % |
| Аддитивный | + - |
| Сдвиг | << >> |
| Отношение и проверка типа | < > <= >= is as |
| Равенство | == != |
| Логическое И | & |
| Исключающее ИЛИ | ^ |
| Логическое ИЛИ | | |
| Условное И | && |
| Условное ИЛИ | || |
| Условный | ?: int S = 0; int N = -10; S = N > 0 ? N : -N; Console.WriteLine(S); |
| Присваивание и лямбда-выражение | = *= /= %= += -= <<= >>= &= ^= |= => |
· За исключением операторов присваивания все бинарные операторы обладают левой ассоциативностью. Это означает, что все операции выполняются слева направо. Например, выражение x + y + z вычисляется как (x + y) + z.
· Операторы присваивания и условный оператор (?:) обладают правой ассоциативностью. Это означает, что все операции выполняются справа налево. Например, выражение x = y = z вычисляется как x = (y = z).
Приоритетом и ассоциативностью можно управлять с помощью скобок.
Некоторые операторы допускают перегрузку.
Простые имена
Просто имя состоит из идентификатора, за которым может следовать список аргументов типа:
простое_имя:
индетификатор список_аргументов_типанеобязательно
Для каждого вхождения данного идентификатора в качестве простого_имени в выражении или деклараторе внутри области объявления локальных переменных, непосредственно включающей это вхождение, каждое вхождение того же самого идентификатора в качестве простого_имени в выражении или декларатора должно ссылаться на одну и ту же сущность. Это правило позволяет гарантировать, что внутри определенного блока, блока switch, а также операторов for, foreach и using имя всегда имеет одинаковое значение.
Правило инвариантности значения применяется только к простым именам. Один идентификатор вполне может иметь одно значение в виде простого имени и другое значение в виде правого операнда в методе доступа к члену. Например:
using System;
namespace ConsoleApplication7
{
struct Point
{
int x, y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public override string ToString()
{
return String.Format("{0} {1}", x, y);
}
}
class Program
{
static void Main(string[] args)
{
Point p = new Point(3, 5);
Console.WriteLine(p);
}
}
}
В примере простые имена x и y относятся к параметрам, но это не мешает выражениям доступа к членам this.x и this.y иметь доступ к полям.
Выражения со скобками
Выражение_со_скобками состоит из выражения, заключенного в скобки.
выражение_в_скобках:
( выражение )
Выражение_со_скобками вычисляется путем вычисления выражения внутри скобок.
Доступ к члену
Оператор "точка" используется для доступа к членам.
Выражения вызова
Выражение_вызова используется для вызова метода.
выражение_вызова:
первичное_выражение ( список_аргументовнеобязательно )
Например
TestMethod();
Доступ this
Доступ_this представляет собой зарезервированное слово this.
доступ_через_this:
this
Доступ_this допустим только в блоке конструктора экземпляра, метода экземпляра или метода доступа к экземпляру.
Когда доступ this используется в основном_выражении внутри конструктора экземпляра структуры, он классифицируется как значение. Типом значения является тип экземпляра структуры, внутри которой происходит это использование, а значением является создаваемая структура. Переменная this конструктора экземпляра структуры действует точно так же, как параметр out типа структуры, в частности, это означает, что переменная должна явно назначаться в каждом пути выполнения конструктора экземпляра.
Когда доступ this используется в основном_выражении внутри конструктора экземпляра класса, он классифицируется как значение. Типом значения является тип экземпляра класса, внутри которого происходит это использование, а значением является ссылка на создаваемый объект.
Примеры
Использование this для квалификации элементов, скрытых одинаковыми именами.
class Point
{
int x, y;
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public override string ToString()
{
return String.Format("{0} {1}", x, y);
}
}
Доступ this используется для передачи другим методам объекта в качестве параметра (пример из msdn)
using System;
namespace ConsoleApplication7
{
class Employee
{
private string name;
private string alias;
private decimal salary = 3000.00m;
// Constructor:
public Employee(string name, string alias)
{
// Use this to qualify the fields, name and alias:
this.name = name;
this.alias = alias;
}
// Printing method:
public void printEmployee()
{
Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
// Passing the object to the CalcTax method by using this:
Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
}
public decimal Salary
{
get { return salary; }
}
}
class Tax
{
public static decimal CalcTax(Employee E)
{
return 0.08m * E.Salary;
}
}
class Program
{
static void Main(string[] args)
{
Employee E1 = new Employee("Mingda Pan", "mpan");
// Display results:
E1.printEmployee();
}
}
}
У статических функций-членов нет указателя this, так как они существуют только на уровне класса и не являются частями объектов. Использование ссылки на this в статическом методе является недопустимым.
Также this используется для объявления индексаторов.
Оператор new .
В языке C# ключевое слово new может использоваться в качестве оператора, модификатора или ограничения.
Оператор new
Используется для создания объектов и вызова конструкторов.
Модификатор new
Используется для того, чтобы скрыть наследуемый член от члена базового класса.
Ограничение new
Используется для ограничения типов, которые могут использоваться в качестве аргументов для параметра типа в универсальном объявлении.
Оператор new используется для создания объектов и вызова конструкторов.
Пример (пример из msdn)
struct SampleStruct
{
public int x;
public int y;
public SampleStruct(int x, int y)
{
this.x = x;
this.y = y;
}
}
class SampleClass
{
public string name;
public int id;
public SampleClass() {}
public SampleClass(int id, string name)
{
this.id = id;
this.name = name;
}
}
class ProgramClass
{
static void Main()
{
// Create objects using default constructors:
SampleStruct Location1 = new SampleStruct();
SampleClass Employee1 = new SampleClass();
// Display values:
Console.WriteLine("Default values:");
Console.WriteLine(" Struct members: {0}, {1}",
Location1.x, Location1.y);
Console.WriteLine(" Class members: {0}, {1}",
Employee1.name, Employee1.id);
// Create objects using parameterized constructors:
SampleStruct Location2 = new SampleStruct(10, 20);
SampleClass Employee2 = new SampleClass(1234, "Luciana Ramos");
// Display values:
Console.WriteLine("Assigned values:");
Console.WriteLine(" Struct members: {0}, {1}",
Location2.x, Location2.y);
Console.WriteLine(" Class members: {0}, {1}",
Employee2.name, Employee2.id);
}
}
Если в определение структуры SampleStruct добавить конструктор экземпляра по умолчанию
public SampleStruct() { }
Это приведет к ошибке: Структуры не могут содержать явных конструкторов без параметров
Выражения создания объектов
Выражение_создания_объекта используется для создания нового экземпляра типа_класса или типа_значения.
выражение_создания_объекта:
new тип ( список_аргументовнеобязательно ) инициализатор_объекта_или_коллекциинеобязательно
new тип инициализатор_объекта_или_коллекции
инициализатор_объекта_или_коллекции:
инициализатор_объекта
инициализатор_коллекции
Тип выражения_создания_объекта должен быть равен типу_класса, типу_значения или параметру_типа. Тип не может быть типом_класса abstract.
Во время выполнения обработка выражения_создания_объекта в виде new T(A), где T является типом_класса или типом_структуры, а A является необязательным списком_аргументов, включает следующие этапы.
· Если T является типом_класса:
o Создается новый экземпляр класса T.
o Все поля нового экземпляра инициализируются с помощью значений по умолчанию.
o В соответствии с правилами вызова функции-члена вызывается конструктор экземпляра. Ссылка на созданный экземпляр автоматически передается конструктору экземпляра, и к этому экземпляру можно обращаться из этого конструктора с помощью this.
· Если T является типом_структуры:
o С помощью выделения временной локальной переменной создается экземпляр типа T. Поскольку для явного присвоения значений каждому полю создаваемого экземпляра требуется конструктор экземпляра типа_структуры, инициализация временной переменной не требуется.
o В соответствии с правилами вызова функции-члена вызывается конструктор экземпляра. Ссылка на созданный экземпляр автоматически передается конструктору экземпляра, и к этому экземпляру можно обращаться из этого конструктора с помощью this.
Оператор typeof
Оператор typeof используется для получения объекта System.Type для типа.
Пример
System.Type type = typeof(int);
Пример
using System;
namespace ConsoleApplication7
{
class Employee
{
private string name;
private string alias;
private decimal salary = 3000.00m;
// Constructor:
public Employee(string name, string alias)
{
// Use this to qualify the fields, name and alias:
this.name = name;
this.alias = alias;
}
// Printing method:
public void printEmployee()
{
Console.WriteLine("Name: {0}\nAlias: {1}", name, alias);
// Passing the object to the CalcTax method by using this:
Console.WriteLine("Taxes: {0:C}", Tax.CalcTax(this));
}
public decimal Salary
{
get { return salary; }
}
}
class Tax
{
public static decimal CalcTax(Employee E)
{
return 0.08m * E.Salary;
}
}
class Program
{
static void Main(string[] args)
{
Employee E1 = new Employee("Mingda Pan", "mpan");
// Display results:
E1.printEmployee();
Type t = typeof(Employee);
// Alternatively, you could use
// SampleClass obj = new SampleClass();
// Type t = obj.GetType();
Console.WriteLine("Methods:");
System.Reflection.MethodInfo[] methodInfo = t.GetMethods();
foreach (System.Reflection.MethodInfo mInfo in methodInfo)
Console.WriteLine(mInfo.ToString());
Console.WriteLine("Members:");
System.Reflection.MemberInfo[] memberInfo = t.GetMembers();
foreach (System.Reflection.MemberInfo mInfo in memberInfo)
Console.WriteLine(mInfo.ToString());
}
}
}
Унарные операторы.
Операторы +, -, !, ~, ++, -- и операторы приведения типа называются унарными операторами.
унарное_выражение:
основное_выражение
+ унарное_выражение
- унарное_выражение
! унарное_выражение
~ унарное_выражение
префиксное_выражение_инкремента
префиксное_выражение_декремента
выражение_приведения_типа
Унарный оператор «плюс»
Операция вида +x результатом является просто значение операнда. Унарные операторы + предопределены для всех числовых типов.
Унарный оператор «минус» .
Операция вида –x. Унарные операторы - предопределены для всех числовых типов.
Для целых чисел результат вычисляется вычитанием x из нуля. Для унарного оператора «–» операнд преобразуется к первому типу из набора int и long, которым может быть представлено значение операнда. Не допускается применение унарного оператора «–» к операндам типа ulong.
Пример
Данная программа вызовет ошибку: Постоянное значение "-17" не может быть преобразовано в "ulong"
ulong A = -17;
Console.WriteLine(A);
Пример. Если операнд оператора взятия обратного знака имеет тип uint, то он преобразуется в тип long.
uint a = 17;
var r = -a;
Console.WriteLine(r);
Результат
Пример
Console.WriteLine(!true);
Console.WriteLine(!false);
Поразрядное отрицание.
Операция вида ~x результатом операции является побитовое дополнение x.
Оператор ~ выполняет операцию поразрядного дополнения операнда, заключающуюся в инвертировании каждого бита. Операторы поразрядного дополнения предопределены для типов int, uint, long и ulong
int v = 0;
Console.WriteLine("~0x{0:x8} = 0x{1:x8}", v, ~v);
Результат
int v = 0;
int vv = ~v;
Console.WriteLine("~{0:d} = {1:d}", v, vv);
Примеры:
static void Main(string[] args)
{
Console.WriteLine(~1999999999);
}
Результат выражения -2000000000, тип – int
static void Main(string[] args)
{
Console.WriteLine(~3999999999);
}
Результат выражения 294967296, тип – uint
static void Main(string[] args)
{
Console.WriteLine(~5999999999);
}
Результат выражения -6000000000, тип – long
Арифметические операторы
мультипликативное_выражение:
унарное_выражение
мультипликативное_выражение * унарное_выражение
мультипликативное_выражение / унарное_выражение
мультипликативное_выражение % унарное_выражение
аддитивное_выражение:
мультипликативное_выражение
аддитивное_выражение + мультипликативное_выражение
аддитивное_выражение – мультипликативное_выражение
Оператор произведения .
Произведение целых чисел. Пример.
Console.WriteLine(5 * 2);
В контексте checked если произведение выходит за пределы диапазона типа результирующего значения, возникает исключение System.OverflowException. В контексте unchecked о переполнениях не сообщается, и все старшие биты, выходящие за пределы диапазона результирующего значения, отбрасываются.
Пример.
int a = 2147483647;
int b = 2147483647;
var t = a * b;
Console.WriteLine(t);
int a = 2147483647;
int b = 2147483647;
var t = checked(a * b);
Console.WriteLine(t);
Произведение чисел с плавающей запятой. Пример. Умножение числа типа int на число типа double.
var t = -.5 * 2;
Console.WriteLine(t);
В результате тип переменной – doudle.
Произведение вычисляется в соответствии с арифметическими правилами стандарта IEEE 754. В следующей таблице приведены результаты всех возможных комбинаций ненулевых конечных значений, нулей, бесконечных значений и ошибок NaN В таблице x и y являются положительными конечными значениями, а z является результатом x * y. Если результат слишком велик для целевого типа, то z равно бесконечности. Если результат слишком мал для целевого типа, то z равно нулю.
| +y | –y | +0 | –0 | +∞ | –∞ | NaN | |
| +x | +z | –z | +0 | –0 | +∞ | –∞ | NaN |
| –x | –z | +z | –0 | +0 | –∞ | +∞ | NaN |
| +0 | +0 | –0 | +0 | –0 | NaN | NaN | NaN |
| –0 | –0 | +0 | –0 | +0 | NaN | NaN | NaN |
| +∞ | +∞ | –∞ | NaN | NaN | +∞ | –∞ | NaN |
| –∞ | –∞ | +∞ | NaN | NaN | –∞ | +∞ | NaN |
| NaN | NaN | NaN | NaN | NaN | NaN | NaN | NaN |
Пример
double w1 = 1.7976931348623157E+308;
double w2 = 1.7E+3;
double w3 = w1 * w2;
Оператор деления .
Операция вида x / y.
Деление целых чисел. При делении двух целых чисел результат всегда является целочисленным.
Если значение правого операнда равно нулю, возникает исключение System.DivideByZeroException
Пример.
using System;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
int c = 6 / 0;
Console.WriteLine(c);
}
}
}
Ошибка Деление на константу, равную нулю.
Деление целых чисел округляет результат.
Пример
int c = 9 / 4;
Оператор остатка .
Операции вида x % y. Результатом выражения x % y является значение x – (x / y) * y.
Остаток для целых чисел. Пример.
Console.WriteLine(5 % 2);
Результат.
Остаток для чисел с плавающей запятой. Пример.
Console.WriteLine(5.9 % 2.3);
Результат.
Оператор сложения.
Операция вида x + y
Сложение целых чисел.
int uint long ulong
В контексте checked если сумма выходит за пределы диапазона типа результирующего значения, возникает исключение System.OverflowException. В контексте unchecked о переполнениях не сообщается, и все старшие биты, выходящие за пределы диапазона результирующего значения, отбрасываются.
Примеры.
Данный пример вызовет ошибку переполнения, т.к. uint+uint дадут в результате выражения тип uint.
static void Main(string[] args)
{
Console.WriteLine(3999999999 + 3999999999);
}
Данный пример будет работать, т.к. uint+long дадут в результате выражения тип long.
static void Main(string[] args)
{
Console.WriteLine(3999999999 + 6999999999);
}
Сцепление строк.
Если один операнд при сцеплении строк равен null, то подставляется пустая строка. Иначе любой нестроковый аргумент преобразуется в свое строковое представление путем вызова виртуального метода ToString, наследуемого от типа bject.
Оператор вычитания
Операция вида x – y
Вычитание целых чисел.
В контексте checked если разность выходит за пределы диапазона типа результирующего значения, возникает исключение System.OverflowException. В контексте unchecked о переполнениях не сообщается, и все старшие биты, выходящие за пределы диапазона результирующего значения, отбрасываются. Пример.
Данный пример будет работать, т.к. uint+ uint дадут в результате выражения тип uint, но вместо -1 получим в результате 4294967295.
static void Main(string[] args)
{
uint A = 10;
uint B = 9;
Console.WriteLine(B-A);
}
Массивы
Массив представляет собой структуру данных, содержащую определенное число переменных, доступ к которым осуществляется с помощью вычисляемых индексов. Содержащиеся в массиве переменные также называются элементами массива и имеют одинаковый тип, который называется типом элементов массива.
Типы массива
Тип массива записывается как тип_не_массива, за которым следуют спецификации_ранга:
тип_массива:
тип_не_массива спецификации_ранга
тип_не_массива:
тип
спецификации_ранга:
спецификация_ранга
спецификации_ранга спецификация_ранга
спецификация_ранга:
[ разделители_размерностейнеобязательно ]
разделители_размерностей:
,
разделители_размерностей ,
Тип_не_массива является одним из типов, которые сами по себе не являются типом_массива.
Пример. Нельзя использовать int[] в качестве типа массива
int[][] sp = new int[3];
Ошибка Неявное преобразование типа "int[]" в "int[][]" невозможно
int[][] sp = new int[3][3];
Ошибка 1 Недопустимый спецификатор ранга: требуется "," или "]"
int[,] arr = new int[,];
Ошибка 2 При создании массива следует указать размер массива или инициализатор массива
Код, который не приведет к ошибке
Одномерный массив
int[] sp = new int[3];
Двумерный массив
int[,] sp = new int[3,3];
Массив массивов — это массив, элементы которого сами являются массивами.
int[][] arr = new int[2][];
arr[0] = new int[5] { 1, 3, 5, 7, 9 };
arr[1] = new int[4] { 2, 4, 6, 8 };
Console.Write("{0}", arr[0][3]);
Ранг типа массива задается левой спецификацией_ранга в типе_массива: спецификация_ранга указывает, что массив имеет ранг, равный единице плюс число меток «,» в этой спецификации.
Тип элемента массива представляет собой тип, полученный в результате удаления крайней левой спецификации_ранга:
· Тип массива в форме T[R] указывает массив с рангом R и типом элемента (типом_не_массива) T.
· Тип массива в форме T[R][R1]...[RN] указывает массив с рангом R и типом элемента T[R1]...[RN].
В результате данные спецификации_ранга считываются слева направо перед последним типом элемента (типом_не_массива). Тип int[][,,][,] указывает одномерный массив трехмерных массивов из двумерных массивов значений с типом int.
Создание массива
Типы массивов являются ссылочными типами.
Во время выполнения значение типа массива может быть равно null или может содержать ссылку на экземпляр массива этого типа.
Первичные выражения разделяются на выражения создания массива и первичные выражения создания не массива.
Экземпляры типа массива создаются при помощи выражений создания массива либо путем объявлений полей или локальных переменных, содержащих инициализатор массива.
Пример.
int[] arr = { 1, 2, 3 };
int[] arr1 = new int[3];
int[] arr2 = new int[] { 1, 2, 3 };
int[,] multiDimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };
Элементы массива, созданного с использованием выражений создания массива, всегда инициализируются значениями по умолчанию.
Array – класс
Предоставляет методы для создания, изменения, поиска и сортировки массивов, то есть выступает в роли базового класса для всех массивов в среде CLR. Явно наследовать класс Array может только система и компиляторы. Пространство имен: System.
public abstract class Array Member of System
Модификатор abstract может использоваться с классами, методами, свойствами, индексаторами и событиями. Модификатор abstract в объявлении класса указывает, что класс предназначен только для использования в качестве базового класса для других классов. Создавать экземпляры абстрактного класса нельзя. Конструктора нет. Создавать переменные типа Array можно. Метод CreateInstance, используется вместо открытых конструкторов. Пример
static void Main(string[] args)
{
Array myArr = Array.CreateInstance(typeof(Int32), 3);
foreach (int i in myArr)
{
Console.Write("\t{0}", i);
}
Console.WriteLine();
myArr.SetValue(1, 1);
foreach (int i in myArr)
{
Console.Write("\t{0}", i);
}
}
Пример кода на языке C #.
Примеры по Созданию консольных приложений (Visual C#) доступны по ссылке https://msdn.microsoft.com/ru-ru/library/0fyc0azh.aspx
Пример. Создание консольного приложения Visual C# Console Application.
//директива using с перечислением пространств имен библиотеки классов платформы .NET Framework //определяет префикс System
using System;
// объявление собственного пространства имен
namespace ConsoleApplication2
{
//Класс Program объявлен с единственным членом - статическим методом Main
class Program
{
//Метод Main - точка входа в программу
static void Main(string[] args)
{
string text;
Console.Write("Введите текст\n");
text = Console.ReadLine();
//статический метод WriteLine–класса Console пространства имен System
Console.WriteLine(text);
}
}
}
Результат выполнения программы:
Метод Main объявляется внутри класса или структуры.
Файлы исходного кода С# имеют расширение .cs. C# программы состоят из одного или более исходных файлов. При компиляции C# программ получаются сборки. Сборки имеют расширение .exe или .dll, они реализованы как приложения или как библиотеки.
Общие сведения о системе общих типов (CTS).
Система общих типов определяет способ объявления, использования и управления типами во время выполнения.
Типы и переменные
There are two kinds of types in C#: value types and reference types.
Система общих типов поддерживает две общие категории типов: типы значений и ссылочные типы.
Переменные типа значений содержат данные.
Переменные ссылочного типа хранят ссылки на соответствующие данные (объекты).
К типам значений в C# относятся простые типы, перечисляемые типы, типы структур и обнуляемые типы. К ссылочным типам в C# относятся типы классов, типы интерфейсов, типы массивов и типы делегатов.
Система общих типов CTS в платформе .NET Framework поддерживает следующие категории типов: (из Спецификации языка C# версии 3.0)
Category
Value
types
Simple types
Reference
types
Class types
Для создания нового типа в программах на языке C# его необходимо определить. Можно определить пять пользовательских типов: классы, структуры, интерфейсы, перечисления и делегаты.
Классы и объекты
Класс — это структура данных, объединяющая состояние (поля) и действия (методы и другие функции-члены). Экземпляры класса создаются с помощью оператора new. Класс может содержать статические члены или члены экземпляра. Статические члены принадлежат классам. Члены экземпляра принадлежат объектам (экземплярам класса).
В типе можно определить следующие члены: (Джеффри Рихтер CLR via C#. Программирование на платформе Microsoft .NET Framework 2.0 на языке C# Питер, Русская Редакция 2007)
Константа. Идентификатор, определяющий постоянную величину. Константы связаны с типом, а не с экземпляром.
Поле. Представляет неизменяемое или изменяемое значение. Поле может быть статическим – тогда оно является частью типа и экземплярным - тогда оно является частью объекта.
Метод. Представляет собой функцию, выполняющую операции, которые изменяют или запрашивают состояние типа (статический метод) или объекта (экземплярный метод).
Конструктор экземпляра– метод, используемый для инициализации полей экземпляра при его создании.
Конструктор типа – метод, используемый для инициализации статических полей типа.
Свойство. Для того чтобы можно было изменить значение (получить значение) закрытой переменной, необходимо использовать свойства или функции доступа (accessors). Для вызывающей стороны этот член выглядит как поле, но в реализации типа он выглядит как метод.
Перегруженный оператор.
Оператор преобразования.
Событие.
Тип. Позволяет определять другие вложенные в него типы.
Встроенные числовые типы (из Спецификации языка C# версии 3.0).
| Category | Bits | Type | Range/Precision |
| Signed integral
| 8 | sbyte | –128...127 |
| 16 | short | –32,768...32,767 | |
| 32 | Int | –2,147,483,648...2,147,483,647 | |
| 64 | Long | –9,223,372,036,854,775,808...9,223,372,036,854,775,807 | |
| Unsigned integral | 8 | Byte | 0...255 |
| 16 | ushort | 0...65,535 | |
| 32 | Uint | 0...4,294,967,295 | |
| 64 | ulong | 0...18,446,744,073,709,551,615 | |
| Floating point | 32 | float | 1.5 × 10−45 to 3.4 × 1038, 7-digit precision |
| 64 | double | 5.0 × 10−324 to 1.7 × 10308, 15-digit precision | |
| Decimal | 128 | decimal | 1.0 × 10−28 to 7.9 × 1028, 28-digit precision |
Тип bool используется для представления логических значений true или false.
Тип char используется для объявления символа Юникода (кода UTF-16).
Для создания переменных в программах C# используются оператор объявления. В операторе объявления необходимо указать тип и имя создаваемой переменной. Каждая переменная по значению должна быть инициализирована перед использованием (ей должно быть присвоено значение). Простые типы можно инициализировать с помощью литералов.Пример. Объявление и инициализация переменных: sbyte, short, int, long. Форматирование числовых результатов при выводе данных на консоль.
using System;
namespace ConsoleApplication2
{
class Program
static void Main(string[] args)
{
sbyte sByte1 = 127;
short x = 32767;
int i = 123;
long long1 = 4294967296;
Console.WriteLine("Переменная sbyte{0,4:d} Переменная short{1,6:d} " +
" Переменная int{2,4:d} Переменная long{3,11:d}", sByte1, x, i,long1);
}
}
}
Для форматирования числовых результатов при выводе данных на консоль можно использовать составное форматирование. Общая форма записи спецификатора формата в составном форматировании имеет следующий вид: {номер_ аргумента[, ширина][: формат]}. Парные фигурные скобки ("{" и "}") здесь обязательны.
номер_ аргумента – описатель параметра, число, определяющее соответствующий объект из списка; индексация элементов ведется от нуля. Например, если имеется три объекта, то можно отформатировать сначала второй, а затем первый и третий объекты, задав следующую строку составного форматирования: "{1} {0} {2}".
Необязательный компонент ширина (alignment) — это целое число со знаком, которое служит для указания желательной ширины поля форматирования.
Необязательный компонент формат — это строка формата, соответствующая типу форматируемого объекта.
Пример. Объявление и инициализация переменных: float, double, decimal. Форматирование числовых результатов.
using System;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
float x = 3.5555F;
double y = 3.5555;
decimal myMoney = 300.5m;
Console.WriteLine("Переменная float {0:f} Переменная double {1:f}" +
" Переменная decimal {2:c}", x, y, myMoney);
}
}
}
using System;
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
float x = 3.5555F;
double y = 3.5555;
decimal myMoney = 300.5m;
Console.WriteLine("Переменная float {0:##.#} Переменная double {1:#.###}" +
"Переменная decimal {2:c}", x, y, myMoney);
}
}
}
Литералы
Литерал — это представление значения в исходном коде.
Символьные литералы
char[] chars = new char[4];chars[0] = 'X'; // Character literalchars[1] = '\x0058'; // Hexadecimalchars[2] = (char)88; // Cast from integral typechars[3] = '\u0058'; // Unicodeлогические литералы
true
false
Литерал_null
null
Целочисленные литералы
Цифры от 0 до 9. Чтобы указать, что литерал представляет собой число без знака, он снабжается
суффиксом u или U, например:
uint i = 12u;
Console.WriteLine("{0:d}", i);
Суффиксы l или L применяются для создания литералов типа long и ulong:
long i = 1222L;
Console.WriteLine("{0:d}", i);
шестнадцатеричные числа
long i = 0xFFFF;
Console.WriteLine("{0:x}", i);
Литералы с плавающей точкой
float i = 10.0f;
Console.WriteLine("{0:f}", i);
double i = -3.7E-10D;
Console.WriteLine("{0:e}", i);
Строковые литералы
string i = "eeeeee\nyyyyyyyyy";
Console.WriteLine(i);
В языке С# строковый литерал может иметь префикс @. Он задает так называемый
буквальный литерал
string i =@"c:\";
Console.WriteLine(i);
Подробнее в спецификации языка C#.Встроенные числовые типы являются структурами, и к их свойствам и методам и другим членам можно получить доступ.
Пример. Объявление и инициализация переменной типа bool. Вывод данных на консоль.
using System;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
bool b = true;
// WriteLine автоматически конвертирует значение переменной b в текст.
Console.WriteLine(b);
}
}
}
Тип char представляет 16-разрядные целые числа без знака в диапазоне от 0 до 65535. Набор возможных значений для типа char соответствует набору символов Юникода.
Пример. Объявление и инициализация четырех переменных типа char, имеющих одно и тоже значение - символ X.using System;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
char char0 = 'X'; // Символьный литерал
char char1 = '\x0058'; // шестнадцатеричная escape-последовательность
char char2 = (char)88; // Преобразование типа int в char
char char3 = '\u0058'; // Юникод
Console.WriteLine("{0} {1} {2} {3}", char0, char1, char2, char3);
}
}
}
Тип char классифицируется как целый тип, однако имеет два отличия от других целых типов:
· Не поддерживается неявное преобразование из других типов к типу char. В частности, несмотря на то, что диапазоны значений для типов sbyte, byte и ushort могут быть полностью представлены с помощью типа char, неявное преобразование из типов sbyte, byte и ushort к типу char не существует.
· Константы типа char должны записываться в виде символьных или целочисленных_литералов в сочетании с приведением к типу char. Например, записи (char)10 и '\x000A' аналогичны.
Использование класса System.Console .
Консолью называется окно операционной системы, в котором пользователи взаимодействуют с операционной системой. Приложение может считывать пользовательский ввод из стандартного входного потока, записывать обычные данне в стандартный выходной поток и записывать данные об ошибках в стандартный поток сообщений об ошибках.
Пример. Чтение из стандартного входного потока и запись в стандартный выходной поток
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Введите x");
String name = Console.ReadLine();
int a = int.Parse(name);
Console.WriteLine(a);
}
}
}
В примере статический метод Console.WriteLine("Введите x") записывает данные в стандартный выходной поток; статический метод Console.ReadLine() считывает входные данные из стандартного входного потока. Возвращаемое методом Console.ReadLine() значение присваивается переменной name типа String; статический метод int.Parse(name) преобразует строковое представление числа в эквивалентное ему 32-битовое целое число со знаком. Возвращаемое методом значение присваивается переменной а типа int; Статический метод Console.WriteLine(a) выводит результирующее целочисленное значение на консоль. Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int i = 5;
double y = 9;
Console.WriteLine(i.ToString("d")+" "+y.ToString("f2"));
}
}
}
Использование аргументов командной строки в консольном приложении.К аргументам командной строки можно получить доступ при помощи дополнительного массива строк, связанного с методом Main. При выполнении приложения в Visual Studio можно указать аргументы командной строки в Страница "Отладка" в конструкторе проектов.
Пример.using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("parameter count = {0}", args.Length);
for (int i = 0; i < args.Length; i++)
{
System.Console.WriteLine("Arg[{0}] = [{1}]", i, args[i]);
}
}
}
}
Идентификаторы используются для обозначения переменных. В идентификаторах разрешены: знак подчеркивания в качестве начального символа, escape-последовательности Юникода, символ «@» в качестве префикса, чтобы можно было использовать ключевые слова в качестве идентификаторов.
Ключевое слово — это зарезервированная последовательность символов.
Операторы языка
Действия программы выражаются с помощью операторов. Оператор может состоять из одной строки кода, которая заканчивается точкой с запятой, или из ряда однострочных операторов в блоке. Блок оператора заключен в скобки ({}) и может содержать вложенные блоки.
Типы операторов.
Операторы объявления
Операторы выражений
Операторы выбора
Операторы итераций
Операторы перехода
Внедренный оператор. В операторах do, while, for и foreach, всегда есть внедренный оператор, следующий за ними. Этот внедренный оператор может быть либо одним оператором, либо несколькими операторами, заключенными в скобки ({}) в блоке оператора. Даже однострочные внедренные операторы могут быть заключены в скобки ({}).
Вложенные блоки операторов. Блоки операторов могут быть вложенными.
Оператор объявления объявляет локальную переменную или константу. Операторы объявления разрешается использовать в блоках, но запрещается использовать как внедренные операторы.
Оператор = называется простым оператором присваивания.
Области объявления
Объявление определяет имя в области объявления, которому принадлежит объявление.
Нельзя использовать одно имя для двух или более объявлений в одной области объявления за исключением перегруженных членов.
Пространства имен могут содержать объявления типов и вложенных пространств имен.
Пространства имен и типы, имеющие родительское пространство имен, являются членами глобального пространства имен.
Пространства имен и типы, объявленные в рамках пространства имен, являются членами данного пространства имен.
Каждое объявление типа: класса, структуры, интерфейса, делегата, перечисляемого типа создает новую область объявления.
Каждое объявление метода, объявление индексатора, объявление оператора, объявление конструктора экземпляров создает новую область объявления, которая называется областью объявлений локальных переменных.
Каждый блок или блок_switch, а также инструкции for, foreach и using создают область объявлений для локальных переменных и локальных констант .
Блоки, встречающиеся в качестве тела члена функции, вложены в область объявлений локальных переменных, объявленной этими функциями для соответствующих параметров. Следовательно, наличие, к примеру, метода с одинаковыми именами локальной переменной и параметра является ошибкой.
Области видимости
Областью видимости имени является часть текста программы, в рамках которой можно ссылаться на переменную, имеющее данное имя. Области могут быть вложенные, в рамках вложенного блока невозможно объявить локальную переменную с именем, совпадающим с именем локальной переменной во внешнем блоке.
Пример программы, которая завершится с ошибкой «Невозможно объявить локальную переменную с именем "a" в этой области видимости, т.к. другое значение "a", уже используется в области видимости "родительский или текущий"
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int a = 0;
Console.WriteLine(a);
{
int a = 6;
Console.WriteLine(a);
}
}
}
}
Пример. Объявление локальных переменных, которое не приведет к ошибке.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
{
int a = 0;
Console.WriteLine(a);
}
{
int a = 6;
Console.WriteLine(a);
}
}
}
}
Областью члена пространства имен, объявленного объявлением члена пространства имен, является полный текст программы.
Областью члена, объявленного объявлением члена типа, является тело типа, в котором сделано объявление.
Областью параметра, объявленного в объявлении метода, является тело метода данного объявления метода.
Областью локальной переменной, объявленной в объявлении локальной переменной, является блок, в котором содержится объявление.
Областью локальной переменной, объявленной в блоке ветвления оператора switch, является блок ветвления.
Областью локальной переменной, объявленной в инициализаторе for оператора for, является инициализатор for, условие for, итератор for и содержащий оператор оператора for.
Областью локальной константы, объявленной в объявлении локальной константы, является блок, в котором содержится объявление. Ссылка на локальную константу в текстовой позиции, предшествующей декларатору константы, является ошибкой времени компилирования.
Переменные
В C# определено семь категорий переменных: статические переменные, переменные экземпляра, элементы массива, параметры по значению, параметры по ссылке, выходные параметры и локальные переменные.
Локальные переменные
Локальную переменную можно объявить в блоке, в операторе for, в операторе switch или операторе using, а также в операторе foreach или в конструкции catch в операторе try.
Объявление локальной переменной состоит из типа локальной переменной, идентификатора, определяющего имя переменной, за которым могут следовать оператор присваивания
и инициализатор локальной переменной, присваивающий переменной начальное значение.
При объявлении локальная переменная не инициализируется автоматически и поэтому не имеет значения по умолчанию (считается не имеющей начального значения).
Пример. Объявление нескольких локальных переменных.
int x = 1, y, z = x * 2;
Примеры. Операторы языка.
Оператор_итераций for
Цикл for повторно выполняет оператор или блок операторов, пока определенное выражение не примет значение false.
В цикле for может содержаться инициализатор for, условие for, итератор for, содержащий оператор оператора for (внедренный оператор)
оператор_for:
for ( инициализатор_forнеобязательно ; условие_forнеобязательно ; итератор_forнеобязательно ) внедренный_оператор
Инициализатор содержит объявление локальной переменной
Условием является логическое выражение
Итератор это выражение
В следующем примере значение переменной int i записывается в консоль, и i увеличивается на 1 за каждое прохождение цикла.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int i = 0;
for (i = 1; i <= 5; i++)
{
Console.WriteLine(i);
}
Console.WriteLine(i);
}
}
}
Все выражения оператора for являются необязательными. Например, следующий оператор используется для создания бесконечного цикла:
C #
for (; ; )
{
// ...
}
Оператор_итераций while
Оператор while выполняет внедренный оператор несколько раз (возможно, ни разу) в зависимости от соблюдения условия.
оператор_while:
while ( логическое_выражение ) внедренный_оператор
Оператор while выполняется следующим образом.
Вычисляется логическое_выражение Если результатом логического выражения является true, управление передается внедренному оператору. Если управление достигает конечной точки внедренного оператора (возможно, в результате выполнения оператора continue), управление передается в начало оператора while.
Если значением логического выражения является false, управление передается в конечную точку оператора while.
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int n = 1;
while (n < 6)
{
Console.WriteLine("Current value of n is {0}", n);
n++;
}
}
}
}
Оператор выбора if
Оператор if выбирает оператор языка для выполнения на основании значения логического выражения.
оператор_if:
if ( логическое_выражение ) внедренный_оператор
if ( логическое_выражение ) внедренный_оператор else внедренный_оператор
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
// Проверяем четность числа
// Вводим проверяемое значение
int Num;
string Str;
Console.Write("Введите число: ");
Str = Console.ReadLine();
Num = int.Parse(Str);
// если число делится на 2 без остатка то четное
// оператор % - это остаток от целочисленного деления
if (Num % 2 == 0)
{
Console.WriteLine("Число {0} - четное", Num);
}
else
{
Console.WriteLine("Число {0} - нечетное", Num);
}
Console.ReadKey();
}
}
}
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
// Найти чему будет равно выражение C = min(A,B)
// A и B целые числа, которые нужно ввести с клавиатуры
// Вывести результат и исходное выражение, подставив числа
// Введем исходные значения A и B
int A, B, C;
string Str;
Console.Write("A = ");
Str = Console.ReadLine();
A = int.Parse(Str); // Parse - статический метод структуры int
Console.Write("B = ");
Str = Console.ReadLine();
B = int.Parse(Str);
//Находим значение выражения
int min;
if (A < B)
min = A;
else
min = B;
C = min;
// Выводим результат
Console.WriteLine("min({0},{1})) = {2}", A, B, C);
Console.ReadKey();
}
}
}
Оператор выбора switch
Оператор switch выбирает для выполнения список операторов, метка которого соответствует значению switch-выражения.
оператор_switch:
switch ( выражение ) блок_switch
блок_switch:
{ разделы_switchнеобязательно }
разделы_switch:
раздел_switch
разделы_switch раздел_switch
раздел_switch
метки_switch список_операторов
метки_switch:
метка_switch
метки_switch метка_switch
метка_switch:
case константное_выражение :
default :
Вычисляется switch-выражение.
Если значение константы, указанной в метке case, совпадает со значением switch-выражения, управление передается списку операторов, следующему за меткой case.
Если ни одна из констант, указанных в метках case оператора switch, не совпадает со значением switch-выражения и при этом имеется метка default, управление передается списку операторов, следующему за меткой default, если метка default отсутствует, управление передается в конечную точку оператора switch.
Если после выполнения одного раздела (раздел заключен в {} скобки) switch должно следовать выполнение другого раздела switch, необходимо явным образом указывать оператор goto case или goto default.
Ошибка времени компиляции возникает, если несколько меток case в одном операторе switch задают одно и то же константное значение.
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int caseSwitch = 5;
switch (caseSwitch)
{
case 1:
Console.WriteLine("Case 1");
break;
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}
}
}
}
Список операторов раздела switch обычно заканчивается оператором break, goto case или goto default.
Если за меткой case нет списка операторов, то операторы break, goto case или goto default необязательны
В примере управление передается списку операторов, следующему за меткой case 2
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
int caseSwitch = 1;
switch (caseSwitch)
{
case 1:
case 2:
Console.WriteLine("Case 2");
break;
default:
Console.WriteLine("Default case");
break;
}
}
}
}
Оператор итераций do
Оператор do выполняет внедренный оператор один или несколько раз в зависимости от соблюдения условия.
оператор_do:
do внедренный_оператор while ( логическое_выражение ) ;
Управление передается внедренному оператору.
Если управление достигает конечной точки внедренного оператора, вычисляется логическое выражение.
Если результатом логического выражения является true, управление передается в начало оператора do. В противном случае управление передается в конечную точку оператора do.
Пример.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int x = 0;
do
{
Console.WriteLine(x);
x++;
} while (x < 5);
}
}
}
Операторы перехода
Операторы перехода осуществляют безусловную передачу управления. Операторы перехода могут передавать управление за пределы блока, но они никогда не передают управление внутрь блока.
Оператор break осуществляет выход из ближайшего объемлющего оператора switch, while, do, for или foreach.
Оператор continue начинает новую итерацию ближайшего объемлющего оператора while, do, for или foreach goto
Оператор return возвращает управление в программу, вызвавшую функцию-член, в которой используется оператор return. Оператор return с выражением может использоваться только в функции-члене, вычисляющей значение, т. е. в методе с типом возвращаемого значения, отличным от void, в методе доступа get для свойства или индексатора или в операторе, определенном пользователем.
Приведение и преобразование типов.
Преобразования бывают явными и неявными.
int a = 123;
long b = a; // implicit conversion from int to long
// неявное перобразование типов, из int к long
int c = (int) b; // explicit conversion from long to int
// явное перобразование типов, из long к int
Неявные преобразования.
При вызове члена функции (метода). Для параметра имеющего тип значения вычисляется выражение аргумента и выполняется неявное преобразование в соответствующий тип параметра. Пример.
using System;
namespace ConsoleApplication5
{
class Program
{
static double f(double a, double b)
{
return a + b;
}
static void Main(string[] args)
{
int r = 2222;
double rez = f(r, 42222);
Console.WriteLine(rez);
}
}
}
Неявное преобразование при использовании оператора присваивания.
Пример. Неявное преобразование числового типа: из int к long. Компилятор неявно преобразует значение справа в тип long перед присвоением его переменной bigNum. Преобразование от меньшего к большему целому типу.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main(string[] args)
{
int num = 2147483647;
long bigNum = num;
}
}
}
Неявные преобразования числовых типов.
Существуют следующие неявные преобразования числовых типов:
· из sbyte к short, int, long, float, double или decimal;
· из byte к short, ushort, int, uint, long, ulong, float, double или decimal;
· из short к int, long, float, double или decimal;
· из ushort к int, uint, long, ulong, float, double или decimal;
· из int к long, float, double или decimal;
· из uint к long, ulong, float, double или decimal;
· из long к float, double или decimal;
· из ulong к float, double или decimal;
· из char к ushort, int, uint, long, ulong, float, double или decimal;
· из float к double.
Преобразования из типов int, uint, long или ulong к float, а также из long или ulong к double могут привести к потере точности, но не величины. Другие неявные преобразования числовых типов никогда не приводят к потере данных.
Неявных преобразований к типу char не существует, поэтому значения любых других целых типов не могут быть преобразованы к типу char.
Неявные преобразования ссылочных типов
Существуют следующие неявные преобразования ссылочных типов:
Из любого ссылочного типа к object.
Из производного класса к базовому классу.
Из типа класса S к типу интерфейса T (где S реализует T).
Из типа интерфейса S к типу интерфейса T (где S является производным от T).
Из любого типа массива к System.Array и реализуемым им интерфейсам.
Из типа_массива S, который имеет тип элементов SE, к типу_ массива T, который имеет тип элементов TE, если выполняются следующие условия:
S и T различаются только по типу элементов. Другими словами, типы S и T имеют одинаковое число измерений.
SE и TE являются ссылочными_типами.
Существует неявное преобразование ссылочного типа из SE к TE.
Пример
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
string[] t = new string[2] { "vv", "kkk" };
object[] tt = new object[2];
tt = t;
}
}
}
Пример
Если элемент массива ссылочного типа передается в качестве параметра ссылки или вывода, во время выполнения необходимо убедиться, что фактический тип элементов массива идентичен типу параметра.
using System;
namespace ConsoleApplication5
{
class Program
{
static void F(ref object x) { }
static void Main()
{
object[] a = new object[10];
object[] b = new string[10];
F(ref a[0]); // Ok
F(ref b[1]); // ArrayTypeMismatchException
}
}
}
Понятие упаковки и распаковки является ключевым в системе типов C#. С помощью данных операций осуществляется связь между типами значений и ссылочными типами за счет возможности преобразования любого значения типа значений к типу object и обратно.
Преобразования упаковки
Преобразование упаковки обеспечивает неявное преобразование типа значений в ссылочный тип.
из любого типа значений к типу object. Пример .
int i = 123;
object box = i;
Явные преобразования
Выражение приведения типа используется для явного преобразования выражения в данный тип.
выражение_приведения_к_типу:
( тип ) унарное_выражение
Выражение_приведения_типа вида (T)E, где T является типом, а E —унарным_выражением, выполняет явное преобразование значения E в тип T.
Явные преобразования числовых типов.
Явные преобразования числовых типов предназначены для преобразования из одного числового_типа к другому числовому_типу, для которого не существует неявного преобразования:
· из sbyte к byte, ushort, uint, ulong или char;
· из byte к sbyte и char;
· из short к sbyte, byte, ushort, uint, ulong или char;
· из ushort к sbyte, byte, short или char;
· из int к sbyte, byte, short, ushort, uint, ulong или char;
· из uint к sbyte, byte, short, ushort, int или char;
· из long к sbyte, byte, short, ushort, int, uint, ulong или char;
· из ulong к sbyte, byte, short, ushort, int, uint, long или char;
· из char к sbyte, byte или short;
· из float к sbyte, byte, short, ushort, int, uint, long, ulong, char или decimal;
· из double к sbyte, byte, short, ushort, int, uint, long, ulong, char, float или decimal;
· из decimal к sbyte, byte, short, ushort, int, uint, long, ulong, char, float или double.
Пример. Для выполнения явного преобразования числового типа необходимо
заключить тип, в который производится преобразование (приведение), в скобки перед преобразуемым значением или переменной. Следующая программа выполнят приведение типа double в тип int.
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
double x = 1234.7;
int a;
// Cast double to int.
a = (int)x;
System.Console.WriteLine(a);
}
}
}
Если x и y являются идентификаторами, то (x)y, (x)(y) и (x)(-y) являются выражениями приведения типа, а (x)-y не является, даже если x обозначает тип. Однако если x является ключевым словом, которое обозначает стандартный тип (например, int), то все четыре вида выражения являются выражениями приведения типа (потому что такое ключевое слово не может само быть выражением). Пример .
using System;
namespace ConsoleApplication5
{
class Program
{
static void Main()
{
double x = 1234.7;
int a;
// Cast double to int.
a = (int)-x;
System.Console.WriteLine(a);
}
}
}
Результат
Дата: 2019-07-30, просмотров: 232.
