Рынок аккаунтов, продажа аккаунтов Samp, Steam, cleo

Учим C#: №10

Twit — Sun, 17 Mar 2013 08:43:57 GMT

Атрибуты. Красивое слово, не так ли? Что такое атрибуты в C#? Они позволяют добавлять в код описательную информацию, которая может определять действия периода компиляции, периода выполнения, или даже ограничение/предоставление некоторых возможностей какого-либо члена в период выполнения. Атрибуты могут определять информацию, относящуюся к классу, структуре, методу и другим синтаксически-концептуальным элементам. Указываются перед элементом в квадратных скобках, вот таким образом:

using System.Runtime.InteropServices;
..............
..............
[DllImport("user32.dll")]
static extern int MessageBoxA(int hWnd,string msg,string caption,int type);

Так импортируются функции из динамических библиотек, хотя в некоторых книгах, это называется экспортированием. К чему бы это? Этот атрибут, по своей концепции, определяет действия периода выполнения. А сам он определен в пространстве имен System.Runtime.InteropServices.
Можно использовать встроенные атрибуты C#, можно создавать новые. Любой атрибут – это класс, наследованный от класса System.Attribute. Теперь давайте создадим реальный конкретный атрибут, который будет определять, например, адрес URL:

using System;
using Sc=System.Console;

public class URLAttribute:Attribute
{
public URLAttribute(string url)
{
this.URL=url;
}

protected string uRL;

public string URL
{
get{return uRL;}
set{uRL=value;}
}

}

[URLAttribute("www.xakep.ru")]
class HackerLink
{

}

class Application
{
public static void Main()
{
Type type=typeof(HackerLink);
foreach(Attribute attr in type.GetCustomAttributes(false))
{
URLAttribute urlAttr=attr as URLAttribute;
if(null!=urlAttr)
{
Sc.WriteLine("Target Link Is "+urlAttr.URL);
}
}
Sc.ReadLine();
}
}

Из чего же состоит сам атрибут?
1) Защищенная строковая переменная URL, хранящая сам адрес;
2) Свойство URL, управляющее и контактирующее со строковой переменной;
3) Конструктор, устанавливающий адрес, заданный в аргументе.

Далее мы прикрепили созданный атрибут к классу HackerLink, задали ссылку на наш любимый сайтец. Теперь давайте рассмотрим метод Main(). Здесь используется отражение (Reflection). Отражение позволяет динамически определять сведения и данные о типах в проге. В первой строке мы создаем объект типа Type, определяющий тип объекта, при этом используем оператор typeof, который в данном контексте присваивает переменной type значение HackerLink. После этого объект находится в нашем распоряжении. Далее просматриваем все атрибуты, и если какой-то из них удается привести к URLAttribute, то выводим на экран строку с линком. Че-то тут новенькое кажись... А! Оператор as... Так вот...

Оператор as производит попытку приведения типов данных. Попытка может быть как успешной, так и безуспешной. В этой проге продемонстрирована работа с атрибутами класса. Существуют и другие разновидности атрибутов. Рассмотрим основные встроенные атрибуты C#. Атрибут Obsolete служит для того, чтобы отметить фрагмент кода, например метод, как устаревший. Имеет один параметр – строка сообщения, которое выведется при компиляции. Атрибут Transactionable определяет способность метода участвовать в транзакциях. Атрибут Conditional служит для создания условных методов, т.е. методов которые выполняются только тогда, когда параметр атрибута является символьной константой, определенной директивой #define. Это довольно так и интересный атрибут, так что рассмотрим следующий листинг.

#define FINAL

using Sc=System.Console;

class Test
{
[Conditional (“TRIAL”)]
public void Remind()
{
Sc.WriteLine(“Please don’t forget to register your version of ... ” );
Sc.ReadLine();
Sc.WriteLine(“Press Enter if u’re sure that u’ll not forget!!!”);
Sc.ReadLine();
}
[Conditional (“FINAL”)]
public void Hello()
{
Sc.WriteLine(“Hi! Registered user!”);
Sc.WriteLine(“Thank u very much for using this nice prog!”);
Sc.ReadLine();
}
}

Как все догадались, первый метод не будет работать, даже если к нему обратиться, а вот если обратится ко второму, то он даже нас поблагодарит еще. Этот прием вполне подходит для создания различия между шарой и зарегистрированной прогой, хотя само по себе это мало чем поможет.
В следующей статье будет рассмотрена обработка исключительных ситуаций, а потом уже будем автоматизировать IE, покрутим баннеры... Просто покажу, как это можно делать на С#.

Учим C#: №9

Twit — Sun, 17 Mar 2013 08:43:37 GMT

Каждый наш учебный листинг начинается с using, т.е. определения видимых пространств имен. Можем ли мы создавать свои пространства имен? Почему бы и нет? Давайте копнем, как этот механизм устроен... Для создания используется ключевое слово namespace. Внутри него могут содержаться классы, структуры и т.д. И все они будут видимы в своем пространстве имен. Чтобы не писать много раз название пространства имен, мы пользуемся директивой using. Как и весь C#, это предельно просто:)

namespace Units
{
class CPU
{
public char ID;
public int freq;
public int CACHE;
}
}

class Application
{
public static void Main()
{
Units.CPU object1=new Units.CPU();
object1.ID='A';
object1.freq=1700;
object1.CACHE=256;
System.Console.WriteLine("Made by "+object1.ID);
System.Console.WriteLine("Frequence is"+object1.freq+"Mhz");
System.Console.WriteLine("CACHE has "+object1.CACHE+"Kb");
System.Console.ReadLine();
}
}

Класс CPU виден в пространстве имен Units, и для создания объекта приходится набирать:

Units.CPU object1=new Units.CPU();

От этого мы можем избавиться при помощи директивы using, в начале исходника пишем:

using Units;

и можем смело создавать объект так:

CPU object1=new CPU();

Директиву using можно использовать и с другой целью – создание псевдоимен. Во многих листингах вы видели:

using Sc=System.Console;

Здесь Sc – псевдоимя, под которым видно пространство имен System.Console. В таком контексте справа от знака ‘=’ может быть пространство имен или класс. Все, typedef нам ни к чему. Хотя когда-нибудь, как-нибудь, где-нибудь да пригодится, забывать не стоит.

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

Вот общий формат объявления делегата:

delegate тип имя(список_аргументов);

Затем следует создать объект делегата, следующим образом:

имяДелегата имяОбъекта = new имяДелегата (имяМетода);

А вот теперь действительно интересное -> делегат может содержать как одну, так и несколько ссылок на разные методы. И реализуется это очень просто – операторы ‘+=’ и ‘-=’. Их формат:

имяОбъектаДелегата +=имяДобавочногоДелегата;
имяОбъектаДелегата -=имяУдаляемогоДелегата;

Так создаются многоадресные делегаты. Нужен ли пример? Ну давайте сварганим.

using Sc=System.Console;

delegate void IO();//объявляем делегат

