Начало

Схема выполнения программы в .NET

Среда Visual Studio.NET
Среда разработки Visual Studio.NET предоставляет мощные и удобные средства написания, корректировки, компиляции, отладки и запуска приложений, использующих .NET-совместимые языки (C#, VB.NET, C++ и J#
Платформа .NET является открытой средой. Это значит, что компиляторы для неё не могут поставляться и сторонними разработчиками. К настоящему времени разработаны десятки компиляторов для .NET, например, Ada, COBOL, Delphi, Eiffel, Lisp, Oberon, Perl, Python.
Все .NET –совместимые языки должны отвечать требованиям общеязыковой спецификации (Common Language Specification, CLS), в которой описывается набор общих для всех языков характеристик. Это позволяет использовать для разработки приложения несколько языков программирования и вести полноценную межъязыковую отладку. Все программы независимо от языка используют те же базовые классы библиотеки .NET.
Приложение в процессе разработки называется проектом. Проект объединяет всё необходимое для создания приложения: файлы, папки, ссылки и прочие ресурсы. Среда Visual Studio.NET позволяет создавать проекты различных типов, например:
- Windows-приложение использует элементы интерфейса Windows, включая формы, кнопки, флажки и пр.;
- консольное приложение выполняет вывод на экран «на консоль», то есть в окно командного процессора;
- библиотека классов объединяет классы, которые предназначены для использования в других приложениях;
- веб-приложение – это приложение, доступ к которому выполняется через браузер (например, Internet Explorer) и которое по запросу формирует веб-страницу и отправляет её клиенту по сети;
- веб-сервис – компонент, методы которого могут вызываться через Интернет.

Консольные приложения
Среда Visual Studio.NET работает на платформе Windows и ориентирована на создание Windows- и веб-приложений, однако разработчики предусмотрели работу и с консольными приложениями. При запуске консольного приложения операционная система создаёт так называемое консольное окно, через которое идёт весь ввод-вывод программ. Внешне это напоминает работу в операционной системе в режиме командной строки, когда ввод-вывод представляет собой поток символов.
Заготовка консольной программы
using System;
namespace ConsoleApplication1
{
class Class1
{
//[STAThread]
static void ]Main(string[ ] args)
{
//основное тело программы
Console.WriteLine(“Любая строка текста”); }
}
}

