Язык C# и первые проекты

Еще одна новинка C#, встречающаяся в начальном проекте, это атрибут [STAThread], который предшествует описанию процедуры Main. Так же, как и тэги документирования, атрибуты распознаются специальным инструментарием и становятся частью метаданных. Атрибуты могут быть как стандартными, так и заданными пользователем. Стандартные атрибуты используются CLR и влияют на то, как она будет выполнять проект. В данном случае атрибут [STAThread] (Single Thread Apartment) задает однопоточную модель выполнения. Об атрибутах и метаданных мы еще будем говорить подробно. Заметьте, если вы нечетко представляете, каков смысл однопоточной модели, и не хотите, чтобы в вашем тексте присутствовали непонятные для вас указания, то этот атрибут можно удалить из текста, что не отразится на выполнении.

Скажем еще несколько слов о точке входа - процедуре Main. Ее заголовок можно безболезненно упростить, удалив аргументы, которые, как правило, не задаются. Они имеют смысл, когда проект вызывается из командной строки, позволяя с помощью параметров задать нужную стратегию выполнения проекта.

Таков консольный проект, построенный по умолчанию. Функциональности у него немного. Его можно скомпилировать, выбрав соответствующий пункт из меню build. Если компиляция прошла без ошибок, то в результате будет произведена сборка и появится PE-файл в соответствующей папке Debug нашего проектa. Приложение можно запустить нажатием соответствующих клавиш (например, CTRL+F5) или выбором соответствующего пункта из меню Debug. Приложение будет выполнено под управлением CLR. В результате выполнения появится консольное окно с предложением нажать любую клавишу для закрытия окна.

Слегка изменим проект, построенный по умолчанию, добавим в него свой код и превратим его в классический проект приветствия. Нам понадобятся средства для работы с консолью - чтения с консоли (клавиатуры) и вывода на консоль (дисплей) строки текста. Библиотека FCL предоставляет для этих целей класс Console, среди многочисленных методов которого есть методы ReadLine и WriteLine с очевидной семантикой. Вот код проектa, полученный в результате моих корректировок:

using System;
namespace ConsoleHello
{
	/// <summary>
	/// Первый консольный проект - Приветствие
	/// </summary>
	class Class1
	{
		/// <summary>
		/// Точка входа. Запрашивает имя и выдает приветствие
		/// </summary>
		static void Main()
		{
			Console.WriteLine("Введите Ваше имя");
			string name;
			name = Console.ReadLine();
			if( name == "" )
				Console.WriteLine ("Здравствуй, мир!");
			else
				Console.WriteLine("Здравствуй, " + name + "!");
		}
	}
}

Я изменил текст в тегах <summary>, удалил атрибут и аргументы процедуры Main, добавил в ее тело операторы ввода-вывода. Благодаря предложению using, мне не требуется при вызове методов класса Console каждый раз писать System.Console. Надеюсь, что программный текст понятен без дальнейших пояснений.

В завершение первого проектa построим его XML-отчет. Для этого в свойствах проектa необходимо указать имя файла, в котором будет храниться отчет. Установка этого свойства проектa, так же как и других свойств, делается в окне Property Pages, открыть которое можно по-разному. Я обычно делаю это так: в окне Solution Explorer выделяю строку с именем проектa, а затем в окне Properties нажимаю имеющуюся там кнопку Property Pages. Затем в открывшемся окне свойств, показанном на рис. 2.3, устанавливается нужное свойство. В данном случае я задал имя файла отчета hello.xml.

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

<?xml version="1.0"?>
<doc>
<assembly>
	<name>ConsoleHello</name>
</assembly>
<members>
	<member name="T:ConsoleHello.Class1">
		<summary>
			Первый консольный проект - Приветствие
		</summary>
	</member>
	<member name="M:ConsoleHello.Class1.Main">
		<summary>
			Точка входа. Запрашивает имя и_выдает приветствие
		</summary>
	</member>
</members>
</doc>

Как видите, отчет описывает наш проект, точнее, сборку. Пользователь, пожелавший воспользоваться этой сборкой, из отчета поймет, что она содержит один класс, назначение которого указано в теге <summary>. Класс содержит лишь один элемент - точку входа Main с заданной спецификацией в теге <summary>.

Windows-проект

Проделаем аналогичную работу: построим Windows- проект, рассмотрим, как он выглядит по умолчанию, а затем дополним его до проектa "Приветствие". Повторяя уже описанные действия, в окне нового проектa (см. рис. 2.1) я выбрал тип проектa Windows Application, дав проектy имя WindowsHello.