class Matrix// класс матрицы
{
private int[,] element=new int[4,4];

public int GetValue(int ii,int jj)
{return element[ii,jj];}

public void Scan()
{
int i,j,ii;
for(i=0;i<4;i++)
{
string str1;
ii=i+1;
Sc.WriteLine("Enter string #"+ii);
for(j=0;j<4;j++)
{
Sc.Write("Enter value for element["+i+","+j+"](then press

Enter)=>");
str1=Sc.ReadLine();
element[i,j]=int.Parse(str1);
}
Sc.WriteLine();
}
}

public void Print()//вывод всей матрицы
{
int i,j;//переменные для циклов
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(i,j));
}
Sc.WriteLine();
}Sc.ReadLine();
}
}

class Application
{
public static void Main()
{
//создаем объект класса
Matrix matrix1=new Matrix();
//создаем объекты делегатов
IO Io=new IO(matrix1.Scan);
IO Out=new IO(matrix1.Print);
//добавляем новый метод
//к последовательности ссылок
Io+=Out;
//вызываем делегат
Io();
}
}

Следует обратить внимание на то, что для добавления метода к исполняемой цепочке делегата необходимо создать новый делегат, содержащий ссылку на этот метод, а затем прибавить новый делегат к старому. Для удаления делегата из цепочки его надо просто вычесть. Просто, не так ли? Делегаты позволяют выбирать метод на этапе выполнения программы в зависимости от той или иной ситуации. На основе делегатов создаются события и устанавливаются обработчики событий. Что же такое событие? Его можно рассмотреть, как сигнал о каком-либо действии, изменении... Ну а эти события созданы для того чтобы их обрабатывать. Обработкой событий занимаются специальные методы – обработчики. Как было сказано ранее, делегаты могут быть многоадресными, а значит и одно событие может иметь несколько обработчиков. Но как же с ними работать? C# предусматривает ключевое слово event для определения событий. Обычно события определяются как открытые члены класса. Давайте разберемся, как использовать этот механизм на примере простенькой проги. Создадим класс Number, главным членом которого будет являться целочисленная переменная, которая не может быть равна нулю. И если пользователь вводит 0, то происходит событие ввода нуля, которое нам надо, типа, обработать. А обработаем мы его так – просто выведем сообщение об ошибке. Итак, вникнем в код...

using Sc=System.Console;

delegate void Handle();//это делегат для нашего события

class Number
{
private int num;

private bool Verify(int n)//проверка на 0
{
if(n!=0) return true;
else return false;
}

public Number(){num=1;}

public Number(int n)
{if(n!=0) num=n;}

public event Handle isZero;//а это и есть событие

public void ZeroMsg()//сообщение 1
{Sc.WriteLine("0 can't be a number!");}

public void ErrorMsg()//сообщение 2
{
Sc.WriteLine("Critical Error!");
Sc.WriteLine("The program will be shut down!");
Sc.ReadLine();
}

public void Input()//ввод значения
{
string str;
bool v;
int n;

Sc.Write("Enter number:");
str=Sc.ReadLine();
n=int.Parse(str);
v=Verify(n);
//если 0, то “запускаем” событие
if(v==false) isZero();
//иначе все нормально
else
{
num=n;
Sc.WriteLine("This one is OK!");
Sc.ReadLine();
}
}
}

class Application
{
public static void Main()
{
Number ob=new Number();
//добавляем новые обработчики
ob.isZero+=new Handle(ob.ZeroMsg);
ob.isZero+=new Handle(ob.ErrorMsg);

ob.Input();
}
}

В принципе, событие – это объект делегата. Физически этот объект делегата содержит ссылки на обработчики события. События, обрабатываемые более чем одним обработчиком, называются широковещательными. Для их поддержки рекомендуется определять делегат с пустым (void) типом возвращаемого значения. События и их обработка открывают новые горизонты во многих сферах ИТ, эти знания нам отлично помогут в написании “автоматизаторов” приложений.

Учим C#: №8

Twit — Sun, 17 Mar 2013 08:43:00 GMT

Классы в C# могут содержать и такие элементы, как свойства. Эти члены являются очень важными и довольно часто используются. По сути, свойства - это данные, отображающие какие-либо особенности, опции, а лучше их смысл понимать дословно. Если вы хотите стать программистом .Net, вы обязаны знать этот механизм и владеть им в совершенстве. Но и тут не надо иметь семи пядей во лбу, как всегда, все очень просто. Свойство - это динамическое поле, для которого определены методы доступа, обычно они объявляются с модификатором доступа public, т.е. открытыми, т.к. обычно свойства изменяются вне объекта. Свойства целесообразно использовать вместо обычных переменных там, где, в соответствии со значением переменной, должны изменять свое значение и другие члены класса. Т.е., благодаря свойствам, нам не придется переписывать код изменения заново, или, что еще хуже, повторно вызывать конструкторы. Внешне синтаксис свойств похож на синтаксис индексаторов. Используются методы доступа с такими же именами, точно так же без аргументов. Общий вид:

public тип имя
{
get
{возврат_значения;}
set
{проверка;
установка_значения;
обновление_других_членов;
}
}

И, наконец, маленький примерчик рационального использования свойств. Определим свойство IsBoxed логического типа для класса, описывающего проц.

using Sc=System.Console;

class CPU
{
private string name;
private int freq;
private bool isboxed;
private bool needcooler;

public CPU(string n,int f)
{
name=n;
freq=f;
}

public bool IsBoxed
{
get{return isboxed;}
set
{
isboxed=value;
if(value==true) needcooler=false;
else needcooler=true;
}
}

public void Print()
{
Sc.WriteLine("This is "+name);
Sc.WriteLine("Frequency is "+freq);
if(needcooler==true)
Sc.WriteLine("It needs a cooler!");
else Sc.WriteLine("It is boxed.");
}

}

class Application
{
public static void Main()
{
CPU Pentium=new CPU("Pentium",2000);
CPU Athlon=new CPU("Athlon",2000);
Pentium.IsBoxed=true;
Athlon.IsBoxed=false;
Sc.WriteLine("The first CPU:");
Pentium.Print();
Sc.WriteLine();
Sc.WriteLine("The second CPU:");
Athlon.Print();
Sc.ReadLine();
}
}

Я хочу остановиться на следующем моменте -> мы определили закрытый член-переменную isboxed и открытое свойство IsBoxed. Так вот, в isboxed хранится значение, определяющее тип упаковки проца, в то время, как свойство IsBoxed работает с этой переменной и с некоторыми другими по надобности. В этом примере мы определили конструктор с двумя параметрами, т.е. конструктор, устанавливающий значения двух перменных-членов, а остальные инициализируются при установке значения свойства. Такой прием носит название отложенной инициализации и имеет немалое значение в оптимизации.

Учим C#: №7

Twit — Sun, 17 Mar 2013 08:42:31 GMT

