Введение

Версия описания 1.0. от 16.03.2013г.
В дальнейшем по мере дополнений и исправлений номер версии будет меняться.
Описание C# Sharp Develop выполнено Е.Е.Квасовым.
В качестве начального источника использованы материалы сайта
Шынгыса Кенесова.
Добавлены ряд справочных материалов по функциям и методам конвертирования данных. Приведены примеры.
С использованием модуля подсветки синтаксиса HightLight.gs улучшено отображение кода C# на всех страницах.
Дополнения и исправления:

• 24.03.2013 добавлен блок типов переменных в раздел "переменные".
• 26.03.2013 добавлен раздел классы. Дополнен раздел переменных сведениями об их видимости. В разделе Цикл For наряду с циклом For имеется цикл foreach. Эти дополнения взяты из публикации Анатолия Подгорецкого, с которым автор знаком заочно ещё во времена FIDO при обсуждении вопросов программирования.

Первый проект

Всё! Ну, неужели, наверно, думаете вы. Создадим наш первый проект, для этого кликните там, где я выделил красным:
Открывается диалоговое окно с выбором типа проекта, в курсе основ мы будем в основном писать только консольные программы:



Снизу есть такое поле, называется Name, назовите MyConsoleApplication.
Всё у нас открывается проект и изначальный шаблон кода, который VisualC# сгенерировал автоматически.
Попробую объяснить:
Здесь IDE подключает нужные пространства имен(о них еще будет статья)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
  //Дальше объявляется пространство имен MyConsoleApplication:
namespace MyConsoleApplication

//ВнутриMyConsoleApplication объявляетсякласс Program:
class Program
//А уже в этом классе объявляется статический метод Main
static void Main(string[] args)

  {

  }

Именно этот метод Main является «главной точкой входа» программы.
Поэтому все, что должна делать наша программа следует писать именню внутри этого метода.

Hello World

Смысл этой программы прост, вывести на консоль HelloWorld и ожидать пользовательского ввода. Я в прошлой статье писал, что логику программы мы будем писать внутри методаMain, по крайней мере до того пока не научимся создавать эти методы.
В пространстве имен System, которую среда подключила автоматически, есть класс Console, у которого есть методы для работы с консолью. Сейчас мы познакомимся с тремя:

1. WriteLine – пишет символы на новой строке.
   
2. Write – пишет символы на одной строке, при условии что в предыдущий раз не использовали WriteLine.
   
3. ReadKey – ожидает пользовательского ввода, после того как мы введем что-то, программа закрывается.
   

Нам нужно вывести HelloWorld, для этого нам нужно воспользоваться или WriteLine или Write, ну пусть будет WriteLine. Теперь как писать, внутри метода Mainнапишите:
Console.WriteLine("Hello World");
Что мы здесь делаем? Мы вызываем WriteLine и передаем ему параметр в скобках, этот параметр определяет что нужно вывести на консоль.
Теперь попробуем запустить программу, для этого нажмите F5.
Но программа запустилась и сразу завершила свою работу, потому что консольные программы выполняют действие строка за строкой и завершают свою работу, когда они пройдут по всем строкам.
Нам нужно сказать программе, что ему нужно подождать нашей команды, для этого после вывода Хелло Ворлд, мы должны ввести метод ReadKey:
Console.ReadKey();
Снова F5 и теперь программа работает и ожидает нашего ввода.
Поздравляю Вы написали свою первую программу!.

Переменные

Переменная – это ячейка в виртуальной памяти компьютера, которое имеет значение и идентифицируется названием. Ну, если вы не поняли это, то есть более легкое объяснение: переменная это ящик, в который что-то помещено, а у ящика есть название. Так как единого правила для переменных нет, то другие могут считать его и так: переменная это ссылка на данные, которые хранятся в памяти компьютера. Считайте переменную, как хотите, я буду придерживаться тому правилу, которую я сам придумал и дал вам в начале этого абзаца.
В языке сишарп есть строгий шаблон создания переменных, приведу его:
[модификаторы доступа] /тип переменной/ /название переменной/ [значение]
[] – необязательное
// - обязательное
Почему я «значение» оставил под «необязательно», потому что мы можем «проинициализировать» переменную и потом, например, строчкой ниже.
Ладно, давайте сначала познакомимся с типами переменных, вам надо, например, 4 переменные: в 1-ую вы запишите своё имя, во второй возраст, в 3-й вес, в четвертый, например, число ПИ = 3,14.
Так вот «Имя» будет иметь строковый тип переменных, возраст – «числовой», вес и пи – дробный тип.
Сишарп относится к строго типизированным языкам программирования, это означает, что тип переменных мы должны будем написать в обязательном порядке (согласно шаблону). Тогда это в нашем таком представлении будет иметь вид:

СТРОКА ИМЯ = «Чингиз» ЧИСЛО ВОЗРАСТ = 16 ДР. ЧИСЛО ВЕС = 65,15 ДР.ЧИСЛО ПИ = 3,14