Как и в консольном случае, по умолчанию строится решение, содержащее единственный проект, содержащий единственное пространство имен (все три конструкции имеют совпадающие имена). В пространство имен вложен единственный класс Form1, но это уже далеко не столь простой класс, как ранее. Вначале приведу его код, а потом уже дам необходимые пояснения:

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace WindowsHello
{
	/// <summary>
	/// Summary description for Form1.
	/// </summary>
	public class Form1 : System.Windows.Forms.Form
	{
		/// <summary>
		/// Required designer variable.
		/// </summary>
		private System.ComponentModel.Container components = null;
		public Form1()
		{
			// Required for Windows Form Designer support
			InitializeComponent();
			// TODO: Add any constructor code after 
			// InitializeComponent call
		}
		/// <summary>
		/// Clean up any resources being used.
		/// </summary>
		protected override void Dispose( bool disposing )
		{
			if( disposing )
			{
				if (components != null)
				{
					components.Dispose();
				}
			}
			base.Dispose( disposing );
		}
		#region Windows Form Designer generated code
		/// <summary>
		/// Required method for Designer support - do not modify 
		/// the contents of this method with the code editor.
		/// </summary>
		private void InitializeComponent()
		{
			this.components = new 
				System.ComponentModel.Container();
			this.Size = new System.Drawing.Size(300,300);
			this.Text = "Form1";
		}
		#endregion
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main()
		{
			Application.Run(new Form1());
		}
	}
}

Начну с того, что теперь пространству имен предшествует 6 предложений using; это означает, что используются не менее 6-ти классов, находящихся в разных пространствах имен библиотеки FCL. Одним из таких используемых классов является класс Form из глубоко вложенного пространства имен System.Windows.Forms. Построенный по умолчанию класс Form1 является наследником класса Form и автоматически наследует его функциональность - свойства, методы, события. При создании объекта этого класса, характеризующего форму, одновременно Visual Studio создает визуальный образ объекта - окно, которое можно заселять элементами управления. В режиме проектирования эти операции можно выполнять вручную, при этом автоматически происходит изменение программного кода класса. Появление в проектe формы, открывающейся по умолчанию при запуске проектa, означает переход к визуальному, управляемому событиями программированию. Сегодня такой стиль является общепризнанным, а стиль консольного приложения следует считать анахронизмом, правда, весьма полезным при изучении свойств языка.

В класс Form1 встроено закрытое ( private ) свойство - объект components класса Container. В классе есть конструктор, вызывающий закрытый метод класса InitializeComponent. В классе есть деструктор, освобождающий занятые ресурсы, которые могут появляться при добавлении элементов в контейнер components. Наконец, в классе есть точка входа - процедура Main с непустым телом.

Начало начал - точка "большого взрыва"

Основной операцией, инициирующей вычисления в объектно-ориентированных приложениях, является вызов метода F некоторого класса x, имеющий вид:

x.F(arg1, arg2, ..., argN);

В этом вызове x называется целью вызова, и здесь возможны три ситуации:

Но как появляются объекты? Как они становятся текущими? Как реализуется самый первый вызов метода, другими словами, кто и где вызывает точку входа - метод Main? С чего все начинается?

Когда CLR получает сборку для выполнения, то в решении, входящем в сборку, отмечен стартовый проект, содержащий класс с точкой входа - статическим методом (процедурой) Main. Некоторый объект исполнительной среды CLR и вызывает этот метод, так что первоначальный вызов метода осуществляется извне приложения. Это и есть точка "большого взрыва" - начало зарождения мира объектов и объектных вычислений. Дальнейший сценарий зависит от содержимого точки входа. Как правило, в ней создаются один или несколько объектов, а затем вызываются методы и/или обработчики событий, происходящих с созданными объектами. В этих методах и обработчиках событий могут создаваться новые объекты, вызываться новые методы и новые обработчики. Так, начиная с одной точки, разворачивается целый мир объектов приложения.

Выполнение проекта по умолчанию после "большого взрыва"

Давайте посмотрим, что происходит в проектe, создаваемом по умолчанию, когда произошел "большой взрыв", вселенная создана и процедура Main начала работать. Процедура Main содержит всего одну строчку:

Application.Run(new Form1());

Прокомментируем этот квалифицированный вызов. Целью здесь является класс Application из пространства имен System.Windows.Forms. Класс вызывает статический метод Run, которому в качестве фактического аргумента передается объектное выражение new Form1(). При вычислении этого выражения создается первый объект - экземпляр класса Form1. Этот объект становится текущим. Для создания объекта вызывается конструктор класса. В процессе работы конструктора осуществляется неквалифицированный вызов метода InitializeComponent(). Целью этого вызова является текущий объект - уже созданный объект класса Form1. Ни в конструкторе, ни в вызванном методе новые объекты не создаются. По завершении работы конструктора объект класса Form1 передается методу Run в качестве аргумента.