Алфавит и лексемы
Алфавит С# включает:
буквы (латинские и национальных алфавитов) и символ подчеркивания (_) который употребляется наряду с буквами;
цифры;
специальные символы, например +, *, { и &;
пробельные символы (пробел и символы табуляции);
символы перевода строки.
Из символов составляются более крупные строительные блоки: лексемы, директивы препроцессора и комментарии.
Лексема (token) - это минимальная единица языка, имеющая самостоятельный смысл. Существуют следующие виды лексем:
имена (идентификаторы);
ключевые слова;
знаки операций;
разделители;
литералы (константы).
Директивы препроцессора пришли в С# из его предшественника - языка C++. Препроцессором называется предварительная стадия компиляции, на которой формируется окончательный вид исходного текста программы.
Оператор задаёт законченное описание некоторого действия, данных или элемента программы. Например: int a; // это – оператор описания целочисленной переменной а.

Ключевые слова С#
break
checked
default
ehum
finally
goto
interface
namespace
out
public
sealed
string
true
unchecked
void.bool
char
decimal
else
false
foreach
int
long
operator
protected
sbyte
static
throw
ulong
virtual
base
catch
continue
double
extern
for
in
lock
object
private
return
stackalloc
this
uint
using as
case
const
do
explicit
float
implicit
is
null
params
ref
sizeof
switch
typeof
ushort
while
abstract
byte
class
delegate
event
fixed
if
internal
new
override
readonly
short
struct
try
unsafe
volatile

Операции С#
Операции делятся на унарные, бинарные и тернарную по количеству участвующих в них операндов. Один и тот же знак может интерпретироваться по-разному в зависимости от контекста. Все знаки операций, за исключением [ ], ( ) и ? :, представляют собой отдельные лексемы.
Разделители используются для разделения или, наоборот, группирования элементов. Примеры разделителей: скобки, точка, запятая. Ниже перечислены знаки операций и разделители, использующиеся в С#:
первичные { } [ ] ( ) . , : ; ->
унарные + - ++ --
бинарные + - * / %
битовые сдвига << >> и поразрядные логические ~ | & ^
отношения == != < > <= >=
логические ! && ||
тернарная ? :
присваивания = += -= *= /= %= битовые <<= >>= &= ^= |=

Пример применения поразрядных логических операций
using System;
namespace ConsoleApplicationl
{ class Classl
{ static void Main() {
Console.WriteLine( 6 & 5 ); // Результат 4
Console.WriteLine( 6 | 5 ); // Результат 7
Console.WriteLineC 6 ^ 5 ); / Результат 3 } } }
6&5=110&101=100=4 (истина - только обе единицы)
6|5=110|101=111=7 (ложь- только оба нули)
6^5=110^101=011=3 (разные – единица, одинаковые-нули)
Операции СДВИГА
а=3=011 а<<1=110=6 (освободившиеся позиции заполняются нулями)
а=3=011 а<<2= 1100 =12
b=9==0.1001 b>>1=4=0.0100 (число положительное, освобождающиеся разряды знаковым разрядом - нулем)
Операция ДЕЛЕНИЯ
11/4(целые)=целочисленное деление (остаток не учитывается)=2
11/4 (вещественные)=вещественное деление (с остатком)=2.75
11%4 = 3
Операция ОТРИЦАНИЯ
Пусть а=3=0.011 Тогда ~a=1.100=-4 (0.100 прямой, 1.011 обратный, 1.100 дополнительный)

Классификация типов данных в С#

Классификация типов данных в С#

Встроенные типы языка С#

int b = 1, а = 100;
int x = b * а + 25:
class X // начало описания класса X
{
int А; // поле А класса X
int В; // поле В класса X
void Y() // --------------------------------------- метод Y класса X
{
int С; // локальная переменная С, область действия - метод Y
int A; // локальная переменная А (НЕ конфликтует с полем А)
{ // ============ вложенный блок 1 ============
int D; // локальная переменная D, область действия - этот блок
int А; // недопустимо! Ошибка компиляции, конфликт с локальной переменной А
С = В; // присваивание переменной С поля В класса X
С = this.А; // присваивание переменной С поля А класса X
} // ============ конец блока 1 ===============
{ // ============ вложенный блок 2 ============
int D; // локальная переменная D, область действия - этот блок
} // ============ конец блока 2 ===============
} //--------------------------------- конец описания метода Y класса X
} // конец описания класса X
Пример описания переменных

Математические функции – класс Math
Имя метода Описание Пояснения
Abs Модуль |x|, записывается как Abs(x)
Acos Арккосинус Acos(double x), угол задается в радианах
Asin Арксинус Asin(double x)
Atan Арктангенс Atan(double x)
Atan2 Арктангенс Atan2(double x,double y) –угол, тангенс которого есть результат деления y на х
BigMul Произведение BigMul(int x,int y)
Celling Округление до большего целого Celling(double x)
Cos Косинус Cos(double x)
Cosh Гиперболический косинус Cosh(double x)
DivRem Деление и остаток DivRem(x,y,rem)
E Число е 2,71828182845905
Exp Экспонента Exp(x)
Floor Округление до меньшего целого Floor(double x)
IEEERemainder Остаток от деления IEEERemainder(double x, double y)
Log Натуральный логарифм Log(x)
Log10 Десятичный логарифм Log10(x)
Max Максимум из 2-х чисел Max(x,y)

Математические функции – класс Math