Приведу таблицу типов.
Вы видите в поле «Пояснение» пункт «строка», двигайте влево и наткнетесь на string(Тип C#). Вот переменная в которую мы запишем строку/текст/букву/слово будет иметь тип string уже на языке сишарп. Еще также сразу под «Пояснение» стоит «Целое», вот для возраста/целых чисел подойдет тип int. Здесь почему-то нет типа double, в которую мы заносим числа с плавающей точкой, например вес/ПИ.
Теперь, то, что мы представили, давайте напишем уже на сишарп:

string name= "Чингиз"; int vozrast= 16; double ves= 65.15; double pi= 3.14;

Теперь можете их вывести:
Console.WriteLine(name);
Чтобы вывести своё слово, а потом переменную нужно просто между словом(в кавычках) и перенной поставить знак +:
Console.WriteLine(“Меня зовут ” + name);

4. Арифметические действия над переменными

Давайте объявим три переменные целого типа(int) a,b и c. В a и b мы занесем число, а в переменную с – результат действия.

int a = 5;
intb = 2;
Вот, теперь 1-е арифметическое действие «Сложение»:
int c = a+b;
В строке выше мы так и прибавляем две переменные, а потом заносим их в с.
Попробуем вывести на консоль:
Console.WriteLine(c);
Результат 7 и всё правильно.
Следующий вычитание:
int c = a-b;
Результат: 3.
Тоже очень легкий код.
Умножение:
int c = a * b;
Результат: 10
Деление:
int c = a/b;
Результат: 2.5, но так как это целый тип, то он может, округлен до 2-х или 3-х.
Теперь давайте проверим число на больше, меньше или равно.
Console.WriteLine(a >b);
В данном примере на консоль выведется true, потому что действительно а больше b.
Следущий:
Console.WriteLine(a < b);
На консоль выведется false, потому что b меньше а.
Console.WriteLine(a == b);
Обратите внимание на то что в сишарп проверка на равенство идет ==, а не =.
Результат будет false. Но если мы а присвоим 2, то True.
Аналогично и больше или равно и меньше или равно:
Console.WriteLine(a >= b); - Больше или равно. 
Console.WriteLine(a <= b); - Меньше или равно.

Обратите внимание, что знак равенства пишется после знака < или >.

Арифметические операции C# Sharp

Различают 5 операций, выполняющих арифметические действия над числами.

Операция	Назначение	Пример
+	Сложение	X = x + y
-	Вычитание	X = x - y
*	Умножение	Z =  x * y
/	Деление	Z =  x / y
%	Деление по модулю	Z =  x % y

Выполнение первых трёх операций очевидно и не требует пояснения. А вот операция деления зависит от типа данных. Если тип данных, участвующих в операции, вещественный, то результат получится по правилам деления с целой и дробной частью. Если тип целый, то результатом деления также является целое число.<br>

Деление по модулю возможно только для целых чисел. Оно обеспечивает получение остатка от деления двух целых чисел. Например, в результате операции 17 % 4 получится число 1, а в результате операции 17 / 4 - получится 4.  Таким образом, пара операций / и % обеспечивает для целых чисел специфическую возможность: можно получить и целую часть, и остаток от деления.

Арифметические операции можно объединять вместе с операцией присваивания, записывая две операции в виде одной. Это так называемая сокращённая форма записи.

Например:
обычная запись: a = a + Stoim;
сокращённая форма: a+=Stoim;

К арифметическим операциям относятся две специфические операции – инкремент и декремент. Эти операции позволяют изменять значения переменных на 1. Инкремент – увеличивает, обозначается знаком ++. Декремент – уменьшает, обозначается знаком --. По сути дела, эти операции являются сокращённой формой записи для выражений типа i = i +1 и i = i – 1. Например, вместо a = a + 1; можно записать: a++; (постфиксный вариант) или ++a; (префиксный вариант). Аналогично: --Prim; Prim--;
Между двумя последними формами нет никакой разницы, если эти операции являются единственными в записи выражения, т.е. используются самостоятельно. Если же речь идёт об использовании в сложном выражении, то приходится учитывать, когда на самом деле выполняются эти операции. Суть в том, что при постфиксном варианте записи значение переменной сначала используется, а потом изменяется на 1. При префиксном, наоборот, сначала изменяется, а потом используется.

Например:

t = 5;          // t = 5 
n = 4 * t++;    // n = 20, t = 6
k = ++n / 3;    // n = 7 , k =7 
b = --k / t;    // k =6 , b = 1

Арифметические функции C# Sharp

Имя	Описание	Результат	Пояснения
Abs	Модуль	Перегружен(существует несколько версий метода)	|x| записывается как Abs(х)
Acos	Арккосинус	double	Аcos(double х)
Аsin	Арксинус	double	Asin(double х)
Аtan	Арктангенс	double	Atan(double х)
Atan2	Арктангенс	double	Atan2(double х, double у) - угол, тангенс которого есть результат деления у на х
BigMul	Произведение	long	BigMul (int х, int у)
Ceiling	Округление до большегоцелого	double	Ceiling(double х)
Cos	Косинус	double	Cos (double х)
Cosh	Гиперболический косинус	double	Cosh (double х)
DivRem	Деление и остаток	Перегружен	DivRem(х, у, rem)
E	База натурального логарифма (число е)	double	2,71828182845905
Ехр	Экспонента	double	ех записывается как Ехр(х)
Floor	Округление до меньшегоцелого	double	Floor(double х)
IEEERemainder	Остаток от деления	double	IEEERemainder(double х, double у)
Log	Натуральный логарифм	double	logех записывается как Log(х)
Log10	Десятичный логарифм	double	log10 х записывается как Log10(х)
Мах	Максимум из двух чисел	Перегружен	Мах(х,у)
Min	Минимум из двух чисел	Перегружен	Min(х,у)
PI	Значение числа пи	double	3,14159265358979
Pow	Возведение в степень	double	ху записывается как Pow (x,y)
Round	Округление	Перегружен	Round (3.1) даст в результате 3, Round (3.8) даст в результате 4
Sign	Знак числа	int	Аргументы перегружены
Sin	Синус	double	Sin(double х)
Sinh	Гиперболический синус	double	Sinh(double х)
Sqrt	Квадратный корень	double	vх записывается как Sqrt(x)
Tan	Тангенс	double	Tan(double х)
Tanh	Гиперболический тангенс	double	Tanh(double х)

Пример использования:

Double d=Math.Sqrt(b*b-4*a*c);

Используется модуль Match.

Программа, иллюстрирующая возможности преобразования строка - число.

using System;

namespace inputconvert
{
    class Program
    {
        public static void Main(string[] args)
        {
            int a,b,c;
            float af,bf,cf;
            double ad,bd,cd;
            Console.WriteLine("Hello World!");
            Console.WriteLine("Вводим 2 целых числа");
            a= int.Parse(Console.ReadLine());
            b=int.Parse(Console.ReadLine());
            Console.WriteLine("a+b="+a+b);
            // TODO: Implement Functionality Here
            Console.WriteLine("Вводим 2 дробных числа типа float");
            af=Convert.ToSingle(Console.ReadLine());
            bf=Convert.ToSingle(Console.ReadLine());
            cf=af+bf;
            Console.WriteLine("cf="+cf);
            Console.WriteLine("Вводим 2 вещественных числа типа double");
            ad=double.Parse(Console.ReadLine());
            bd=double.Parse(Console.ReadLine());
            cd=ad+bd;
            Console.WriteLine("cd="+cd);
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    }
} 

Преобразование типов в языке Си Шарп

Язык Си шарп имеет отдельный класс, который вызывает методы,
для преобразование типов данный.
Этот класс называется: Convert Давайте
рассмотрим эти преобразование типов данных:
Преобразование в плавающей точкой в целое число:
int i = Convert.ToInt32(14.56); обратите внимание на то,
что округление идет к большему числу, т.е. получится 15!!!
Преобразование с целого числа в дробное или в число
с плавающей точкой:
double d = Convert.ToDouble(14)
Преобразование с числа в строку (число может быть любым:
дробным или целым):
string s = Convert.ToString(14.456);
Преобразование с целого числа в символ АСIII кода:
Интересно получается следующая запись:
char s = Convert.ToChar(76.8);
В данном случае ошибки синтаксической не будет, но при запуске
программа выведет исключение, что недопустимое приведение
double к char
Поэтому нужно писать целые числа.
Необходимо добавить ещё варианты преобразования от строки к числу.
dd=float.Parse(gg);
k=int.Parse("11111");
Здесь dd - переменная типа float, а k -int
В скобках строковая переменная и строковая константа.

Пример работы с переменной типа char;

Ряд задач решается проще, если обратить на аналогию переменной целого типа и переменной char; Аналогия заключается в том, что переменная типа char представлена номером в таблице кодов.

using System;

namespace massivproba
{
    class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            
            // TODO: Implement Functionality Here
        int[] a = new int['z']; //Здесь вместо 'z' я мог бы поставить 122 - номер символа.  
        for (int i = 'a'; i < 'z'; i++)
        {
            a[i] = i;
            Console.Write((char)a[i]);
        }
        Console.ReadKey(true);
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    }
}

5. Условный оператор

Распишу, как должна писаться конструкция:
1) Сначала идет ключевое слово if и скобки
2) Дальше в скобках пишется условие.
3) Дальше фигурные скобки, но их можно и не ставить, если нужно выполнить только одно действие.
Вот это уже считается конструкцией. Дальше в зависимости от целей можете писать блок else.
Полная конструкция будет выглядеть так:

if (условие) { ///Делаем что-то } else { ///Делаем что-то }

Bот и всё, ничего такого сложного здесь я не вижу. Вернемся, к примеру, про покупку модема. Попробуем написать эту ситуацию. Сначала объявим переменную, в которую мы занесем, сколько денег у нас есть.
int money = 4000;
Теперь цена модема:
int price = 4500;
И условие:
if (money > price)
{
Console.WriteLine("Мы купили модем");
}
else
{
Console.WriteLine("Купим потом");
}
Console.ReadKey();
Цепочки условий.
Конечно, вы можете добавлять туда еще и несколько таких конструкции, но они будут работать по отдельности. Чтобы несколько условий работало вместе нужно записать главное условие, потом второе условие писать уже так:
else if ()
Дополним предыдущий код:

if (money > price) { Console.WriteLine("Мы купили модем"); } else if (money == price) { Console.WriteLine("Денег хватило, но не осталось"); } else { Console.WriteLine("Купим потом"); }

В самом начале этого урока я писал, что фигурные скобки необязательно ставить, если у нас под условием делается только одно действие, а это значит, что наш код мы можем упростить вот так:

if (money > price) Console.WriteLine("Мы купили модем"); else if (money == price) Console.WriteLine("Денег хватило, но не осталось"); else Console.WriteLine("Купим потом");

Если не понятно, поиграйтесь со значениями переменных и надеюсь, всё станет понятно.

6. Конструкция switch-case

Распишу, как пишется конструкция switch-case:
1) Ключевое слово switch и скобки.
2) В скобках название рассматриваемой (проверяемой) переменной и фигурные скобки.
3) В фигурных скобках case и вариант условия, двоеточие и что нужно делать, точка с запятой ключевое слово break и точка с запятой.
Получается так:
switch (переменная)
{
case значение: делаем что-то; break;
case значение: делаем что-то; break;
}
Зачем нужно ключевое слово break? Для того чтобы после проверки программа выходила из конструкции, иначе он будет выполнять код строка за строкой.
Рассмотрим пример: Давайте просто объявим переменную:
int a = 4;
Теперь сама конструкция:
switch (a)
{
case 0: Console.WriteLine("0"); break;
case 1: Console.WriteLine("1"); break;
}
Еще одна фича….
В эту конструкцию можно добавлять одну строку кода, который будет выполнять тогда, когда нет правильных вариантов case, его пишут так:
default: Console.WriteLine("Нет правильных вариантов"); break;
Попробуем модифицировать наш предыдущий код, добавив эту строку, вот полный код:
int a = 4;
switch (a)
{
case 0: Console.WriteLine("0"); break;
case 1: Console.WriteLine("1"); break;
default: Console.WriteLine("123456"); break;
}
Console.ReadKey();