Сегодня я хотел бы рассказать о других, пропущенных членах классов, т.к. время уже пришло. В прошлой статье я говорил о перегрузке операторов. Существует специальный оператор, предназначенный для индексирования массива - []. И его нельзя перегрузить. Хотя нет, можно, но при выполнении следующего условия: перегружать его только для тех объектов, сущностью которых является массив каких-либо элементов. И адресовать этот индексатор будет не различные элементы массива объектов, а какой-либо массив, являющийся членом объекта.
Далее приведен общий формат определения одномерного индексатора.
public возвращаемый_тип this[int index]
{
get{тело_метода_чтения;}
set{тел_ метода_установки;}
}

Чтоб было понятнее, определим индексатор для нашего класса Matrix...

using Sc=System.Console;

class Matrix// класс матрицы
{
private int[,] element=new int[4,4];

//-------Ну-а-теперь-время-----
//-------определить-индексатор-
public int this[int i,int j]
{
//Метод доступа для чтения
get
{
return element[i,j];
}
//Метод доступа для установки
set
{
element[i,j]=value;
}
}
}

class Application
{
public static void Main()
{
Matrix matrix1=new Matrix();
int i,j;//для цикла

//Установим разные значения
//элементов матрицы при помощи
//определенного индексатора

for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
matrix1[i,j]=i+j;
}
}

//Теперь точно таким же способом
//сделаем вывод на консоль

for(i=0;i<4;i++)
{
for(j=0;j<4;j++) Sc.Write(" "+matrix1[i,j]);
Sc.WriteLine();
}

Sc.Write("Нажмите ENTER для выхода.");
Sc.ReadLine();
}
}

Теперь немного слов. Здесь в теле метода set вы должны были обратить внимание, что переменная с именем value нигде не определена. В этом случае value является ключевым словом, указывающим неявно на значение выражения справа от оператора присваивания. get и set также являются ключевыми словами, они являются специальными методами. Если рассмотреть, например, такую строку:

matrix1[i,j]=matrix2[j,i];

то вызывается метод get объекта matrix1 и метод set объекта, а value указывает на значение, возвращаемое методом чтения объекта слева. Вроде просто и красиво, а кое-где даже полезно.

Учим C#: №6

Twit — Sun, 17 Mar 2013 08:41:51 GMT

Перегрузка операторов позволяет определить воздействие операторов на объекты, т.е., благодаря перегрузке операторов, мы можем применять их к объектам. В принципе, перегрузка оператора осуществляется специальным методом. Метод перегруженного операторов должен объявляться как public static. Операторы бывают унарные и бинарные. Унарные операторы работают с одним операндом, а бинарные - с двумя. Для указания перегрузки операторов используется ключевое слово operator. В зависимости от количества операндов, различают две общие формы операторных методов. Вот и они:

public static возвращаемый_тип operator #(тип_операнда операнд)
{
//тело метода унарного оператора
}
public static возвращаемый_тип operator #(тип_операнда1 операнд1, тип_операнда2 операнд2)
{
//тело метода бинарного оператора
}

Теперь некоторые ограничения на перегрузку операторов:
- приоритет операторов не меняется (в C# приоритет операторов можно считать таким же, как и в C/C++);
- нельзя менять определенное в языке для конкретного оператора количество операндов;
- тело метода перегружаемого оператора должно определять действия оператора, по отношению к объекту/объектам текущего класса.
- операторы сравнения (кроме равенства) надо определять по два, т.е., если есть '>', то должно быть и '<';
- нельзя перегружать операторы сравнения

И, наконец, перегрузим несколько операторов для нашего класса Matrix. В нем я буду использовать условный оператор if(выражение){блок1;}else{блок2;}. Для тех, кто с ним не знаком, объясняю... Если выражение в круглых скобках принимает значение истины, то выполняется блок1, иначе - блок2, следующий за else. Все просто!
//Этуот пример можно было бы сделать красивее,
//с динамическим распределением, но некоторым
//это пока будет сложно
using Sc=System.Console;

class Matrix// класс матрицы
{
//-Объявим-закрытый-член-класса----------
//-Массив-10x10-целочисленных-переменных-
//-Элементов-матрицы---------------------
int[,] element=new int[4,4];
//----Конструктор-по-умолчанию---------
public Matrix()
{
int i,j;
//цикл для прохода по строкам
for(i=0;i<4;i++)
{ //цикл для прохода по элементам строки
for(j=0;j<4;j++)
{ //установка в 0 каждого элемента
element[i,j]=0;
}
}
}
//-теперь-определим-методы-присваивания-и---
//-получения-значения-определенному-элементу-
public void SetValue(int line,int row,int value)
{
element[line,row]=value;
}
public int GetValue(int line,int row)
{
return element[line,row];
}

//-определим-перегруженный-метод-вывода-
public void Print()//вывод всей матрицы
{
int i,j;//переменные для циклов
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(i,j));
}
Sc.WriteLine();
}Sc.ReadLine();
}
public void Print(int line)//вывод строки
{
int j;
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(line,j));
}
Sc.WriteLine();
Sc.ReadLine();
}
public void Print(int line,int row)//вывод элемента
{
Sc.WriteLine("Element["+line+","+row+"]="+GetValue(line,row));
}
//-и-наконец-метод-ввода-всех-элементов-
public void Scan()
{
int i,j,ii;
for(i=0;i<4;i++)
{
string str1;
ii=i+1;
Sc.WriteLine("Enter string #"+ii);
for(j=0;j<4;j++)
{
Sc.Write("Enter value for element["+i+","+j+"](then press Enter)=>");
str1=Sc.ReadLine();
element[i,j]=int.Parse(str1);
}
Sc.WriteLine();
}
}

public int Sum()//счет суммы всех элементов
{
int sum=0;
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++) sum=sum+element[i,j];
//или sum+=element[i,j];
}
return sum;
}

//А вот и они - операторы

public static Matrix operator ++(Matrix m)
{//унарный оператор инкремента
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++) m.element[i,j]++;
}
return m;
}
public static Matrix operator +(Matrix m1,Matrix m2)
{//бинарный оператор сложения
Matrix mresult=new Matrix();
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++) mresult.element[i,j]=m1.element[i,j]+m2.element[i,j];
}
return mresult;
}
//операторы сравнения возвращают значения
//типа bool (1 или 0)
//часто используются в выражениях
//условных операторов
public static bool operator >(Matrix m1,Matrix m2)
{
if(m1.Sum()>m2.Sum()) return true;
else return false;
}
public static bool operator <(Matrix m1,Matrix m2)
{
if(m1.Sum() else return false;
}
}

