Задания к выполнению
Создать приложение позволяющее решать методом Ньютона и методом половинного деления нелинейные уравнения(согласно варианту), а также выполнять графическое построение этих графиков с помощью элемента управления Chart. При выполнении задания обязательно пользоваться делегатами. Создать справочную систему.
|
№ варианта |
Уравнения |
№ вари-анта |
Уравнения |
|
1. |
1) x×lg(x+3) = 1; 2) 2x^3+x^2 +2x+3=0 |
2. |
1) sin(x-p/3)-2x =0; 2) x^3 – 4x - 1 = 0 |
|
3. |
1) (x-1)×lg(x+2) = 1; 2) 2x^3-x^2 -2x+3=0 |
4. |
1) sin(x+1) = 2(x+3)3; 2) x^3-x^2+4x-1=0 |
|
5. |
1) x×cos(x-2) = 1; 2) x^3+3x^2+9x-8=0 |
6. |
1) 1-x cos(x) =0; 2) x^3+2x^2-3x-2=0 |
|
7. |
1) x×lg(x+2) – 1=0; 2) x^3-x^2 +2x-4=0 |
8. |
1) x×lg(x-3) + 12=0; 2) x^3+2x^2 +x+1=0 |
|
9. |
1) x^2-2cos(x) – 1 =0; 2) x^3-x^2+2^x+1=0 |
10. |
1) cos(x) –(x+1) 3 = 0; 2) x^3+2x^2+3x+1=0 |
|
11. |
1) ex+2x – 4=0; 2) x^3+3x^2 –2x+1=0 |
12. |
1) lg(x) – 2x + 1=0; 2) 2x^3-x^2 –x+2=0 |
|
13. |
1) lg(x) – x + 2=0; 2) 2x^3+x^2 –x-2=0 |
14. |
1) e-x-2x +1=0; 2) 2x^3-x^2 –x+1=0 |
|
15. |
1) sin(x-1) = 2x3; 2) x^3-4x^2+x-1=0 | ||
Лабораторная работа №5
Работа с графикой
Цель работы: получить навыки работы с графикой и изображениями наVisualC#.
Теоритические сведения
GDIиGDI+
Графический интерфейс приложений C#, как и других приложений, предназначенных для работы в рамках Microsoft .NET Framework, состоит из набора классов. Эти классы инкапсулируют поведение объектов и инструментов, предназначенных для рисования. Однако прежде чем приступить к описанию этих классов, нам необходимо познакомиться с основными понятиями интерфейса графических устройств.
При создании ОС Microsoft Windows компания Microsoft избавила программистов от необходимости учитывать аппаратные особенности видеоадаптеров, переложив эту задачу на драйверы видеоадаптеров. Эти драйверы создаются разработчиками видеоадаптеров и наилучшим образом реализуют возможности аппаратуры. Что же касается приложений, то для них в составе ОС Microsoft Windows был предусмотрен набор системных функций, реализующих интерфейс графических устройств (Graphics Device Interface, GDI). Интерфейс графических устройств GDI, как это можно предположить из названия, предназначен для взаимодействия приложений Microsoft Windows с графическими устройствами, такими как видеоадаптер, принтер или плоттер. Когда приложения обращаются к GDI для выполнения операции вывода графического изображения, они работают не с реальными (физическими) устройствами вывода, а с логическими устройствами. Приложения Microsoft Windows не определяют тип видеоадаптера (EGA, VGA, SVGA и т.п.), а работают с логическим видеоадаптером, имеющим феноменальные характеристики: способность отображать практически любой цвет, имеющим огромное разрешение и т. д.
С точки зрения приложений, интерфейс GDI состоит из контекста отображения и инструментов, предназначенных для рисования. Контекст отображения можно сравнить с листом бумаги, на котором приложение рисует то или иное графическое изображение, а также пишет текст. Инструменты для рисования — это перья, кисти (а также шрифты и даже целые графические изображения), с помощью которых создается изображение. Кроме контекста отображения и инструментов для рисования, приложениям доступны десятки функций программного интерфейса GDI, предназначенные для работы с контекстом отображения и инструментами. Что же касается приложений Microsoft .NET Framework, то они реализуют возможности интерфейса GDI+ с помощью набора соответствующих классов и интерфейсов. В терминах ОС Microsoft Windows контекст отображения (display context) представляет собой структуру данных, описывающую устройство отображения. В этой структуре хранятся различные характеристики устройства и набор инструментов для рисования, выбранный по умолчанию. Приложение может выбирать в контекст отображения различные инструменты (например, перья различной толщины и цвета, с различными «наконечниками»). Поэтому если Вам надо нарисовать линию красного или зеленого цвета, перед выполнением операции следует выбрать в контекст отображения соответствующее перо.
Примечание: Функции рисования GDI, входящие в программный интерфейс Win32 API, не имеют параметров, указывающих цвет или толщину линии. Такие параметры хранятся в контексте отображения.
Приложение может создать контекст отображения не только для окна приложения, но и для любого другого графического устройства вывода, например, для принтера. В последнем случае оно может рисовать на принтере различные изображения, используя те же функции, что и для рисования в окне приложения.
Концепция графического интерфейса GDI+ несколько отличается от концепции «классического» графического интерфейса GDI, с которым привыкли иметь дело разработчики приложений Microsoft Windows. Прежде всего, это касается класса Graphics, реализующего в себе как свойства контекста отображения, так и инструменты, предназначенные для рисования в этом контексте. Для того чтобы приложение могло что-нибудь нарисовать в окне, оно должно, прежде всего, получить или создать для этого окна объект класса Graphics. Далее, пользуясь свойствами и методами этого объекта, приложение может рисовать в окне различные фигуры или текстовые строки.
Класс Graphics
Прежде чем мы сможем что-нибудь нарисовать в окне нашего приложения, мы должны получить для этого окна объект класса Graphics. Каждое окно имеет свой идентификатор (handle). Зная идентификатор окна, можно легко получить связанный с этим окном контекст отображения. Приложения Microsoft .NET Framework могут получить идентификатор формы или любого другого элемента управления при помощи свойства Handle. В частности, наше приложение получает идентификатор окна формы Form1 с помощью свойства this.Handle.
Зная идентификатор окна, с помощью метода Graphics.FromHwnd нетрудно получить нужный нам объект класса Graphics.
Graphics g = Graphics.FromHwnd(this.Handle);
Для того чтобы рисовать, художнику нужна кисть. Программист, создающий приложение GDI+, тоже нуждается в инструментах для рисования. Мы создадим кисть как объект класса SolidBrush:
SolidBrush redBrush = new SolidBrush(Color.Red);
С помощью этой кисти можно рисовать замкнутые геометрические фигуры, закрашенные заданным цветом. Через единственный параметр мы передаем конструктору класса SolidBrush цвет кисти Color.Red. Таким образом, мы будем рисовать кистью красного цвета.
Проще всего объяснить назначение и принципы использования класса Graphics на конкретном примере. Давайте создадим приложение GraphicsApp, в окне которого можно рисовать мышью. Создайте проект приложения GraphicsApp при помощи мастера проектов, а затем установите белый цвет фона для формы этого приложения Form1. Изменить цвет фона можно, отредактировав свойство BackColor.
Нам нужно сделать так, чтобы пользователь мог рисовать в окне при нажатой левой клавише мыши. Поэтому нам придется отслеживать в нашем приложении события, связанные с нажатием и отжатием этой клавиши. Кроме того, необходимо отслеживать перемещения курсора мыши. Текущее состояние мыши будет храниться в поле doDraw типа bool. Вам нужно добавить это поле в класс Form1, проинициализировав его следующим образом:
bool doDraw = false;
Создайте два обработчика событий MouseDown и MouseUp для формы Form1:
private void Form1_MouseDown(object sender,
System.Windows.Forms.MouseEventArgs e)
{
doDraw = true;
}
private void Form1_MouseUp(object sender,
System.Windows.Forms.MouseEventArgs e)
{
doDraw = false;
}
Чтобы создать эти обработчики событий, откройте окно визуального проектирования формы, а затем на вкладке событий щелкните дважды события MouseDown и MouseUp. Когда пользователь нажимает левую клавишу мыши, управление передается обработчику событий Form1_MouseDown. Этот обработчик записывает в поле doDraw значение true, отмечая таким способом тот факт, что пользователь приступил к процедуре рисования. Нарисовав линию, пользователь отпускает левую клавишу мыши. При этом управление передается обработчику событий Form1_MouseUp, записывающему в поле doDraw значение false. Это означает завершение процедуры рисования. Для того чтобы наделить наше приложение возможностью рисования, добавьте обработчик события Form1_MouseMove:
private void Form1_MouseMove(object sender,
System.Windows.Forms.MouseEventArgs e)
{
if(doDraw)
{
Graphics g = Graphics.FromHwnd(this.Handle); \\ Создание объекта Graphics
SolidBrush redBrush = new SolidBrush(Color.Red); \\ Создание кисти
g.FillRectangle(redBrush, e.X, e.Y, 1, 1); \\ Рисование точки (прямоугольник 1х1 п.)
}
}
Этот обработчик будет получать управление при всяком перемещении курсора мыши, причем свойства e.X и e.Y будут содержать новые координаты курсора. Мы воспользуемся этим обстоятельством, нарисовав в месте нового расположения курсора квадрат, с шириной стороны в один пиксел. На экране такой квадрат будет выглядеть как точка. Рисование должно выполняться только в том случае, если в поле doDraw хранится значение true.
В классе Graphics имеется множество различных методов, предназначенных для рисования самых разных геометрических фигур, таких как линии, прямоугольники, овалы и окружности, многоугольники, кривые Безье и т.д.
Но вот чего в этом классе нет, так это метода, с помощью которого можно было бы нарисовать одну единственную точку. Заметим, однако, что вместо точки мы можем нарисовать закрашенный квадрат с шириной стороны, равным 1 пикселу. Эта задача выполняется при помощи метода FillRectangle:
g.FillRectangle(redBrush, e.X, e.Y, 1, 1);
Обратите внимание на то, что метод FillRectangle вызывается для объекта g класса Graphics, созданного нами для окна формы Form1. Поэтому квадрат будет нарисован в окне этой формы.
В качестве первого параметра методу FillRectangle передается кисть redBrush, которую нужно использовать для рисования. Кисть нужна и для других методов класса Graphics, предназначенных для рисования геометрических фигур.
Второй и третий параметры метода FillRectangle задают координаты, в которых будет нарисован квадрат. И, наконец, последние два параметра метода FillRectangle задают, соответственно, ширину и высоту прямоугольника.
Начало системы координат при этом находится в левом верхнем углу окна, для которого был получен объект Graphics. В нашем случае это левый верхний угол внутренней области окна формы Form1. Ось X в этой системе координат, принятой по умолчанию, направлена слева направо, а ось Y — сверху вниз. В процессе перемещения мыши, при нажатой левой клавише, происходит многократный вызов обработчика событий Form1_MouseMove. Как результат, в окне нашего приложения появляется рисунок, состоящий из отдельных точек
Рис 5.1 Система координат по умолчанию
В приложении GraphicsApp мы получили контекст отображения (в виде объекта класса Graphics) для всего окна формы Form1. Однако формы реальных приложений создаются с использованием различных элементов управления. Что же касается непосредственного рисования, то оно чаще всего выполняется не во всем окне приложения, а только в его некоторой части.
Рис 5.2 Рисование в окне элемента управления Panel
С помощью мыши пользователь может рисовать внутри окна панели Panel, однако остальная часть главного окна приложения для рисования недоступна. Попробуем сделать это на практике:
Добавьте на форму элемент управления Panel
Далее создайте в классе Form1 поле doDraw и обработчики событий, создаваемых мышью. Обработчики должны создаваться для объекта Panel, а не для формы Form1, как это было в предыдущем приложении:
bool doDraw = false;
private void panel1_MouseDown(object sender,
System.Windows.Forms.MouseEventArgs e)
{
doDraw = true;
}
private void panel1_MouseUp(object sender,
System.Windows.Forms.MouseEventArgs e)
{
doDraw = false;
}
private void panel1_MouseMove(object sender,
System.Windows.Forms.MouseEventArgs e)
{
if(doDraw)
{
Graphics g = Graphics.FromHwnd(panel1.Handle);
SolidBrush redBrush = new SolidBrush(Color.Red);
g.FillEllipse(redBrush,e.X, e.Y, 10, 10);
}
}
Этот код почти аналогичен коду, который мы использовали в предыдущем приложении GraphicsApp, однако в обработчиках событий имеются важные отличия. Прежде всего, мы создали обработчики событий для панели panel1, а не для формы Form1. В результате они будут получать управление только в том случае, когда пользователь щелкает левую кнопку мыши и перемещает ее курсор внутри панели.
Второе важное отличие в методе panel1_MouseMove. Этот метод получает контекст отображения не для всего окна формы, а только для окна панели panel1. С этой целью он передает методу Graphics.FromHwnd идентификатор окна панели, извлеченный из свойства panel1.Handle:
Graphics g = Graphics.FromHwnd(panel1.Handle);
В результате последующая операция рисования будет выполнена в системе координат, связанной с окном панели, а не с окном формы.
Третье отличие от предыдущего приложения не соль существенно. Вместо метода FillRectangle для рисования мы применили метод FillEllipse:
g.FillEllipse(redBrush,e.X, e.Y, 10, 10);
Назначение параметров метода FillEllipse, предназначенного для рисования закрашенных эллипсов, аналогично назначению параметров метода FillRectangle. При этом два последних параметра задают, соответственно, ширину и высоту прямоугольной области, занимаемой эллипсом. Проверяя работу приложения GraphicsApp1, описанного в предыдущем разделе этой главы, Вы наверняка заметите одну неприятную особенность — при изменении размеров окна часть нарисованного изображения или все изображение пропадает. Аналогичная неприятность происходит и в том случае, когда окно приложения GraphicsApp1 перекрывается окном другого приложения. В чем здесь проблема? Она в том, что в приложении GraphicsApp1 не реализована техника рисования в окне, применяемая во всех стандартных приложениях Microsoft Windows. По своей логике способ рисования программ Microsoft Windows в корне отличается от способа, к которому привыкли разработчики, создававшие программы для ОС MS-DOS.
Для форм класса System.Windows.Forms предусмотрен удобный объектно-ориентированный способ, позволяющий приложению при необходимости перерисовывать окно формы в любой момент времени. Когда вся клиентская область окна формы или часть этой области требует перерисовки, форме передается событие Paint. Все, что требуется от программиста, это создать обработчик данного события, наполнив его необходимой функциональностью. Для наглядной демонстрации методики обработки события Paint мы подготовим простейшее приложение PaintApp, рисующее в своем окне текстовую строку и геометрические фигуры:
Выделите в окне дизайнера форму Form1 и откройте вкладку событий для этой формы, отыщите на вкладке строку события Paint и щелкните ее дважды левой клавишей мыши. В результате будет создан обработчик события Form1_Paint. Этот обработчик будет получать управление всякий раз, когда по тем или иным причинам возникнет необходимость в перерисовке содержимого окна нашего приложения.
Вот в каком виде будет создан обработчик события Paint:
private void Form1_Paint(object sender,
System.Windows.Forms.PaintEventArgs e)
{
}
Обработчику Form1_Paint передаются два параметра.
Через первый параметр передается ссылка на объект, вызвавший событие. В нашем случае это будет ссылка на форму Form1.Что же касается второго параметра, то через него передается ссылка на объект класса PaintEventArgs. Этот объект имеет два свойства, доступных только для чтения — Graphics и ClipRectangle.
Класс Graphics Вам уже знаком — он представляет собой контекст отображения, необходимый для рисования текста и геометрических фигур. Мы работали с этим классом в приложениях GraphicsApp и GraphicsApp1, рассмотренных ранее в этой главе. Обработчик события Paint получает контекст отображения через свои параметры, поэтому программисту не нужно определять его специальным образом.Через свойство ClipRectangle передаются границы области, которую должен перерисовать обработчик события Paint. Эти границы передаются в виде объекта класса Rectangle. Свойства этого класса Left, Right, Width и Height, наряду с другими свойствами, позволяют определить расположение и размеры области.Заметим, что в простейших случаях обработчик события Paint может игнорировать свойство ClipRectangle, перерисовывая содержимое окна полностью. Однако процесс перерисовки содержимого окна можно заметно ускорить, если перерисовывать не все окно, а только область, описанную свойством ClipRectangle. Ускорение будет особенно заметным, если в окне нарисовано много текста и геометрических фигур.
Итак, давайте отредактируем исходный текст приложения PaintApp таким образом, чтобы в его окне была нарисована текстовая строка, прямоугольник и эллипс. Прежде всего, создайте в классе Form1 поле text класса string, в котором будет храниться отображаемая текстовая строка:
public string text;
Добавьте также в конструктор класса Form1 строку инициализации упомянутого поляtext:
public Form1()
{
InitializeComponent();
text = "Обработка события Paint";
}
И, наконец, измените исходный текст обработчика события Form1_Paintследующим образом:
private void Form1_Paint(object sender,
System.Windows.Forms.PaintEventArgs e)
{
Graphics g = e.Graphics;
g.Clear(Color.White);
g.DrawString(text, new Font("Helvetica", 15),
Brushes.Black, 0, 0);
g.DrawRectangle(new Pen(Brushes.Black,2), 10, 30, 200, 100);
g.DrawEllipse(new Pen(Brushes.Black,2), 150, 120, 100, 130);
}
Здесь в теле обработчика Form1_Paint мы определили локальную переменную g класса Graphics, предназначенную для хранения контекста отображения. Эта переменная инициализируется при помощи значения, полученного из свойства Graphics первого параметра обработчика Form1_Paint:
Graphics g = e.Graphics;
Получив контекст отображения, наш обработчик события Paint может рисовать в соответствующем окне все, что угодно.
Вначале мы закрашиваем окно белым цветом, вызывая для этого метод Clear, определенный в классе Graphics:
g.Clear(Color.White);
Таким способом мы можем закрасить фон, цвет которого задан для формы в свойстве BackColor.
Далее мы вызываем методы DrawString, DrawRectangle и DrawEllipse, также определенные в классе Graphics:
g.DrawString(text, new Font("Helvetica", 15), Brushes.Black, 0, 0);
g.DrawRectangle(new Pen(Brushes.Black,2), 10, 30, 200, 100);
g.DrawEllipse(new Pen(Brushes.Black,2), 150, 120, 100, 130);
Первый из них рисует текстовую строку в верхней части окна, а два других — прямоугольник и эллипс, соответственно.
Рис 5.3 Окно приложения PaintApp
Запустив приложение PaintApp, Вы сможете убедиться в том, что нарисованное изображение не пропадает при изменении размеров окна. Оно заново перерисовывается и в том случае, если окно приложения PaintApp оказывается временно перекрыто окном другого приложения.
Методы и свойства класса Graphics
Имена большого количества методов, определенных в классе Graphics, начинается с префиксаDraw* иFill*. Первые из них предназначены для рисования текста, линий и не закрашенных фигур (таких, например, как прямоугольные рамки), а вторые — для рисования закрашенных геометрических фигур. Мы рассмотрим применение только самых важных из этих методов, а полную информациюВы найдете в документации (MSDN).
Линия
Метод DrawLine, как это нетрудно догадаться из его названия, рисует линию, соединяющую две точки с заданными координатами. Ниже мы привели прототипы различных перегруженных версий этого метода:
public void DrawLine(Pen, Point, Point);
public void DrawLine(Pen, PointF PointF;
public void DrawLine(Pen, int, int, int, int);
public void DrawLine(Pen, float, float, float, float);
Первый параметр задает инструмент для рисования линии — перо. Перья создаются как объекты класса Pen, например:
Pen p = new Pen(Brushes.Black,2);
Здесь мы создали черное перо толщиной 2 пиксела. Создавая перо, Вы можете выбрать его цвет, толщину и тип линии, а также другие атрибуты.
Вызвав один раз метод DrawLines, можно нарисовать сразу несколько прямых линий, соединенных между собой. Иными словами, методDrawLinesпозволяет соединить между собой несколько точек. Координаты этих точек по горизонтальной и вертикальной оси передаются методу через массив классаPointилиPointF:
public void DrawLines(Pen, Point[]);
public void DrawLines(Pen, PointF[]);
Прямоугольник
Метод DrawRectangle позволяет рисовать прямоугольники, заданные координатой верхнего левого угла, а также шириной и высотой. В библиотеке классов .NET Frameworks имеется три перегруженных варианта этого метода:
public void DrawRectangle(Pen, Rectangle);
public void DrawRectangle(Pen, int, int, int, int);
public void DrawRectangle(Pen, float, float, float, float);
В качестве первого параметра этим методам передается перо класса Pen. Остальные параметры задают расположение и размеры прямоугольника.
За один вызов метода DrawRectangles программа может нарисовать сразу несколько прямоугольников. Существует два перегруженных варианта этого метода:
public void DrawRectangles(Pen, Rectangle[]);
public void DrawRectangles(Pen, RectangleF[]);
Многоугольник
Метод DrawPolygon поможет Вам в тех случаях, когда нужно нарисовать многоугольник, заданный своими вершинами. Предусмотрено два варианта этого метода:
public void DrawPolygon(Pen, Point[]);
public void DrawPolygon(Pen, PointF[]);
В первом случае методу DrawPolygon через второй параметр передается массив точек класса Point, в котором координаты точек заданы целыми числами, а во втором — массив класса PointF, где координаты соединяемых точек задаются в виде числе с плавающей десятичной точкой.
Эллипс
Метод DrawEllipse рисует эллипс, вписанный в прямоугольную область, расположение и размеры которой передаются ему в качестве параметров. Предусмотрено четыре перегруженных варианта метода DrawEllipse:
public void DrawEllipse(Pen, Rectangle);
public void DrawEllipse(Pen, RectangleF);
public void DrawEllipse(Pen, int, int, int, int);
public void DrawEllipse(Pen, float, float, float, float);
Как видите, эти методы отличаются только способом, при помощи которого описывается расположение и размеры прямоугольной области, в которую вписан эллипс. Вы можете задавать расположение и размеры этой области в виде рассмотренных ранее объектов класса Rectangle, RectangleF, а также в виде целых чисел или числе с плавающей десятичной точкой.
Замкнутый сегмент эллипса
Для рисования замкнутого сегмента эллипса (pie) Вы можете воспользоваться методом DrawPie. Имеется 4 перегруженных варианта этого метода:
public void DrawPie(Pen, Rectangle, float, float);
public void DrawPie(Pen, RectangleF, float, float);
public void DrawPie(Pen, int, int, int, int, int, int);
public void DrawPie(Pen, float, float, float, float, float, float);
В качестве первого параметра методу нужно передать перо для рисования. Последние два параметра определяют углы, ограничивающие сегмент эллипса. Эти углы используются таким же образом, как и при рисовании незамкнутого сегмента эллипса методом DrawArc, рассмотренным выше. Остальные параметра задают расположение и размеры прямоугольника, в который вписывается сегмент эллипса.
Изображения
Bitmap
Bitmapинкапсулирует точечный рисунок GDI+, состоящий из данных пикселей графического изображения и атрибутов рисунка. Объект Bitmap используется для работы с изображениями, определяемыми данными пикселей. Точечный рисунок содержит данные элементов отображения (пикселей) и атрибуты графического изображения. Существует множество стандартных форматов сохранения точечных рисунков в файл. Класс GDI+ поддерживает следующие форматы файлов: BMP, GIF, EXIF, JPG, PNG и TIFF. Можно создать изображения из файлов, потоков и других источников, используя один из конструкторов Bitmap, и сохранить их в поток или файловую систему с помощью метода Save. Изображения отрисовываются на экране или в памяти с помощью метода DrawImage объекта Graphics. В следующем примере кода демонстрируется создание нового экземпляра класса Bitmap из файла с помощью методов GetPixel и SetPixel для перекрашивания изображения. В примере также используются свойства PixelFormat, Width и Height.
Bitmap image1;
private void Button1_Click(System.Object sender, System.EventArgs e)
{
try
{
// Retrieve the image.
image1 = new Bitmap(@"C:\Documents and Settings\All Users\"
+ @"Documents\My Music\music.bmp", true);
int x, y;
// Loop through the images pixels to reset color.
for(x=0; x<image1.Width; x++)
{
for(y=0; y<image1.Height; y++)
{
Color pixelColor = image1.GetPixel(x, y);
Color newColor = Color.FromArgb(pixelColor.R, 0, 0);
image1.SetPixel(x, y, newColor);
}
}
// Set the PictureBox to display the image.
PictureBox1.Image = image1;
// Display the pixel format in Label1.
Label1.Text = "Pixel format: "+image1.PixelFormat.ToString();
}
catch(ArgumentException)
{
MessageBox.Show("There was an error." +
"Check the path to the image file.");
}
}
PictrureBox
Обычно PictureBox используется для отображения графических метафайлов из растрового изображения значка, для файла, JPEG, GIF и PNG.
Установка Image свойство Image необходимо указать либо во время разработки или во время выполнения. Можно также определить изображение с помощью установки свойства ImageLocation и загрузить изображение синхронно с помощью метода Load или асинхронно с помощью метода LoadAsync.
Примечание: Если необходимо использовать одно и то же изображение в разных элементах управления PictureBox, создайте копию изображения для каждого PictureBox. Попытка получения доступа к одному и тому же изображению из нескольких элементов управления приведёт к возникновению исключения.
SizeMode свойство, устанавливаются значения в PictureBoxSizeMode перечисление, элементы управления отсечение и размещение образа в области отображения. Можно изменить размер области отображения во время выполнения с помощью свойства ClientSize.
По умолчанию элемент управления PictureBox отображается без границ. Можно предоставить стандартную или трехмерную границу используя свойство BorderStyle для различения окна изображения от остальной части формы, даже если она не содержит изображения. PictureBox не является выделяемым элементом управления. Это означает, что он не может получить фокус ввода. Например:
private Bitmap MyImage ;
public void ShowMyImage(String fileToDisplay, int xSize, int ySize)
{
// Sets up an image object to be displayed.
if (MyImage != null)
{
MyImage.Dispose();
}
// Stretches the image to fit the pictureBox.
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage ;
MyImage = new Bitmap(fileToDisplay);
pictureBox1.ClientSize = new Size(xSize, ySize);
pictureBox1.Image = (Image) MyImage ;
}
DataGridView
Элемент управление DataGridViewпредставляет собой настраиваемую таблицу для отображения данных. КлассDataGridViewподдерживает настройку ячеек, строк, столбцов и платформы с помощью свойстваDefaultCellStyle, какColumnHeadersDefaultCellStyle,CellBorderStyleиGridColor. Элемент управления DataGridView можно использовать для отображения данных как с базовым источником данных, так и без. Без определения источника данных можно создать столбцы и строки, которые содержат данные и добавьте их непосредственно в DataGridView с помощью свойства Rows и Columns. Можно также использовать коллекцию Rows для доступа к объектам DataGridViewRow, а свойство DataGridViewRow.Cells для чтения или записи значения ячеек напрямую. Индексатор Item также предоставляет прямой доступ к ячейкам. В качестве альтернативы заполнения элемента управления вручную можно задать свойства DataSource и DataMember для привязки DataGridView к источнику данных и автоматически заполнить ее данными.
DataGridViewRow.Columns возвращает коллекцию, содержащую все столбцы в элементе управления. С помощью DataGridViewColumnCollection, возвращенного этим свойством, можно добавлять столбцы, чтобы удалить столбцы и получить число столбцов, содержащихся в элементе управления DataGridView.
В случае с несвязанным DataGridViewсхему будущей таблицы с данными можно настроить как через конструктор формы так и через код программы. Чтобы настроить схему через конструктор необходимо выделить элемент управленияDataGridViewи поработать со свойством Columns:
Рис 5.4 Конструктор столбцов
Правка столбцов
Затем нажать кнопку «Добавить»:
Рис 5.5 Окно для добавления столбца
После чего настроить добавленный столбец:
Рис 5.6 Правка столбцов
Пример программного добавления столбцов и строк:
private void InitializeDataGridView()
{
// Создания несвязанного датагрида путем объявления количества столбцов
dataGridView1.ColumnCount = 4;
// Настройка стиля заголовка таблицы
DataGridViewCellStyle columnHeaderStyle = new DataGridViewCellStyle();
columnHeaderStyle.BackColor = Color.Beige;
columnHeaderStyle.Font = new Font("Verdana", 10, FontStyle.Bold);
dataGridView1.ColumnHeadersDefaultCellStyle = columnHeaderStyle;
// Настройка имен столбцов
dataGridView1.Columns[0].Name = "Recipe";
dataGridView1.Columns[1].Name = "Category";
dataGridView1.Columns[2].Name = "Main Ingredients";
dataGridView1.Columns[3].Name = "Rating";
// Создание строк
string[] row1 = new string[] { "Meatloaf", "Main Dish", "ground beef",
"**" };
string[] row2 = new string[] { "Key Lime Pie", "Dessert",
"lime juice, evaporated milk", "****" };
string[] row3 = new string[] { "Orange-Salsa Pork Chops", "Main Dish",
"pork chops, salsa, orange juice", "****" };
string[] row4 = new string[] { "Black Bean and Rice Salad", "Salad",
"black beans, brown rice", "****" };
string[] row5 = new string[] { "Chocolate Cheesecake", "Dessert",
"cream cheese", "***" };
string[] row6 = new string[] { "Black Bean Dip", "Appetizer",
"black beans, sour cream", "***" };
object[] rows = new object[] { row1, row2, row3, row4, row5, row6 };
// Добавление строк
foreach (string[] rowArray in rows)
{
dataGridView1.Rows.Add(rowArray);
}
}
DataGridView.Rows возвращает коллекцию, содержащую все строки в элементе управления DataGridView. Можно использовать коллекцию Rows вручную, чтобы заполнить элемент управления DataGridView вместо привязать к источнику данных. В следующем примере показано, как вручную добавить и вставки строк.
dataGridView1.Rows.Add("five", "six", "seven", "eight");
dataGridView1.Rows.Add();
И небольшой пример работы с ячейками напрямую:
for (int i = 0; i < 10; i++)
{
dataGridView1.Rows.Add();
dataGridView1.Rows[i].Cells[0].Value = i.ToString();
}
Здесь добавляется десять строк и первый столбец заполняется числами от 0 до 9.
Для того, чтобы связать DataGridViewнапример с массивом, необходимо вначале разобраться со свойствомDataGridView.DataSource.
DataSourceвозвращает или задает источник, данные для которого отображаются в сетке.
Допустимы следующие источники данных:
Элемент DataTable
Элемент DataView
Элемент DataSet
Элемент DataViewManager
любой компонент, реализующий интерфейс IListSource;
любой компонент, реализующий интерфейс IList.
Примечание: чтобы привязать элемент управления DataGridView к строго типизированному массиву объектов, тип объекта должен содержать открытые свойства.
Например, свяжем список с сеткой.
В качестве списка будем использовать BindingList.BindingList<T> обеспечивает универсальную коллекцию, поддерживающую привязку данных. Класс BindingList<T> может использоваться в качестве базового класса для создания двустороннего механизма привязки данных.
Итак, как написано в примечании, нам необходимо создать массив объектов с открытыми свойствами, если мы создадим например экземпляр типа BindingList<float>, добавим пару элементов и свяжем его сDataGridView, то ничего не увидим в сетке, потому что нам необходим объект с открытым свойством, где поле будет играть роль значения, а свойство роль механизма доступа к полю, например:
public class item
{
// Контсруктор с параметром
public item(float a)
{
fval = a;
}
// Контсруктор по умолчанию
public item()
{
fval = 0;
}
// Хранит значение
private float fval;
// Открытое поле дает доступ к значению
public float val
{
get { return fval; }
set { fval = value; }
}
}
Затем уже создадим список этих объектов и свяжем их с DataGridView:
bl = new BindingList<item>();
dataGridView1.DataSource = bl;
Теперь при редактировании сетки будет редактироваться и список, а при редактировании списка будет редактироваться сетка, то есть обеспечивается двусторонний механизм связи.
Рис. 5.7 Двусторонняя связь