7. Циклы while и do-while

Приведу простой жизненный пример, вы вступаете на беговую дорожку (на стадионе) и вам нужно пробежать 5 кругов. После первого круга вы говорите себе, что один круг вы пробежали надо еще 4, после 2 круга пробежали 2 круга, надо пробежать 3, и так до того момента пока вы не пробежите 5 кругов. Циклы поступают точно также, вы говорите циклу сколько раз нужно выполнить что-то и она выполнить это.
Циклов существует 4 - while, do-while, for и foreach. Про foreach потом отдельный разговор после массивов. Синтаксис цикла while:
1)Ключевое слово while, скобки.
2)В скобках условие, фигурные скобки
3)А в фигурных скобках действие.
Давайте выведем числа от 0 до 9.
Сначала мы должны объявить переменную, который будет «счетчиком», обычно она называется i и имеет целочисленный тип.

int i = 0;

Теперь сам цикл:

while(i<10)

{

Console.WriteLine(i);

i = i + 1;

}

Зачем мы i увеличиваем на 1, да потому что он счетчик. Тот же пример на беговой дорожке, если вы не будете отсчитывать, сколько кругов пробежали, то вы будете бегать вечно.
Теперь иногда в примерах вам будет попадаться такая запись i++ вместо i = i + 1. Здесь ничего страшного нет, она эквивалентна и моей записи, просто программисты ленивые и придумывают как можно легче сделать. Эта операция называется «инкрементом», т.е. увеличение значения переменной на 1, но если вы хотите постоянно увеличивать, к примеру, на 2 то вам придется воспользоваться моей записью.
Обратная инкременту «декремент» пишется i--.

8. Цикл Do-While

Этот цикл так же прост, как и прошлый, главное отличие наличие ключевого слова do. Рассмотрим прошлый пример, только с циклом Do-While:

do{

Console.WriteLine(i);

i = i + 1;

} while(i<10);

Думаю объяснять здесь нечего.

Бесконечный цикл

Если вы хотите чтобы цикл работал вечно или до того момента пока вы сами не завершите работу в круглых скобках вместо условия должны написать слово true.

Циклы for и foreach

Начнем сразу с примера цикла for:

{
int k = Int32.Parse(Console.ReadLine());
int sum=0;
for(int i=1; i<=k; i++){
    sum+=i;
}
Console.WriteLine(sum);

Этот пример подсчитывает сумму чисел от 1 до введенного пользователем числа k. Сумма записывается в переменную sum и выводится на экран. Очень часто циклы используются для некоторых действий с массивами. Так как нумерация элементов массива идет с нуля, то типичный цикл будет выглядеть так:

{
int[] a = {-5, 4, 55};
int sum=0;
for(int i=0; i<3; i++){
    sum+=a[i];
}

В этом примере начальное значение для счетчика цикла равно нулю, и в условии продолжения цикла мы пишем знак "меньше", после которого ставится количество элементов в массиве. Разумеется, если в цикле должен выполнится только один оператор, то фигурные скобки можно не писать. Тут все, как в других C/C++-подобных языках. Теперь рассмотрим пример цикла foreach:

{
int[] m = {-5, 4, 10};
int sum=0;
foreach(int i in m){
    sum+=i;
}

В данном примере мы суммируем все элементы массива m, записывая сумму в sum. В приведенном примере наш цикл перебирает все элементы массива m. На это нам указывает строка

foreach(int i in m){

которая интерпретируется так: для каждого целого числа из массива m делам что-то там. Если бы элементами массива были бы не целые, а, скажем, вещественные, то мы записали бы что-то вроде:

...
foreach(float i in m){
...

Т. е. мы пишем именно тип элементов массива. На самом деле foreach используется не только для массивов, но и для других объектов.

Массивы в C#

Массивы в C# несколько отличаются от других C-подобных языков. Начнем сразу с примеров. Пример первый:

int[] k; //k - массив
k=new int [3]; //Определяем массив из 3-х целых
k[0]=-5; k[1]=4; k[2]=55; //Задаем элементы массива
  //Выводим третий элемент массива
Console.WriteLine(k[2].ToString());

Смысл приведенного фрагмента ясен из комментариев. Обратите внимание на некоторые особенности. Во-первых, массив определяется именно как
int[] k;
а не как один из следующих вариантов:

int k[]; //Неверно!
int k[3]; //Неверно!
int[3] k; //Неверно!

Во-вторых, так как массив представляет из себя ссылочный объект, то для создания массива необходима строка
k=new int [3];
Именно в ней мы и определяем размер массива. Хотя, вообще говоря, возможны конструкции вида
int[] k = new int [3];
Элементы массива можно задавать сразу при объявлении. Вот пример:
int[] k = {-5, 4, 55};
Разумеется, приведенные конструкции применимы не только к типу int и не только к массиву размера 3. В C#, как и в C/C++, нумерация элементов массива идет с нуля. Таким образом в нашем примере начальный элемент массива - это k[0], а последний - k[2]. Элемента k[3], разумеется, нет. Теперь переходим к многомерным массивам. Вот так задается двумерный массив:
int[,] k = new int [2,3];
Обратите внимание, что пара квадратных скобок только одна. Естественно, что в нашем примере у массива 6 (=2*3) элементов (k[0,0] - первый, k[1,2] - последний). Аналогично мы можем задавать многомерные массивы. Вот пример трехмерного массива:
int[,,] k = new int [10,10,10];
А вот так можно сразу инициализировать многомерные массивы:
int[,] k = {{2,-2},{3,-22},{0,4}};
Приведенные выше примеры многомерных массивов называются прямоугольными. Если их представить в виде таблицы (в двумерном случае), то массив будет представлять из себя прямоугольник. Наряду с прямоугольными массивами существуют так называемые ступенчатые. Вот пример: //Объявляем 2-мерный ступенчатый массив
int[][] k = new int [2][];
//Объявляем 0-й элемент нашего ступенчатого массива
//Это опять массив и в нем 3 элемента
k[0]=new int[3];
//Объявляем 1-й элемент нашего ступенчатого массива
//Это опять массив и в нем 4 элемента
k[1]=new int[4];
k[1][3]=22; //записываем 22 в последний элемент массива
... Обратите внимание, что у ступенчатых массивов мы задаем несколько пар квадратных скобок (столько, сколько размерность у массива). И точно так же мы что-нибудь делаем с элементами массива - записываем, читаем и т. п. Самая важная и интересная возможность у ступенчатых массивов - это их "не прямоугольность". Так, в приведенном выше примере в первой "строке" массива k три целых числа

10. Многомерные массивы

string[,] names = { {"Chingiz", "Kenesov"}, {"Zufar", "Dawydov"} };
Обязательным должна быть запятая в кадратных скобках или можете поставить числа между ним(запятым), в фигурных скобках мы определяем элементы, но в них есть еще фигурные скобки, это говорит о том что там будет еще один массив. Перечисление массивов идет через запятую как и в обычном массиве. И наконец значения в этих массивах. В них я записал свою имя и фамилия, а во втором массиве – друга.

Вывод из массива
При выводе значения из такого массива мы в квадратных скобках сначала указываем индекс массива, ставим запятую и индекс элемента уже из этого массива. Пример:

Console.WriteLine(names[0,1]);

Выведет нам «Kenesov».

11. Вывод маркерами

Нам нужно вывести 5 переменных со словами, причем они идут не порядку, сначала переменные потом слова, а нужно их как-то связать. Смотрите пример, то что я выделил жирным это переменная:
«Меня зовут Чингиз, и я начинаю изучать язык C#, учусь в школе Комарова в 11 классе».
Вот я создаю переменные:

string name = "Чингиз";

string csharp = "C#";

string school = "Комарова";

int klass = 11;

Как вы выведите это дело, так?:

Console.WriteLine("Меня зовут"+name+",и я начинаю изучать язык"+csharp+",учусь +

в школе"+school+"в"+klass+"классе");

Это дело можно вывести и по-другому, не знаю как они называются лично я называю способ вывода маркерами. В чем суть? В методе вы пишите все, что нужно вывести, за исключением переменных, а в местах, куда надо подставить переменные оставляете маркер. Маркеры пишутся так {0},{1},{2},….{n}, а после того как вы всё поставили, вы после кавычек прямо в методе ставите запятую и перечисляете какие переменные нужно подставлять вместо маркеров. Приведу пример:

Console.WriteLine("Меня зовут {0}, и я начинаю изучать язык {1}, учусь в школе {2} в {3} классе",name,csharp,school,klass);

Важно заметить что маркеров может быть больше, чем переменных, например:

Console.WriteLine("Меня зовут {0}, и я начинаю изучать язык {1}, учусь в школе {2} в {3}+ классе,я напоминаю что меня зовут {0}, и что я учу язык {1}", name, csharp, school,klass);

Это мы будем еще использовать при на выводе не только на консоль, но в компоненты, например, текстовое поле.

12. Разбор массива циклами

Но что если у вас в массиве элементов очень много или что еще хуже вы не знаете сколько там элементов, напишите столько кода ради того чтобы вывести эти значения? Для этого мы и научимся разбирать массив. Разбирать или перебирать массив мы можем циклами for, foreach и while.Ну я покажу, как перебирать в for и foreach, а в while это делается аналогично for.
Перебираем массив 1.Цикл for
В этом цикле у нас счетчик постоянно увеличивается на 1 согласно инкременту, так что нам мешает просто подставить вместо индекса название счетчика? Вы, наверно, скажете «а что с условием?», с условием всё просто. Дело в том, что каждый объект массива имеет свойство Length – это свойство возвращает длину массива в численной форме. Например, если у нас в массиве содержится 3 элемента, Length вернет нам 3, также и с другими. Смотрим пример, в котором я объявил массив, и циклом for разбираю его:
string[] mas1 = { "Chingiz","Kenesov","Zufar","Dawydov" };
for (int i = 0; i < mas1.Length; i++)
{
Console.WriteLine(mas1[i]);
}
Console.ReadKey();
Покажу способ разбора массива циклом while:
string[] mas1 = { "Chingiz","Kenesov","Zufar","Dawydov" };
int i = 0; while (i < mas1.Length)
{
Console.WriteLine(mas1[i]);
i++;
}
Console.ReadKey();
Важно заметить, что разбор массива циклом while, почти не используется, поэтому сразу перейдем к следующему циклу.
2.Цикл foreach
Цикл foreach немного сложен для новичка, но постараюсь объяснить всё легко. Покажу пример, а потом объясню:
string[] mas1 = { "Chingiz","Kenesov","Zufar","Dawydov" };
foreach (string item in mas1)
{
Console.WriteLine(item);
}
В скобках этого цикла мы создаем переменную я назвал item, важно заметить что тип этой переменной должен соответствовать типу массива(если массив int, то и переменная int), у меня массив имеет тип string, поэтому тип моей переменной тоже string. Дальше ключевое слово in и название массива, которую мы разбираем. А дальше выводим на консоль уже item.
В чем суть цикла? Как работает цикл? Да всё просто переменная (в данном случае item) «заходит» в массив и присваивает себе первый элемент, дальше он идет в саму конструкцию и делает инструкции (я написал, что его нужно вывести). После того как сделает все инструкции цикл опустошает его значение и переменная присваивает себе уже второй элемент массива. И так продолжается до того момента пока в массиве не останется элементов которых он себе не присваивал.

13. Считывание данных консолью и класс Convert

Для этого существует методы: ReadLine и Read, которые есть в классе Console.
Чтобы считать нужно просто ввести ReadLine и результат записать в переменную. Покажу пример:

1. Console.WriteLine("Привет, введите ваше имя: ");
2. string name = Console.ReadLine();
3. Console.WriteLine("Вас зовут: " + name);
4. Console.ReadKey();

Обратите внимание на 2-ую строчку кода, там мы объявляем переменную текстового типа и в него записываем то, что мы ввели на консоль. А в 3-ей строчке уже выводим эту переменную.
Класс Convert
Попробуйте таким способом в переменную числового типа записать данные с консоли, примерно вот так:

1. int name = Console.ReadLine();

Не получается? Да так и должно быть, среда должна выявить ошибку в коде, ну ладно объясню почему так и причем здесь класс Convert. Дело в том, что метод ReadLine предполагает, что вы вводите какой-то текст. А записывать в числовой тип текст мы не можем. Теперь немного про класс Convert. Этот класс конвертирует переменную из одного типа в другую. Тогда мы можем считать данные с консоли, конвертировать тип этих данных и записать уже в другую переменную, который имеет тип данных отличной текстовой, ну например это может быть как раз таки числовой тип. Давайте попробуем это реализовать, внимательно изучите код:

1. Console.WriteLine("Введите ваш возраст: ");
2. int voz = Convert.ToInt32(Console.ReadLine());

Если вы хотите узнать все методы класса Convert, просто введите его поставьте точку и среда сама покажет вам все его методы.
Итого весь код получился таким:

1. Console.WriteLine("Привет, введите ваше имя: ");
2. string name = Console.ReadLine();
3. Console.WriteLine("Введите ваш возраст: ");
4. int voz = Convert.ToInt32(Console.ReadLine());
5. Console.WriteLine("Вас зовут {0} а ваш возраст {1}", name, voz);
6. Console.ReadKey();

Если вы не понятно что это за фигурные кавычки при выводе в номером, рекомендую прочитать этот урок про вывод на консоль маркерами.

14. Константы

Причем нельзя объявлять массивы с константой. Ладно достаточно слов, перейдем к коду:

1. const string url = "csharp.kz";
2. Console.WriteLine(url);
3. Console.ReadKey();

А отличия объявлений констант только в том что перед типом вы пишите ключевое слово const.
А если написать так:

1. const string url = "csharp.kz";
2. url = "dirlo.in";
3. Console.WriteLine(url);

Во второй строчке среда выявит ошибку, так как значение константы нельзя переопределять.
Где это применять?
Например, в математических расчетах значения числа пи, или физика - гравитационная постоянная

Введение в классы в C#

Начиная с этого урока, приступаем к изучению классов. Сначала пару слов о том, что такое классы. Представьте себе, что у вас есть некоторый объект, который характеризуется рядом свойств. Например, работник на некой фирме. У него есть такие свойства, как фамилия, возраст, стаж и т. п. Так вот, в этом случае удобно каждого работника описывать не рядом независимых переменных (строкового типа для фамилии, целого типа для возраста и стажа), а одной переменной типа Worker, внутри которой и содержаться переменные для фамилии, возраста и стажа. Это здесь самое важное - что в переменной типа Worker содержаться другие переменные. Конечно, типа Worker среди встроенных типов данных нет - ну так эта не беда - мы можем ввести его. Еще одна важная вещь про классы - это то, что в классах помимо переменных разных типов содержатся функции (или, что тоже самое, методы) для работы с этими переменными. Скажем, в нашем примере с классом Worker логично ввести специальные функции для записи возраста и стажа. Функции будут, в частности, проверять правильность вводимой информации. Например, ясно, что возраст у работника не может быть отрицательным или большим 150 ;). Так вот наша функция и будет проверять правильность введенного пользователем возраста. Давайте рассмотрим первый пример класса. Создайте новое консольное приложение для C# и введите следующий текст:

using System;
namespace test
{
    //Начало класса
    class Worker
    {
        public int age=0;
        public string name; 
    }
    //Конец класса

    class Test
    {
        [STAThread]
        static void Main(string[] args)
        {
            Worker wrk1 = new Worker();
            wrk1.age=34;
            wrk1.name="Иванов";
            Console.WriteLine(wrk1.name+", "+wrk1.age);
        }
    }
}

Запустите программу. Она, как и следовало ожидать, выведет на экран "Иванов, 34". Давайте кратко обсудим наш код. Во-первых, в строчках

    class Worker
    {
        public int age=0;
        public string name; 
    }

мы определили наш класс Worker. Внутри этого класса существует две переменные - целая age для возраста и name строкового типа для имени. Обратите внимание, что, в отличие от C/C++, мы можем задавать некоторое начальное значение прямо сразу после объявления переменной: ... public int age=0; ... Начальное значение задавать вовсе не обязательно - это видно по переменной name. Перед переменными мы пишем ключевое слово public. Значение у него такое же, как и в C++ - а именно это означает, что эта переменная (или функция) будет видна вне класса. Если мы не напишем перед переменной никакого модификатора доступа, или напишем private, то переменная не будет видна снаружи класса и ее смогут использовать только функции этого же класса (т. е. она будет для "внутреннего использования"). Далее в строчке ... Worker wrk1 = new Worker(); ... мы заводим экземпляр класса в куче (heap) и возвращаем на него ссылку. Затем в строчках

  wrk1.age=34;
  wrk1.name="Иванов";
  Console.WriteLine(wrk1.name+", "+wrk1.age);
  

мы используем наш класс. А именно присваиваем некоторые значения для возраста и имени и выводим их потом на экран. С этим уроком все.

Конструкторы классов

Для начала кратко обсудим, что такое конструктор вообще. Конструктор - это функция (метод) класса. Раз эта функция, то описываем мы ее почти точно так же, как и любую другую функцию класса - пишем параметры в круглых скобках и т. п. Когда конструктор вызывается? В момент создания переменной. При этом у класса может быть несколько конструкторов - но при этом они должны различаться или типом параметров, или их количеством. Этот урок будет основан на предыдущем. Откройте проект, созданный на прошлом уроке. Давайте добавим в наш класс Worker конструктор:

    class Worker
    {
        public int age=3;
        public string name;
        //Конструктор 1
        public Worker(int age, string name)
        {
            this.age=age;
            this.name=name;
        }
    }

Обратите внимание на ряд особенностей конструктора. Во-первых, конструктор называется как класс. Раз наш класс называется Worker, значит и конструктор должен называться точно также. И во-вторых, конструктор, в отличие от других методов класса, не возвращает никакого значения (даже типа void). Если вы знакомы с языком C++, то, несомненно, это вам все знакомо. Что делает наш конструктор? Он записывает передаваемые в него параметры во внутренние переменные класса. Обратите внимание, что называются они одинаково - age и age, name и name. Компилятор сначала ищет локальную переменную с таким именем, и, если не находит, то переменную класса. Поэтому age (и name) - это передаваемый в конструктор параметр. Если же нам надо сослаться на переменную класса (при существовании переменной с таким же именем, как и передаваемый в функцию параметр), то мы используем ключевое слово this. Оно всегда указывает на текущий экземпляр нашего класса. Таким образом в строчках

  this.age=age;
  this.name=name;

мы передаем параметры конструктора в переменные класса. Теперь изменим тестовый класс test следующим образом:

  static void Main(string[] args)
  {
    //Вызываем конструктор
    Worker wrk1 = new Worker(40, "Вася");
    Console.WriteLine(wrk1.name+", "+wrk1.age);
  }

Теперь после объявления переменной мы вызываем конструктор с двумя параметрами, который запишет в переменные age и name экземпляра класса Worker значения 40 и "Вася". Строчкой ниже эти значения выводятся на экран.

Наследование

Представьте себе, что у нас есть некоторый класс (быть может весьма большой), который почти подходит для нашей конкретной задачи. Почти, но не совсем. Что-то (некоторые методы) в этом классе надо изменить, что-то - добавить. Наследование как раз и служит для этого. При наследовании мы объявляем наш класс потомком другого класса. И наш класс-потомок (или, как его еще называют, дочерний класс) автоматически приобретает всё, что было в родительском классе. Это мы делаем буквально парой строчек. Затем в дочерний класс мы можем что-нибудь добавить (чего не было в классе родительском). Кроме того, в дочернем классе мы можем что-нибудь из родительского класса переопределить - так что оно уже будет работать по-другому. Давайте рассмотрим это все на примере. У нас будет класс Worker и производный от него класс Boss. Класс Boss будет отличаться от класса Worker во-первых, наличием переменной numOfWorkers (для количества подчиненных) и, во вторых, метод для задания возраста (setAge) будет работать в Boss не так:

using System;
namespace test
{
    //Класс Worker
    class Worker
    {
        protected int age=0;
        public void setAge(int age)
        {
            if(age>0 && age<100)
                this.age=age;
            else
                this.age=0;
        }
        public int getAge()
        {
            return age;
        }
    }
    //Класс Boss
    class Boss : Worker{
        public int numOfWorkers; //Количество подчиненных
        public new void setAge(int age)
        {
            if(age>0 && age<45)
                this.age=age;
            else
                this.age=0;
        }
    }
    class Test
    {
        static void Main(string[] args)
        {
            Worker wrk1 = new Worker();
            Boss boss = new Boss();
            wrk1.setAge(50);
            boss.setAge(50);
            boss.numOfWorkers=4;
            Console.WriteLine("Возраст работника "+wrk1.getAge());
            Console.WriteLine("Возраст босса "+boss.getAge()+
".\nКоличество подчиненных "+boss.numOfWorkers);
        }
    }
}

Обратите внимание, как мы вводим новый класс Boss: ... class Boss : Worker{ ... Такая запись и означает, что новый класс Boss будет потомком другого класса (Worker в данном случае). Так как наш класс - потомок другого класса, то он автоматически умеет все тоже самое, что и родительский класс. В частности, в нем есть переменная age для хранения возраста. Далее, в класс Boss мы вводим переменную numOfWorkers для хранения количество подчиненных у нашего босса. В родительском классе такой переменной не было. Кроме того, нас не устроила реализация метода setAge из родительского класса Worker (по каким-то там внутренним инструкциям фирмы возраст босса не может превышать 45 лет, тогда как возраст работника не может превышать 100), поэтому мы просто написали в классе Boss метод с таким же именем. Обратите внимание на слово new при объявлении метода: ... public new void setAge(int age) ... Таким образом мы в производном классе можем что-нибудь добавлять и что-нибудь изменять по отношению к классу родительскому. Обратите внимание, что убирать что-нибудь, полученное в наследство от родительского класса, мы не можем. При запуске наша программа даст вполне ожидаемый результат - в возраст работника запишется