class Application
{
public static void Main()
{
Matrix matrix1=new Matrix();
Matrix matrix2=new Matrix();
Matrix matrix3=new Matrix();
Sc.WriteLine("Input 1st matrix:");
matrix1.Scan();matrix1++;
Sc.WriteLine("1st matrix incremented:");
matrix1.Print();
Sc.WriteLine("input 2nd matrix:");
matrix2.Scan();
matrix3=matrix1+matrix2;
Sc.WriteLine("matrix1 + matrix2 is");
matrix3.Print();
if(matrix3>matrix2) Sc.WriteLine("matrix3 is bigger");
else Sc.WriteLine("matrix3 is not bigger");
Sc.ReadLine();
}
}
Чтобы перегрузить операторы '==' и '!=' необходимо переопределить методы Equals() и GetHashCode() базового класса Object (или типа object). Для полного счастья, сделаем уже и это. Но, для начала, я расскажу немного о упаковке/распаковке. Все классы автоматически наследуют фундаментальный класс Object. Следовательно, любой тип или класс можно привести к типу object. Возможна и обратная процедура. Приведение объекта к объекту базового типа object и называется упаковкой. Распаковка - это обратная процедура. В следующем примере мы воспользуемся распаковкой в переопределении метода Equals(object o). Критерий равенства матриц - равенство сумм всех элементов обеих матриц. Просто добавляем следующие методы в наш класс Matrix...

public override int GetHashCode()
{
return 100;
}
public override bool Equals(object o)
{
//unpack it now
Matrix matr=(Matrix)o;
if(Sum()==matr.Sum()) return true;
else return false;
}

public static bool operator ==(Matrix m1,Matrix m2)
{
if(m1.Sum()==m2.Sum()) return true;
else return false;
}
public static bool operator !=(Matrix m1,Matrix m2)
{
if(m1.Sum()!=m2.Sum()) return true;
else return false;
}
И следующие строки в конец метода Main()...
if(matrix1==matrix2) Sc.WriteLine("matrix1=matrix2");
else Sc.WriteLine("matrix1!=matrix2");
Sc.ReadLine();

Далее комментировать эту прогу я не вижу смысла. Командная строка, csc имя_файла & GO! Ну, создавать классы умеем, интерфейсы - умеем, умеем наследовать, умеем перегружать операторы и методы, умеем пользоваться объектами, создавать новые типы данных, если вы, конечно, прочитали все мои статьи. Можно, сказать, что теперь и ты знаешь основы объектно-ориентированного программирования, Нео!

Учим C#: №5

Twit — Sun, 17 Mar 2013 08:40:54 GMT

Перегрузка.

Методы

Некоторые более опытные ребята уже усекли перегрузку методов в листингах предыдущих статей. Какие же методы мы перегружали? Мы уже перегружали конструкторы. И перегружали мы их по количеству параметров. В большинстве примеров присутствуют конструктор по умолчанию, т.е. без параметров, и конструктор с параметрами. Методы можно перегрузить по количеству параметров, а также по типам аргументов. Благодаря перегрузке методов, объект может вести себя по-разному, в зависимости от способа вызова метода. Приведем пример класса с перегруженными методами. Количество форм метода условимся называть его степенью перегрузки. Приведем пример класса с перегруженными методами (кто не знаком с массивами, сейчас будем знакомить, массив - это набор элементов одного типа).
//Этуот пример можно было бы сделать красивее,
//с динамическим распределением, но некоторым
//это пока будет сложно
using Sc=System.Console;

class Matrix// класс матрицы
{
//-Объявим-закрытый-член-класса----------
//-Массив-10x10-целочисленных-переменных-
//-Элементов-матрицы---------------------
private int[,] element=new int[4,4];
//----Конструктор-по-умолчанию---------
public Matrix()
{
int i,j;
//цикл для прохода по строкам
for(i=0;i<4;i++)
{ //цикл для прохода по элементам строки
for(j=0;j<4;j++)
{ //установка в 0 каждого элемента
element[i,j]=0;
}
}
}
//----Конструктор-с-3мя-параметрами------
//-строка-столбец-и-значение-------------
//-устанавливает-в-определенное-значение-
//-определенный-элемент-а-остальные-в-0--
public Matrix(int line,int row,int value):this()
{
element[line,row]=value;
}
//----Конструктор-копирования-------
//-создает-объект-на-основе-объекта-
public Matrix(Matrix ob1)
{
int i,j;
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
element[i,j]=ob1.element[i,j];
}
}
}
//-теперь-определим-методы-присваивания-и---
//-получения-значения-определенному-элементу-
public void SetValue(int line,int row,int value)
{
element[line,row]=value;
}
public int GetValue(int line,int row)
{
return element[line,row];
}

//-определим-перегруженный-метод-вывода-
public void Print()//вывод всей матрицы
{
int i,j;//переменные для циклов
for(i=0;i<4;i++)
{
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(i,j));
}
Sc.WriteLine();
}Sc.ReadLine();
}
public void Print(int line)//вывод строки
{
int j;
for(j=0;j<4;j++)
{
Sc.Write(" "+GetValue(line,j));
}
Sc.WriteLine();
Sc.ReadLine();
}
public void Print(int line,int row)//вывод элемента
{
Sc.WriteLine("Element["+line+","+row+"]="+GetValue(line,row));
}
//-и-наконец-метод-ввода-всех-элементов-
public void Scan()
{
int i,j,ii;
for(i=0;i<4;i++)
{
string str1;
ii=i+1;
Sc.WriteLine("Enter string #"+ii);
for(j=0;j<4;j++)
{
Sc.Write("Enter value for element["+i+","+j+"](then press Enter)=>");
str1=Sc.ReadLine();
//C# не позволяет считывать численные данные
//непосредственно "в переменные".
//считываем их в строку, затем "парсим".
//читай после листинга
element[i,j]=int.Parse(str1);
}
Sc.WriteLine();
}
}
}

class Application
{
public static void Main()
{
Matrix matrix1=new Matrix();
Matrix matrix2=new Matrix(3,3,3);
matrix1.Scan();
Matrix matrix1_copy=new Matrix(matrix1);

Sc.Write("Matrix2->");
matrix2.Print(3,3);//вывод одного элемента
Sc.WriteLine();
Sc.WriteLine("The very first line of matrix1:");
matrix1.Print(0);//вывод нулевой строки
Sc.WriteLine("& finally the full matrix1_copy");
matrix1_copy.Print();//вывод всей матрицы
}
}
Каждый тип, как я уже сказал - это класс. В каждом классе численного типа определен метод Parse(string str), который преобразует переданную ему строку в число и возвращает это число. Тип, возвращаемый методом, идентичен типу, описанному в классе. Обращение к методу производится следующим образом:
псевдо_имя_типа.Parse(строка);
Где псевдо_имя_типа - это просто название типа в C#. Вообще, честно говоря, применение консольного режима ограничено. А теперь о проге. В ней перегружены два метода. Степень перегрузки обоих методов равна 3. Итак, чтобы перегрузить метод, его достаточно просто повторно описать. Список параметров у каждой формы метода должен быть уникальным. Перегрузка методов - это неотъемлемая часть полиморфизма. При вызове метода выполняется та его форма, аргументы которой подходят под заданные. С методами все. Теперь об операторах.

Учим C#: №4

Twit — Sun, 17 Mar 2013 08:39:59 GMT

using sc=System.Console;