Пример линейной программы расчета по заданной формуле
using System;
namespace ConsoleApplicationl
{ class Classl
{ static void Main()
{
string buf;
Console.WriteLine(“Введите x”);
buf=Console.ReadLine();
double x=Convert.ToDouble(buf);
Console.WriteLine(“Введите alfa”);
buf=Console.ReadLine();
double a=double.Parse(buf);
double y=Math.Sqrt(Math.PI*x)-
Math.Exp(0.2*Math.Sqrt(a))+
2*Math.Tan(2*a)+
1.6e3*Math.Log10(Math.Pow(x,2));
Console.WriteLine(“Для х= {0} и alfa ={1}”, x,a);
Console.WriteLine(“Результат =” +y);
Console.ReadKey(); }}}

Операторы языка C#
for (int j=1; j<5; j++) //оператор цикла {;;;}; //пустой оператор
Примеры оператора if
if (a<0) b=1;
if (a
d||a= =0) ) b=++; else {b*=a;a=0;}
if (a
switch(выражение) {
case константное_выражение_1: [операторы_1 оператор_перехода_1] ... case константное_выражение_K: [операторы_K оператор_перехода_K]
[default: операторы_N оператор_перехода_N]}
Операторов перехода, позволяющих прервать естественный порядок выполнения операторов блока, в языке C# несколько:
оператор безусловного перехода goto;
оператор выхода из цикла break;
оператор перехода к следующей итерации цикла continue;
оператор возврата из функции return;
оператор генерации исключения throw.

Операторы цикла
Цикл с предусловием while имеет формат:
while ( выражение ) оператор
Цикл с постусловием do имеет вид:
do оператор while выражение;
Цикл с параметром имеет следующий формат:
for ( инициализация; выражение модификации; ) оператор;
Цикл перебора foreach используется для просмотра всех объектов из некоторой группы данных, например массива, списка или другого контейнера.

В языке С# массив относится к ссылочным типам данных, то есть располагается только в динамической памяти, поэтому создание массива начинается с выделения памяти под его элементы. Всем элементам при создании массива присваиваются значения по умолчанию – нули для значимых типов, и null для ссылочных. Все массивы в С# имеют общий базовый класс Array, определенный в пространстве имен System. using System;
namespace ConsoleApplication1
{class Class1
{ static void Main()
{ const int n=6; int [] a= new int[n] {3,12,5,-9,8,-4};
Console.WriteLine(“Исходный массив: ”);
for (int i=0;i
int s=0,k=0;
for (int i=0;i
Console.WriteLine(“Сумма отрицательных ”+s);
Console.WriteLine(“Количество отрицательных ”+k); }}}

Примеры описания двумерных массивов:
int [,] a; //элементов нет
int [,] b=new int [2,3]; //элементы равны 0
int [,] c={{1,2,3},{4,5,6}}; //new подразумевается
int [,] d=new int[,]{{1,2,3},{4,5,6}}; //размерность вычисляется
int [,] e=new int [2,3] {{1,2,3},{4,5,6}}; //избыточное описание
{class Class1
{static void Main() {int [] a= {3,12,5,18,-9,8,-4};
PrintArray (“Исходный массив:”, a); //пользовательская функция (метод)
Console.WriteLine(Array.IndexOf(a,18); Array.Sort(a);
PrintArray (“Отсортированный массив:”, a);
Console.WriteLine(Array.BinarySearch(a,18)); }//конец Main()
public static void PrintArray(string s, int[] a)
{Conole.WriteLine(s);
for (int i=0;i
Console.Write(“\t”+a[i]);Console.WriteLine();} //конец функции
}//конец класса Class1

Основные элементы класса Array

Оператор foreach для работы с массивами
int [] a= {3,12,5,-9,8,-4};
Console.WriteLine(“Исходный массив: ”);
foreach (int x in a) Console.Write(“\t” +x); Console.WriteLine();
Использование оператора foreach для вывода на экран двумерного массива имеет вид:
foreach (int [] x in a)
{foreach (int y in x) Console.Write(“\t”+y);
Console.WriteLine();}

Для получения псевдослучайной последовательности чисел необходимо сначала создать экземпляр класса с помощью конструктора: Random a = new Random();

Пример работы с генератором псевдослучайных чисел
using System:
namespace ConsoleApplicationl
{ class Classl
{ static void Main()
{ Random a = new Random();
Random b = new Random(1);
const int n = 10;
Console.WriteLine( "\n Диапазон [0, 1]:" );
for ( int i = 0; i < n; ++i ) Console.Write( "{0 ,6:0.##}", a.NextDouble() );
Console.WriteLine( "\n Диапазон [0, 1000]:" );
for ( int i = 0; i < n; ++i ) Console.Write( " " + b.Next(1000) );
Console.WriteLine( "\n Диапазон [-10, 10]:" );
for ( int i = 0; i < n; ++i ) Console.Write( " " + a.Next(-10, 10) );
Console.WriteLine( "\n Массив [0, 255]:" );
byte[] mas = new byte[n];
a.NextBytes( mas );
for (int i = 0; i < n; ++i) Console.Write( " " + mas[i] ); } } }

Для работы со строками в языке C# существует несколько возможностей:
используя символьный тип char(символ), который соответствует классу System.Char, для организации строки – массив символов типа char, который соответствует классу System.Array
используя строки типа String, ему соответствует базовый класс System.String библиотеки .NET. , его объекты должны оставаться неизменны.
используя строки типа StringBuilder. В этом случае для работы со строками применяется класс StringBuilder, определенный в пространстве имен System. Text и позволяющий изменять значение своих экземпляров.

Функции (методы) в языке С#
Метод, не возвращающий значение – вызывается как отдельный оператор.
Метод, возвращающий значение - вызывается в правой части оператора присваивания.
Если метод возвращает значение, оно передается в точку вызова. Если метод имеет тип void управление передается на оператор, следующий после вызова.
Параметры, описываемые в заголовке метода, определяют множество значений аргументов, которые можно передавать в метод. Список аргументов при вызове метода должен соответствовать списку параметров по количеству, порядку следования и типу. Для каждого параметра должны задаваться его тип и имя. Существует два способа передачи параметров: по значению и по ссылке.
При передаче по значению метод получает копии аргументов, и операторы внутри метода работают с этими копиями. Доступа к исходным значениям аргументов у метода нет, и, следовательно, нет возможности их изменять.
При передаче по ссылке (по адресу) метод получает адреса аргументов, осуществляет доступ к ячейкам памяти по этим адресам, следовательно может изменять значения аргументов, модифицируя параметры. В языке C# для обмена данными между вызывающей и вызываемой функциями есть 4 типа параметров: - параметры-значения void func(int x)
- параметры-ссылки void func(ref int x)
- выходные параметры static void p(int a, out int b, out int c)
- параметры-массивы

Одним из основных достоинств языка C# является его схема работы с памятью: автоматическое выделение памяти под объекты и автоматическая уборка мусора. При этом невозможно обратиться по несуществующему адресу памяти или выйти за границы массива, что делает программы более надежными и безопасными.
В некоторых случаях возникает необходимость работать с адресами памяти непосредственно, например, при взаимодействии с операционной системой, написании драйверов и др. Такую возможность представляет так называемый небезопасный (unsafe) код, выполнение которого среда CLR не контролирует.
Указатели являются отдельной категорией типов данных. Они не наследуются от типа object, и преобразование между типом object и типами указателей невозможно. В частности, для них не выполняется упаковка и распаковка. Однако допускаются преобразования между разными типами указателей, а так же указателями и целыми.
Основными операциями с указателями являются * и &. Обе эти операции являются унарными, т. е. имеют один операнд, перед которыми они ставятся. Операция & соответствует операции "взять адрес". Операция * соответствует словам "значение, расположенное по указанному адресу".