Метод Run класса Application - это знаменитый метод. Во-первых, он открывает форму - видимый образ объекта класса Form1, с которой теперь может работать пользователь. Но главная его работа состоит в том, что он создает настоящее Windows-приложение, запуская цикл обработки сообщений о происходящих событиях. Поступающие сообщения обрабатываются операционной системой согласно очереди и приоритетам, вызывая обработчики соответствующих событий. Поскольку наша форма по умолчанию не заселена никакими элементами управления, то поступающих сообщений немного. Все, что может делать пользователь с формой, так это перетаскивать ее по экрану, сворачивать и изменять размеры. Конечно, он может еще закрыть форму. Это приведет к завершению цикла обработки сообщений, к завершению работы метода Run, к завершению работы метода Main, к завершению работы приложения.

Проект WindowsHello

Давайте расширим приложение по умолчанию до традиционного приветствия в Windows-стиле, добавив окошки для ввода и вывода информации. Как уже говорилось, при создании Windows-приложения по умолчанию создается не только объект класса Form1 - потомка класса Form, но и его видимый образ - форма, с которой можно работать в режиме проектирования, населяя ее элементами управления. Добавим в форму следующие элементы управления:

На рис. 2.4 показано, как выглядит наша форма в результате проектирования.

Я не буду далее столь же подробно описывать действия по проектированию интерфейса форм, полагая, что все это интуитивно ясно и большинству хорошо знакомо. Более важно понимать то, что все действия по проектированию интерфейса незамедлительно транслируются в программный код, добавляемый в класс Form1. Мы вручную сажаем элемент управления на форму, тут же в классе появляется закрытое свойство, задающее этот элемент, а в процедуре InitailizeComponent выполняется его инициализация. Мы меняем некоторое свойство элемента управления, это незамедлительно находит отражение в программном коде указанной процедуры.

Вот как выглядит автоматически добавленное в класс описание элементов управления:

private System.Windows.Forms.Label label1;
	private System.Windows.Forms.TextBox textBox1;
	private System.Windows.Forms.Button button1;
	private System.Windows.Forms.TextBox textBox2;
	private System.Windows.Forms.Label label2;

А вот фрагмент текста процедуры InitailizeComponent:

#region Windows Form Designer generated code
	/// <summary>
	/// Required method for Designer support - do not
	/// modify the contents of this method with the code 
	/// editor.
	/// </summary>
	private void InitializeComponent()
	{
		this.label1 = new System.Windows.Forms.Label();
		this.textBox1 = new System.Windows.Forms.TextBox();
		this.button1 = new System.Windows.Forms.Button();
		this.textBox2 = new System.Windows.Forms.TextBox();
		this.label2 = new System.Windows.Forms.Label();
		this.SuspendLayout();
		// label1
		this.label1.Location = new System.Drawing.Point(24, 40);
		this.label1.Name = "label1";
		this.label1.Size = new System.Drawing.Size(152, 32);
		this.label1.TabIndex = 0;
		this.label1.Text = "Ваше имя";
		this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
... аналогично задаются описания свойств всех элементов управления ...
... далее задаются свойства самой формы ...
			// Form1
			//
			this.AutoScaleBaseSize = new System.Drawing.Size(6, 15);
			this.ClientSize = new System.Drawing.Size(528, 268);
			this.Controls.AddRange(new 
				System.Windows.Forms.Control[]
				{
					this.textBox2,
					this.label2,
					this.button1,
					this.textBox1,
					this.label1
				});
			this.Name = "Form1";
			this.Text = "Приветствие";
			this.Load += new System.EventHandler(this.Form1_Load);
			this.ResumeLayout(false);
		}
		#endregion

Заметьте, в теге <summary> нас предупреждают, что этот метод требуется специальному инструментарию - Дизайнеру формы - и он не предназначен для редактирования пользователем; добавление и удаление кода этого метода производится автоматически. Обращаю внимание, что после заполнения свойств элементов управления заключительным шагом является их добавление в коллекцию Controls, хранящую все элементы управления. Здесь используется метод AddRange, позволяющий добавить в коллекцию одним махом целый массив элементов управления. Метод Add позволяет добавлять в коллекцию по одному элементу. Позже нам придется добавлять элементы управления в форму программно, динамически изменяя интерфейс формы. Для этого мы будем выполнять те же операции: объявить элемент управления, создать его, используя конструкцию new, задать нужные свойства и добавить в коллекцию Controls.

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

private void button1_Click(object sender,System.EventArgs e)
	{

	}

Нам остается добавить свой текст. Я добавил следующие строки:

string temp;
    	temp = textBox1.Text;
		if( temp == "")
			textBox2.Text = "Здравствуй, мир!";
		else
			textBox2.Text = "Здравствуй, " + temp + " !";

И вот как это работает.

На этом мы закончим первое знакомство с проектaми на C# и в последующих лекциях приступим к систематическому изучению возможностей языка.