abstract class Stone //это будет базовый класс
{
protected float weight;//protected можно смело
protected int color;//использовать в абстрактных классах
//т.к. они в любом случае наследуемы.
public Stone(){weight=0;color=0;}//конструктор
public Stone(float w,int c) //конструктор
{
weigth=w;
color=c;
}
public abstract void Print(); //абстрактный метод вывода
}
class Diamond:Stone //это производный класс
{
private double price;
public Diamond(){price=0;}
public Diamond(float ww,int cc,double pp):base(ww,cc)
{price=pp;}
public override void Print() //метод вывода.
//override говорит компилятору о том,
//что код наследованного метода
//будет переопределен.
{
sc.WriteLine("The weight is "+weight);
sc.WriteLine("The color number is "+color);
//ключевое слово base позволяет получить
//доступ и к закрытым членам базового класса
//имеет смысл ссылки на базовый класс
sc.WriteLine("The price is "+price);
sc.ReadLine();
}
}

class Prog
{
public static void Main()
{
Diamond ob1=new Diamond(10,4,99.99);
ob1.Print();
}
}

В .Net Framework имеется специальный класс - Object. А еще точнее - System.Object. Этот класс является базовым для всех стандартных классов. Любой тип в C# - это, по сути, класс. Поэтому мы до сих пор не рассмотрели типы, а вот мучаемся тут с этими концепциями и реализациями. Зато потом будет понятнее архитектура. Я, например, в свое время пожалел, что сначала знакомился с типами. Да, но что-то я не о том. Object это фундаментальный класс. Он определяет минимальный набор методов для объекта. Практически, все классы .Net Framework наследуют этот класс, и этот момент очень важен. Итак, класс System.Object определяет шесть открытых методов:

public virtual bool Equals(object object)
Этот метод определяет равенство вызывающего и передаваемого экземпляров.

public static bool Equals(object ob1,object ob2)
Этот метод определяет равенство объектов ob1 и ob2, передаваемых в качестве параметров. Метод Equals() перегружен, т.к. для него определено два разных контекста.

public virtual int GetHashCode()
Этот метод возвращает хэш-код, соответствующий вызывающему объекту. Применяется в алгоритмах, использующих хэши для доступа к экземплярам.

public Type GetType()
Этот метод возвращает тип объекта.

public static bool ReferenceEquals(object ob1,object ob2)
Этот метод определяет равенство ссылок ob1 и ob2, т.е. ссылаются ли они на один экземпляр.

public virtual string ToString()
Этот метод возвращает строку с описанием объекта.

И два закрытых:

protected void Finalyze()
Вызывается перед сборкой мусора. В принципе, можно не использовать. Не следует помещать в выполняемый код. Обычно вызывается деструктором.

protected object MemberwiseClone()
Один старый опытный кодер сказал мне, что этот метод используется для копирования объектов, при котором не копируется объект, а копируются его члены. Если честно, то я ему не верю, т.к. метод возвращает значение типа object. Этот метод скорее создает копию объекта, содержащую ссылки на другие объекты. С этой штукой я пока не экспериментировал и за базар не отвечаю. Как-нибудь, я разберусь с этим, напишу.

Теперь можно переходить к интерфейсам с чистой душой. Интерфейсами в C# принято называть структуры, содержащие прототипы методов. Интерфейс, как и абстрактный класс не может являться базой для создания объектов. Синтаксис интерфейса похож на синтаксис абстрактного класса, но интерфейс не может содержать переменные-члены и тела методов, строго прототипы. А во всем остальном, можно считать их одной и той же сущностью. Все методы интерфейса являются виртуальными. Для создания интерфейсов в C# используется ключевое слово interface. Ниже приведен общий вид интерфейса и его наследования:

public interface имя_интерфейса //определение интерфейса
{
тип_1 метод_1(список_параметров_1); //прототип_1
...........................................................
тип_n метод_n(список_параметров_n); //прототип_n
}

class имя_класса:имя_интерфейса
//наследование интерфейса классом
{
//тело класса
}

Примечание: при переопределении методов интерфейса ключевое слово override использовать не надо.

Если мы создаем объект типа класса, то нам приходится работать с ссылкой на него, что накладывает некоторое дополнительное время обработки. В С++ структура и класс v почти одно и то же, за исключением разницы в доступе по умолчанию и некоторых синтаксических аспектов. В C# структура синтаксически схожа с классом, может инициализироваться также, как и класс, но она имеет тип значения, а не ссылки, как класс. Это обеспечивает повышение эффективности. Итак, когда следует использовать структуры? Их следует использовать в том случае, если объект не обладает особой сложностью и большими объемами. Иначе говоря, структуры следует использовать для создания более простых объектов. Но синтаксически они мало чем отличаются. Для создания структуры используется старое доброе ключевое слово struct. Но теперь структура определяет тип данных, а не тип структуры, как в С++, и необходимость в использовании typedef отпадает. Вообще C# освобождает кодера от всяких таких мелочей, и не только мелочей, работа стала легче... Но это не значит, что это язык для ламеров... Структура в C# не может определять деструкторы, также не может определять конструторы по умолчанию (без параметров).
Итак, ключевое слово class определяет тип ссылки, а struct v тип значения. Пример структуры я приводить не буду, т.к. сейчас это уже предельно просто.

Теперь, наверное, последняя структура данных - перечисления. В C# под перечислением понимают некоторый упорядоченный набор целочисленных констант. Для создания используется ключевое слово enum. Рассмотрим следующий пример:

enum CodeMen{gates,torwald,straustrup,ritchie,kernigan};

доступ к элементам производится как и в случае с классом, но им автоматически присваиваются такие значения:

CodeMen.gates =0
CodeMen.torwald =1
CodeMen.straustrup =2
CodeMen.ritchie =3
CodeMen.kernigan =4

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

enum CodeMen:ulong{gates,torwald,straustrup,ritchie,kernigan};

Теперь все члены перечисления будут иметь значение типа ulong. Это может быть любой другой целочисленный тип, кроме char.

В принципе, теперь вы знаете основы объектно-ориентированной модели C#.

В завершении я хочу привести фундаментальные типы C# с именами классов, которые отвечают за их обработку.

Приведение типов осуществляется, как в С++. Покажем это на следующем примере:
....
int k=10;
object ob1;
ob1=(object)k;
//приведение значения типа int типу object.
....

И, наконец, немного о полиморфизме. Полиморфизм обеспечивается использованием интерфейсов. Хотя, в принципе, полиморфизм можно создать и без интерфейса, но это считается неправильно, типа, если есть - юзай! Я считаю, что на этом не стоит сейчас останавливаться, вы это еще не раз увидите в моих, и не только моих примерах.

Теперь почти все самое нудное позади, далее пойдут вещи новые и более интересные. В следующей статье будет описана перегрузка методов и операторов (только это, пожалуй, нам не ново), некоторые классы .Net Framework, а также некоторые принципы автоматизации работы программ при помощи того же волшебного .Net. Скоро вы узнаете, почему он волшебный!

Учим C#: №3

Twit — Sun, 17 Mar 2013 08:38:38 GMT

Язык программирования считается объектно-ориентированным, если в нем реализованы механизм классов и объектов, а также три важных свойства (я их считаю возможностями):

Инкапсуляция - это возможность скрыть некоторые члены класса от пользователя. Например, предотвратить вмешательство пользователя во внутреннюю структуру класса, предотвратить ошибки, которые могут возникнуть в результате изменений пользователя и т.д.
Наследование - это возможность создания производных классов на основе базовых классов, которые также называют классами-предками. Существуют такие классы, объекты которых не могут быть созданы, т.к. эти классы необходимо доопределить. Такие классы называются абстрактными и могут быть только предками, причем, в производном классе должны быть определены тела (код) методов, являющихся абстрактными (т.е. только прототип) в базовом классе. Методы, определенные виртуальными в базовом классе, могут быть переопределены. Метод, определенный абстрактным, автоматически становится виртуальным. Абстрактный класс может отражать некоторые общие свойства и методы для разных типов объектов, его можно назвать интерфейсом; но в С# принято называть интерфейсами немного другое - интерфейс содержит только прототипы методов без тел и не содержит переменных-членов. Другими словами, интерфейс определяет, что делать, но не определяет, как делать. Интерфейс также может быть унаследован производным классом. Абстрактные классы и интерфейсы несут некоторую фундаментальную неполную информацию об объекте.
Полиморфизм - это возможность одинакового обращения к методам объектов разного типа. Использование одного интерфейса в качестве предка для нескольких классов порождает полиморфизм.

Инкапсуляция в С# достигается за счет применения модификаторов доступа public, private & protected, internal. Как в С++, не так ли? Да, но...
В С++ мы писали так:

private:
закрытые члены;//не доступны клиенту
protected:
защищенные от клиента, но доступные производному классу члены;
public:
открытые члены;//доступны клиенту

А в C# вот как:

private член1;
public член2;
protected член3;
.....

Т.е. уровень доступа указывается явно для каждого члена. Если это функции (методы), то перед именем указывается тип возвращаемого значения, после имени в круглых скобках указывается список аргументов, перед типом может стоять некоторое ключевое слово.
Модификатор internal - нечто среднее между public и protected, в зависимости от того, где находится код. Это достаточно специфичный модификатор доступа. Член становится видимым только в пределах текущей единицы компиляции. Я считаю, что в написании прог им можно не пользоваться, но его знание может пригодиться в анализе других прог. Хотя, я намереваюсь все же его затронуть в своих статьях.
Об инкапсуляции все самое основное вы должны были понять, остальное это вопрос энтузиазма.
Наследование реализуется довольно просто. Приведем пример:

using sc=System.Console;

class Stone //это будет базовый класс
{
protected float weight;//использован модификатор
protected int color;//protected в целях наследования.
public Stone(){weight=0;color=0;}//конструктор
public Stone(float w,int c) //конструктор с параметрами
{
weight=w;//присваивание значений
color=c;
}
public void Print() //метод вывода
{
sc.WriteLine("The weight is "+weight);
sc.WriteLine("The color number is "+color);
sc.ReadLine();
}
}
class Diamond:Stone //это производный класс
{
private double price;//не доступно вне класса
public Diamond(){price=0;}
public Diamond(float ww,int cc,double pp):base(ww,cc)
{price=pp;}//вызов конструктора базового класса и дополнение его своим опреациями
new public void Print() //метод вывода.
//new скрывает метод
//базового класса с таким же именем.
//не следует путать с выделением памяти
{
base.Print(); //ключевое слово base позволяет получить
//доступ к члену базового класса
sc.WriteLine("The price is "+price);
sc.ReadLine();
}
}

class Prog
{
public static void Main()
{
Diamond ob1=new Diamond(10,4,99.99);
ob1.Print();
}
}
Итак, есть класс, описывающий камень и созданный на его основе класс, описывающий бриллиант. Конструктор с параметрами производного класса сначала запускает аналогичный конструктор базового класса, передавая ему нужные значения, затем производит свои действия:

public Diamond(float ww,int cc,decimal pp):base(ww,cc)
{price=pp;}

Здесь осуществляется вызов конструктора с параметрами базового класса. При этом базовому конструктору передаются аргументы, заданные в вызове производного конструктора. В таком контексте ключевое слово base имеет смысл ссылки на конструктор базового класса.
Наследование можно предотвратить, определив класс как sealed. Это ключевое слово указывает, что данный класс не может быть предком. Если мы определим класс Stone в нашей проге таким образом:

sealed class Stone
{
}

то производный класс Diamond не унаследует члены базового класса.

А теперь немного переделаем нашу прогу:

using sc=System.Console;

class Stone //это будет базовый класс
{
protected float weight;
protected int color;
public Stone(){weight=0;color=0;}//конструктор
public Stone(float w,int c) //конструктор
{
weight=w;
color=c;
}
public virtual void Print() //виртуальный метод вывода
{
sc.WriteLine("The weight is "+weight);
sc.WriteLine("The color number is "+color);
sc.ReadLine();
}
}
class Diamond:Stone //это производный класс
{
new int color;//закроем переменную базового класса
private double price;
public Diamond(){price=0;}
public Diamond(float ww,int cc,double pp):base(ww,cc)
{price=pp;}
public override void Print() //метод вывода.
//override говорит компилятору о том,
//что код наследованного метода
//будет переопределен.
{
sc.WriteLine("The weight is "+base.weight);
sc.WriteLine("The color number is "+base.color);
//ключевое слово base позволяет получить доступ
//и к членам базового класса, закрытым из-за
//объявления новой переменной с таким же именем.
//base имеет смысл ссылки на базовый класс.
sc.WriteLine("The price is "+price);
sc.ReadLine();
}
}

class Prog
{
public static void Main()
{
Diamond ob1=new Diamond(10,4,99.99);
ob1.Print();
}
}

Теперь мы познакомились с виртуальными функциями. Тут же я хочу отметить ключевые слова this и base. И то, и другое имеет смысл ссылки на объект. Но разница в том, что this ссылается на текущий объект текущего класса (того класса, типом которого является сам объект), а base ссылается на объект базового класса (предка). Если не понятно,

this - полноценный объект, с которым мы работаем;
base - объект базового класса-предка.

Абстрактные классы. Как много страха выражают эти два слова для начинающего кодера! Но, на самом деле, бояться здесь нечего. Как уже отмечалось, абстрактный класс - это класс, объект которого нельзя создать, может нести некоторую часть теоретической информации об объекте. Но зачем они нужны? На базе абстрактных классов можно создавать новые производные классы, на основе которых можно будет создавать объекты. Для создания абстрактного класса в C# используется ключевое слово abstract. Абстрактным можно определить и метод, используя все то же ключевое слово. Как уже было отмечено, абстрактный метод автоматически становится виртуальным. Итак, пример...

Учим C#: №2

Twit — Sun, 17 Mar 2013 08:37:14 GMT

Основной структурой объектно-ориентрованного программирования является класс. Классы – это кирпичики, из которых состоит любая программа на С#. Конечно же классы – это основа С#. Поэтому я их рассматриваю в первую очередь, хотя многие считают, что надо начинать с типов данных и операторов.
Без знания классов и основных концепций ООП невозможно создать действительно !качественного! приложения в С#.
В классе определяются данные и код, обрабатывающий эти данные. Активный процесс С#-программы происходит внутри класса. Класс является определением составляющих объекта. Переменная типа класса называется объектом, то есть объект – это экземпляр класса. Под инициализацией объекта понимается инициализация переменных в объекте. Как и в C++, инициализация объекта выполняется специальной функцией – конструктором. Класс может иметь несколько конструкторов, но об этом попозже. Функции-методы и данные, составляющие класс называют членами класса.
Итак, класс – это описание объекта (за исключением одного момента, который вы вскоре уловите). Я думаю, понятно, что данные содержатся в переменных объекта, а код – в функциях-методах. В С# применяется следующая классификация членов класса:

переменные;
статические переменные;
константы;
конструкторы;
деструкторы;
методы;
операторы;
свойства;
индексаторы;
события;

Определение класса начинается, как и в С++, с ключевого слова class. Например,

class example //example – это имя класса
{
//-----------Объявление-переменных-------------
private int version; //эта переменная доступна только для членов класса
public int amount; //а эта открыта для кода, находящегося вне данного класса
//-----------Объявление-методов-------------------
public int get_version()//
{
//тело метода (код)
}
}

“public” & “private” называются идентификаторами доступа.

А теперь напишем прогу...

using System;

class CPU //этот класс описывает
{ //характеристики проца
public char ID; //идентификатор производителя
//(I->Intel, A->AMD)
public int freq; //рабочая частота проца (Mhz)
public int CACHE; //размер кэша (Kb)
}

class Application
{
public static void Main()
{
CPU object1 = new CPU();//создание объекта класса CPU
object1.ID = ’A’;
object1.freq = 1700;
object1.CACHE = 256;
Console.WriteLine (“Made by “+object1.ID);
Console.WriteLine (“Frequence is”+object1.freq+”Mhz”);
Console.WriteLine (“CACHE has “+object1.CACHE+”Kb”);
}

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

В классе CPU мы определили основные характеристики процессора в качестве одной символьной и двух целочисленных переменных.

Как создается объект в C#? Можно выделить 2 этапа (на примере вышеприведенного кода):

1) Объявление переменной object1 типа CPU. Но переменная не является объектом, как, например, в С++, а только ссылается на него.

2) Оператор new создает физическую реализацию объекта, т.е. динамически выделяет память под объект, на который теперь получает ссылку переменная. Если мы наберем, к примеру, CPU object2 = object1; мы не создадим нового объекта, мы создадим новую ссылку на старый объект.

Смысл оператора присваивания в первой строке метода Main() заключается в том, что переменная получает значение адреса объекта в памяти. Можно создавать несколько ссылок на один объект, приравнивая новые к первой и т.д.

В C# память, занимаемая объектом, должна выделяться строго динамически!

Теперь поговорим о конструкторах и деструкторах. Это специальные методы, отвечающие за инициализацию и удаление объектов соответственно. Конструктор в С# похож на конструктор в С++. И там и там конструкторы и деструкторы не имеют возвращаемого значения. Добавим к нашему классу 2 конструктора:

class CPU //этот класс описывает
{ //характеристики проца
public char ID; //идентификатор производителя
//(I->Intel, A->AMD)
public int freq; //рабочая частота проца (Mhz)
public int CACHE; //размер кэша (Kb)

public CPU() //конструктор по умолчанию
{
ID = 0;freq = 0;CACHE = 0;//установка в 0 значений
//всех переменных-членов
}
public CPU(char ID_,int freq_,int CACHE_)
{ //конструктор с тремя параметрами -
//значениями для переменных
ID = ID_;
freq = freq_;
CACHE = CACHE_;
}
}

В конструкторах чаще всего описывают динамическое выделение памяти и задание начальных значений некоторых переменных. Показано два конструктора – по умолчанию и с параметрами. Существуют и другие разновидности конструкторов, но это как-нибудь потом, а то перегруз инфы пойдет. Конструктор в классе должен быть объявлен открытым, т.е. public.
Еще одно нововведение С# - механизм сборки мусора. Итак, оператор new динамически выделяет память под объект. Но “...памяти никогда не бывает много...” (так говорит мой препод по Центральным Устройствам) и ее надо освобождать после использования. В С++ мы это делали оператором delete. Сейчас память освобождается сама тогда, когда объект больше не используется, т.е. тогда, когда отсутствуют обращения к нему. Память освобождается при необходимости. Сборка мусора производится только тогда, когда она может быть выполнена эффективно, например, для нескольких объектов одновременно. Деструктор же может использоваться для гарантии удаления. Можно его использовать для осведомления пользователя о деятельности нового чудо-механизма. Деструктор, как и конструктор, имеет такое же имя, как и класс, но перед ним ставится знак ‘~’. А теперь, типа фокус...
class CPU //этот класс описывает
{ //характеристики проца
public char ID; //идентификатор производителя
//(I->Intel, A->AMD)
public int freq; //рабочая частота проца (Mhz)
public int CACHE; //размер кэша (Kb)

public CPU() //конструктор по умолчанию
{
ID = 0;freq = 0;CACHE = 0;//установка в 0 значений
//всех переменных-членов
}
public CPU(char ID_,int freq_,int CACHE_)
{ //конструктор с тремя параметрами -
//значениями для переменных
ID = ID_;
freq = freq_;
CACHE = CACHE_;
}
}
public void CreateNewObject(char ID__,int freq__, int CACHE__)
{
CPU ob = new CPU(ID__,freq__,CACHE__); //это используем
//для создание объектов
}
~CPU() //деструктор
{
System.Console.WriteLine(“Сгорел твой проц!!!”);
}
}
//--------------------
class Application
{
public static void Main()
{
int i;
CPU object = new CPU();
for(i=0;i<500000;i++) object.CreateNewObject(‘A’,1700,i);
}
}

Итак, мы создали множество объектов методом CreateNewObject() в цикле for. Со временем они перестают быть используемыми и удаляются, причем группами. На экране должны появляться сообщения от деструктора. Чаще всего деструктор генерирует сообщения об удалении объекта, т.е. для осведомления пользователя. Сообщения деструкторов могут выводится, например, в Status Bar’e.

Еще я хочу сказать пару слов о методах, и на сегодня все... Метод является одной из двух основных составляющих класса. Итак, что такое метод? Это ни что иное, как старая добрая сишная функция, являющаяся членом класса. Кто не знаком с функциями, советую взять любой учебник по С или С++ и посмотреть. Метод содержит в себе определенный код, последовательность операций, может возвращать значение при помощи оператора return:

return значение;

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

А вот вам сувенирчик – ссылка на .Net Framework SDK, содержащий компиляторы и другие инструменты для создания .Net-приложений. Весит около 132 Мб, но оно того стоит... Советую скачать. Не советую качать без Getright или подобной проги. Можно компилировать программы на С#, не имея MS Visual Studio на семи дисках.

И еще одно... Если вы считаете, что мои статьи короткие, просьба написать об этом в мнениях.

Следующая глава раскроет другие новые аспекты объектно-ориентированной модели C#. Это очень объемная тема, за один раз ее сложно рассмотреть и преподнести. Да и не зачем так мозги нагружать, мы же не в универе! Еще хочу включить в следующую статью перегрузку операторов и ключевое слово this. Но пока не обещаю. Я считаю, что чем меньше доза информации, тем больше прикола, и она лучше усваивается. Я хочу, чтоб читатели наслаждались чтением, а не грузились. Поэтому такие вот короткие статейки. Если я не прав, оставляйте свои мнения...

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

Учим C#: №1

Twit — Sun, 17 Mar 2013 08:36:33 GMT

Язык С после своего появления завоевал сердца многих кодеров. Программирование развивалось, задачи усложнялись тем самым увеличивая размер кода. Возникла необходимость в новом подходе к программированию...
Возникает новое направление – объектно-ориентированное программирование. Его особенность заключается в использовании виртуальных функций и классов, что увеличивает гибкость динамической организации программы в виде отдельных модулей; а также активное преднамеренное использование таких свойств как наследование, полиморфизм, инкапсуляция. Разработан объектно-ориентированный язык программирования C++, соответствующий практически всем аспектам данного направления. Данный язык является основным во многих операционных системах, и почти вся нами горячо любимая Windows (почему почти? - потому что без ASMa никак в системном программировании). Короче в С++ писали почти все (и чуть меньше пишут сейчас). Также широко используется сочетание его с другими языками. Проги в С/C++ компилируются в бинарные исполняемые файлы или в бинарные динамические библиотеки (dll).
Но как известно многим нам – программистам и юзерам, существует один страшный монстр в этом компьютерном мире, и называет он себя гордо – Microsoft. Базару нет - он управляем, и управляет им отважный праотец миллионов дыр в своих операционках, его дырявое величество, Билл Гейтс, мать его так! Решил Билл удивить мир и сказал своим апостолам:
- Вот С++ - хорошая концепция, а мы мутим, типа, самую лучшую реализацию этой концепции под самую глючную, самую дырявую, короче, самую конченную операционную систему во всем этом, из-за наших систем, неидеальном мире! Мы гребанные молодцы!!! Надо создавать свой язык программирования и заставим пользоваться им всех владельцев новых версий Visual C++ 7. Вот это будет тема, типа!
И то ли он что-то недосказал, то ли апостолы что-то прослушали... Сделали, в общем, вещь толковую. А назвать ее решили C#. Я считаю, красивый понт. А Билл, сам того не желая, сделал в своей жизни хоть что-то толковое, а не очередную покупку у лохов прав на DOS или подписывание контрактов с IBM, где последняя расписывается в том, что является лохушкой! C# имеет двух родителей – это С++ и Java, легко учится при наличии небольшого опыта хоть в одном из этих двух языков. В последние годы много шуму наделал язык JAVA от Sun Microsystems. Его можно назвать внуком С++. Программы JAVA компилируются не в бинарный исполняемый файл, как в С/C++, а в так называемый байт-код, выполняемый виртуальной машиной JAVA. Так был решен вопрос о переносимости. Но, по мнению Microsoft, у JAVA ест один серьезный недостаток – отсутствие прямой поддержки Windows. Код JAVA не совместим с кодом C/C++, но синтаксис явно заимствован из С++, но конечно есть некоторые изменения.

Интересный факт:
Язык программирования JAVA – это детище Sun Microsystems, можно сказать, гордость этой компании. Хотя еще какие-то 2 недели назад моя матушка скачивала Java Virtual Machine(среду выполнения JAVA-приложений) с сайта Microsoft. Однако, по решению суда от 3.02.2003, зловещий производитель Windows не имеет прав на распространеие JVM.

И вот тут Microsoft решает внести свою лепту... В конце 90х разрабатывается язык С# для создания кода Net Framework. В 2000 году появляется первая бета-версия. Мне не известно, на чем сделан Net Framework, но это не мешает мне рассказать о том, что это и зачем надо.
Итак, Net Framework – это среда, в которой могут выполняться программно-независимые приложения. В данной среде поддерживается совместная работа в приложении разных языков программирования. Net Framework определяет библиотеки классов, используемых в C#. Любая примитивная программа C# основана на использовании библиотек классов Net Framework. И, пожалуй, самое главное – Net Framework не ограничивается Windows! Я не знаю, существует ли реализация данной среды под другие системы, но уверяю вас, что скоро это все будет.
Net Framework содержит в себе не зависящую от языка среду выполнения. Программы C# не компилируются в бинарный исполняемый файл, а компилируются в промежуточный язык (MS Intermediate Language, MSIL). MSIL можно назвать переносным ассемблером, но это псевдо-ассемблер. Среда переводит MSIL в машинный исполняемый код, который в последствии и выполняется. То есть, Net Framework содержит интерпретатор MSIL. А кто сказал, что интерпретаторы плохи? Я с ним не согласен (ну без базару, небольшой проигрыш во времени при запуске), и вот мой аргумент: интерпретируемость – это идеальное решение проблем переносимости прог. В это же время не возникает никаких ошибок при переносе (если же конечно не глючная версия Net Framework :-) ). Кто знаком с PERL, вспомните, как просто переносятся скрипты в разные ОС.
По традиции, сейчас мы вместе напишем первую прогу на С# - “Hello World!!!”. Если вы являетесь счастливым обладателем MS Studio Net, можете набрать прогу в файле с расширением .сs (пусть его имя Hello.cs), затем в командой строке набираете csc Hello.cs в директории содержащей исходник. В результате получается файл Hello.exe, и запустится он только при наличии Net Framework.

Листинг:
using System; //Это называется определением пространства имен, об этом я буду говорить
//позже
class Hello //Определение класса
{

public static void Main() //любая C#-программа начинается с вызова функции Main()
{
Console.WriteLine(“Hello World!!!”);//метод вывода строки класса Console
}
}

ИТОГ... В вышеприведенном листинге ярко видны 2 отличия от С++:

мы определили пространство имен, использовав новое ключевое слово’using’, которого в С++ не было;
функция Main() содержится прямо в классе, как в JAVA;

А вот еще одно не очень яркое:

в С++ для вывода строки в консольном режиме, мы использовали оператор cout (в принципе, это целый класс) из iostream.h.

Несмотря на все, С# не утрачивает возможности использования динамических библиотек. Успешно комбинируется с ASP.net. Кроме разработки обычных приложений C# может быть использован для автоматизации работы программ, в частности офисных приложений Microsoft, а также других важных направлениях информационных технологий и сферах деятельности человека. С# имеет нововведение, тип decimal, используемый в финансовых вычислениях. Об этих и других возможностях этого концептуально нового языка я расскажу позже, в следующих статьях.
Объектно-ориентированная модель C# куда более совершенна модели C++. Об этом пойдет речь в следующей статье.
I’ll be back!!! See ya!