Адресная книга на C# (Windows Forms): Курсовая работа в Visual Studio 2013

В современном мире, где объём информации постоянно растёт, эффективное управление контактами становится не просто удобством, но и необходимостью. От студентов, хранящих контакты одногруппников и преподавателей, до профессионалов, управляющих обширными сетями бизнес-партнёров – каждому требуется надёжный и интуитивно понятный инструмент. Проект «Адресная книга» в рамках курсовой работы по программированию представляет собой уникальную возможность не только решить эту актуальную проблему, но и освоить фундаментальные принципы разработки настольных приложений.

Это руководство ставит своей целью не просто демонстрацию технических решений, но и формирование глубокого понимания всего жизненного цикла разработки программного обеспечения: от концептуального проектирования до тестирования и документирования. Оно станет незаменимым помощником для студентов технических специальностей, позволяя им шаг за шагом создать полноценное приложение «Адресная книга» на платформе Windows Forms с использованием языка C# и интегрированной среды разработки Visual Studio 2013. Мы подробно рассмотрим архитектурные подходы, принципы объектно-ориентированного программирования, методы постоянного хранения данных (от локальных баз данных до файловых форматов), а также реализацию дополнительных, но крайне полезных функций, таких как экспорт данных и отправка электронных писем. Особое внимание будет уделено методологиям тестирования и отладки, а также стандартам академического документирования, что позволит представить проект в соответствии с высочайшими требованиями учебного заведения, гарантируя высокий балл.

Теоретические основы: Windows Forms, C# и объектно-ориентированное программирование

Прежде чем приступать к кодированию, необходимо заложить прочный фундамент из теоретических знаний. Разработка настольных приложений на C# в Visual Studio опирается на несколько ключевых концепций, понимание которых критически важно для создания устойчивого и масштабируемого программного продукта, ведь без этого невозможно написать по-настоящему качественный код. Этот раздел призван осветить эти фундаментальные понятия, чтобы читатель мог уверенно ориентироваться в процессе разработки.

Платформа Windows Forms: Назначение и возможности

Платформа Windows Forms представляет собой один из самых распространённых и проверенных временем инструментов для создания разнообразных настольных клиентских приложений, работающих под управлением операционной системы Windows. С момента своего появления Windows Forms зарекомендовала себя как надёжное решение для разработки широкого спектра программ — от простых утилит до сложных корпоративных систем.

Её ключевой особенностью является интеграция с интегрированной средой разработки (IDE) Visual Studio, которая предоставляет разработчикам мощный визуальный конструктор. Эта функция, основанная на принципе «перетаскивания» (drag-and-drop), значительно упрощает процесс создания пользовательского интерфейса. Разработчик может визуально размещать элементы управления (кнопки, текстовые поля, таблицы, списки и т.д.) на форме, настраивать их свойства и обрабатывать события, не углубляясь в ручное написание сложного кода для каждого компонента. Такая парадигма позволяет сосредоточиться на бизнес-логике приложения, а не на рутинных задачах по отрисовке интерфейса. Несмотря на появление более современных фреймворков, таких как WPF, Windows Forms остаётся актуальной и поддерживаемой технологией, особенно в контексте .NET Framework 4.5/4.5.1, которые были основными для Visual Studio 2013.

Язык программирования C#: Ключевые особенности

В центре экосистемы .NET, и, соответственно, разработки Windows Forms приложений, находится язык программирования C# (произносится «Си Шарп»). Это современный, объектно-ориентированный язык, разработанный Microsoft, который объединяет в себе выразительность и мощь C++ с простотой и производительностью Java. C# является ключевым компонентом .NET Framework, предоставляя разработчикам богатый набор функций для создания разнообразных приложений: от веб-сервисов до мобильных и настольных программ.

Основные преимущества C# включают строгую типизацию, сборщик мусора (который автоматически управляет памятью, избавляя разработчика от ручного управления), поддержку LINQ (Language Integrated Query) для упрощения работы с данными, асинхронное программирование (async/await) для создания отзывчивых приложений и обширную стандартную библиотеку. В контексте «Адресной книги» C# позволяет чётко структурировать код, легко манипулировать данными и быстро реализовывать сложные функциональные возможности.

Основы объектно-ориентированного программирования (ООП)

Объектно-ориентированное программирование (ООП) — это парадигма, которая произвела революцию в разработке программного обеспечения, предлагая принципиально новый подход к структурированию кода. Вместо того чтобы рассматривать программу как последовательность инструкций, ООП фокусируется на «объектах» – сущностях, которые инкапсулируют данные (свойства) и поведение (методы). Этот подход значительно улучшает модульность, повторное использование кода и удобство поддержки больших проектов. Для «Адресной книги» применение ООП позволяет создать интуитивно понятную и расширяемую модель данных. Четыре столпа ООП — абстракция, инкапсуляция, наследование и полиморфизм — являются краеугольными камнями в C#.

Инкапсуляция: Сокрытие данных и свойства

Инкапсуляция — это принцип, согласно которому данные объекта и методы, работающие с этими данными, объединяются в единое целое (класс), а детали реализации скрываются от внешнего мира. Это достигается путём объявления полей (переменных) класса как private и предоставления доступа к ним только через публичные методы или свойства (public properties).

Пример применения в «Адресной книге»: Класс Contact может иметь private поля для имени, фамилии, телефона и email. Доступ к этим полям осуществляется через публичные свойства Name, Surname, PhoneNumber, Email. Это позволяет, например, добавить логику валидации внутри свойства (скажем, проверку формата email) перед тем, как новое значение будет присвоено приватному полю.

public class Contact
{
    private string _name; // Приватное поле
    public string Name // Публичное свойство
    {
        get { return _name; }
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException("Имя не может быть пустым.");
            }
            _name = value;
        }
    }

    private string _email;
    public string Email
    {
        get { return _email; }
        set
        {
            // Пример простой валидации
            if (!string.IsNullOrEmpty(value) && !value.Contains("@"))
            {
                throw new ArgumentException("Некорректный формат Email.");
            }
            _email = value;
        }
    }
    // Другие свойства: Surname, PhoneNumber, Address и т.д.
}

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

Наследование: Повторное использование кода для схожих сущностей

Наследование позволяет одному классу (дочернему или производному) расширять функциональность другого класса (родительского или базового). Это мощный механизм для создания иерархий классов, уменьшения дублирования кода и повышения его повторного использования.

Пример применения в «Адресной книге»: Можно определить базовый класс Contact с общими свойствами (имя, фамилия, телефон, email). Затем создать производные классы, такие как PersonalContact (добавляющий поле «день рождения») и BusinessContact (добавляющий поля «компания», «должность»).

public class Contact // Базовый класс
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string PhoneNumber { get; set; }
    public string Email { get; set; }

    public virtual string GetFullName() // Виртуальный метод для полиморфизма
    {
        return $"{FirstName} {LastName}";
    }
}

public class PersonalContact : Contact // Производный класс
{
    public DateTime DateOfBirth { get; set; }
}

public class BusinessContact : Contact // Производный класс
{
    public string Company { get; set; }
    public string JobTitle { get; set; }

    public override string GetFullName() // Переопределение метода для полиморфизма
    {
        return $"{FirstName} {LastName} ({Company})";
    }
}

Полиморфизм: Гибкость в работе с различными типами контактов

Полиморфизм (многообразие форм) позволяет использовать один и тот же интерфейс для различных типов данных. В C# полиморфизм достигается за счёт наследования, перегрузки методов (overloading) и переопределения виртуальных методов (overriding).

Пример применения в «Адресной книге»: Благодаря полиморфизму, мы можем иметь список объектов типа Contact, который фактически будет содержать как PersonalContact, так и BusinessContact. Когда мы вызываем метод GetFullName() для каждого элемента списка, будет вызван соответствующий метод для его конкретного типа.

List<Contact> contacts = new List<Contact>();
contacts.Add(new PersonalContact { FirstName = "Иван", LastName = "Иванов", DateOfBirth = new DateTime(1990, 1, 1) });
contacts.Add(new BusinessContact { FirstName = "Петр", LastName = "Петров", Company = "ООО Рога и Копыта", JobTitle = "Менеджер" });

foreach (var contact in contacts)
{
    Console.WriteLine(contact.GetFullName()); // Вызовет соответствующий GetFullName()
}
// Вывод:
// Иван Иванов
// Петр Петров (ООО Рога и Копыта)

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

Абстракция: Моделирование реальных объектов

Абстракция — это процесс выделения только существенных характеристик объекта и скрытия несущественных деталей реализации. Она позволяет сосредоточиться на «что делает» объект, а не на «как он это делает». В C# абстракция часто реализуется через абстрактные классы и интерфейсы.

Пример применения в «Адресной книге»: Класс Contact сам по себе является абстракцией, представляющей общий концепт контакта, без уточнения, личный он или деловой. Если бы мы добавили интерфейс IContactRepository, он бы абстрагировал детали хранения данных, позволяя приложению работать с контактами независимо от того, хранятся они в базе данных, XML или JSON.

public interface IContactRepository
{
    void AddContact(Contact contact);
    Contact GetContactById(Guid id);
    void UpdateContact(Contact contact);
    void DeleteContact(Guid id);
    IEnumerable<Contact> GetAllContacts();
}

// Конкретная реализация для работы с базой данных
public class SqlContactRepository : IContactRepository
{
    // ... реализация методов для SQL ...
}

// Конкретная реализация для работы с JSON файлами
public class JsonContactRepository : IContactRepository
{
    // ... реализация методов для JSON ...
}

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

Архитектура и проектирование приложения «Адресная книга»

Эффективная архитектура — это фундамент любого успешного программного проекта. Она определяет, как компоненты системы взаимодействуют друг с другом, обеспечивает масштабируемость, удобство поддержки и, в конечном итоге, долговечность приложения. Для «Адресной книги», как и для любой другой академической работы, важно не просто «заставить работать», но и «спроектировать правильно», продемонстрировав понимание принципов программной инженерии. Как же добиться максимальной эффективности и прозрачности в проекте?

Обзор архитектуры Windows Forms приложения

Проект Windows Forms в Visual Studio имеет чёткую иерархическую структуру, которая формируется автоматически при создании нового проекта. Понимание этой структуры является ключом к эффективной разработке и отладке.

Каждый класс формы, который вы создаёте (например, Form1, MainForm, ContactDetailsForm), состоит из двух тесно связанных файлов C#:

Файл самой формы (Form1.cs, MainForm.cs и т.д.): Это основной файл, где разработчик пишет большую часть своего кода. Здесь размещаются обработчики событий (например, нажатие кнопки, изменение текста в поле), конструкторы формы, переопределения методов и вся пользовательская логика, специфичная для данной формы. Это ваш «холст» для взаимодействия с интерфейсом.
Файл дизайнера (Form1.Designer.cs, MainForm.Designer.cs и т.д.): Этот файл генерируется и управляется Visual Studio автоматически при работе с визуальным конструктором. Он содержит декларации переменных-членов для каждого элемента управления (например, TextBox, Button, DataGridView), которые вы перетаскиваете на форму. Самое главное, здесь находится метод InitializeComponent(). Этот метод автоматически вызывается из конструктора вашей формы и отвечает за инициализацию всех элементов управления, установку их свойств (размер, положение, текст, привязки данных) и прикрепление обработчиков событий, заданных в дизайнере. Крайне не рекомендуется вручную изменять код в файле *.Designer.cs, так как эти изменения могут быть перезаписаны Visual Studio.

Точка входа в приложение:
Каждое графическое приложение на Windows Forms начинается с файла Program.cs. Он содержит статический класс Program с методом Main(), который является точкой входа в приложение. Обычно этот метод выполняет следующие действия:

Application.EnableVisualStyles(); – включает стили оформления Windows для элементов управления, делая приложение современным.
Application.SetCompatibleTextRenderingDefault(false); – отключает GDI+ текстовый рендеринг по умолчанию для лучшей совместимости с WPF и другими технологиями.
Application.Run(new MainForm()); – запускает главную форму вашего приложения (в данном случае, MainForm).

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

Принципы многослойной архитектуры для «Адресной книги»

Для курсовой работы по разработке «Адресной книги» рекомендуется использовать многослойную архитектуру. Этот подход позволяет чётко разделить ответственность между различными частями приложения, что повышает его масштабируемость, удобство тестирования и сопровождения. Традиционно выделяют три основных слоя:

Уровень представления (Presentation Layer / UI Layer): Отвечает за взаимодействие с пользователем. В случае Windows Forms это сами формы, элементы управления (кнопки, текстовые поля, DataGridView) и их визуальное отображение. Этот слой собирает пользовательский ввод и отображает результаты операций. Его основная задача — обеспечить удобный и интуитивно понятный интерфейс.
Уровень бизнес-логики (Business Logic Layer / BLL): Содержит основную логику приложения, правила, по которым обрабатываются данные, и операции, специфичные для предметной области. Здесь будут находиться классы, управляющие контактами: добавление, редактирование, удаление, поиск, валидация данных. Этот слой не должен напрямую взаимодействовать с базой данных или пользовательским интерфейсом.
Уровень доступа к данным (Data Access Layer / DAL): Отвечает за взаимодействие с хранилищем данных (база данных, XML-файл, JSON-файл). Этот слой абстрагирует детали хранения, предоставляя бизнес-логике унифицированный интерфейс для выполнения CRUD-операций.

Разделение на слои гарантирует, что изменения в одном слое (например, переход от SQL Server к SQLite) минимально повлияют на другие слои. Это является краеугольным камнем для создания гибкого и легко поддерживаемого приложения.

Проектирование классов сущностей: «Контакт» и «Группа»

В основе нашей «Адресной книги» лежат две ключевые сущности: «Контакт» и «Группа». Их правильное проектирование является первым шагом в создании уровня бизнес-логики.

Класс Contact: Будет представлять отдельную запись в адресной книге. Он должен содержать следующие свойства:
- Id (уникальный идентификатор, например, Guid или int)
- FirstName (имя)
- LastName (фамилия)
- PhoneNumber (номер телефона)
- Email (адрес электронной почты)
- Address (адрес проживания)
- GroupId (идентификатор группы, к которой принадлежит контакт, для связи с классом Group)
- Дополнительные поля: Notes (заметки), DateOfBirth (дата рождения).
Мы можем расширить его, используя принципы наследования, как обсуждалось ранее, создавая PersonalContact и BusinessContact.
Класс Group: Будет представлять категорию контактов (например, «Семья», «Работа», «Друзья»).
- Id (уникальный идентификатор)
- Name (название группы)
- Description (описание группы)

Пример базовых классов сущностей:

public class Contact
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string PhoneNumber { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
    public Guid? GroupId { get; set; } // Nullable Guid для контактов без группы
    public string Notes { get; set; }
    public DateTime? DateOfBirth { get; set; }

    public string FullName => $"{FirstName} {LastName}";
}

public class Group
{
    public Guid Id { get; set; } = Guid.NewGuid();
    public string Name { get; set; }
    public string Description { get; set; }
}

Проектирование пользовательского интерфейса (UI/UX): Макеты форм и элементов управления

Качество пользовательского интерфейса (UI) и удобство взаимодействия (UX) имеют решающее значение для успеха любого приложения. В «Адресной книге» UI должен быть инту��тивно понятным, чтобы пользователь мог легко добавлять, находить, редактировать и удалять контакты и группы.

Основные формы и элементы управления:

Главная форма (MainForm):
- Основное окно приложения.
- Содержит DataGridView для отображения списка контактов. DataGridView позволяет легко сортировать, фильтровать и выбирать контакты.
- Кнопки для базовых операций: «Добавить контакт», «Редактировать контакт», «Удалить контакт», «Добавить группу», «Редактировать группу», «Удалить группу».
- TextBox для поиска контактов.
- ComboBox или ListBox для фильтрации контактов по группам.
- Меню (MenuStrip) для доступа к дополнительным функциям (экспорт, настройки, выход).

Форма добавления/редактирования контакта (ContactDetailsForm):

TextBox для каждого поля контакта (имя, фамилия, телефон, email, адрес, заметки).
DateTimePicker для поля «дата рождения».
ComboBox для выбора группы из списка существующих групп.
Кнопки «Сохранить» и «Отмена».

Пример макета:

----------------------------------------------------
| Contact Details                                  |
| ------------------------------------------------ |
| Имя:      [TextBox_FirstName        ]           |
| Фамилия:  [TextBox_LastName         ]           |
| Телефон:  [TextBox_PhoneNumber      ]           |
| Email:    [TextBox_Email            ]           |
| Адрес:    [TextBox_Address          ]           |
| День рожд.:[DateTimePicker_DateOfBirth]           |
| Группа:   [ComboBox_Group           ]           |
| Заметки:  [TextBox_Notes (Multiline)]           |
|                                                  |
| [Button_Save] [Button_Cancel]                    |
----------------------------------------------------

Форма добавления/редактирования группы (GroupDetailsForm):
- TextBox для названия группы.
- TextBox для описания группы.
- Кнопки «Сохранить» и «Отмена».

Для обеспечения оптимального взаимодействия с пользователем:

Используйте Label для чёткого обозначения полей ввода.
Применяйте ToolTip для предоставления подсказок по элементам управления.
Реализуйте валидацию ввода, чтобы предотвратить некорректные данные (например, проверка формата email, обязательность полей).
Обеспечьте обратную связь пользователю о результатах операций (сообщения об успешном сохранении, ошибках).
Используйте стандартные комбинации клавиш (например, Enter для подтверждения, Esc для отмены).

Разработка бизнес-логики: Реализация правил и операций

Уровень бизнес-логики является «мозгом» приложения. Здесь сосредоточены все операции, которые не касаются напрямую пользовательского интерфейса или хранения данных. Для «Адресной книги» это будет включать:

Класс ContactService (или ContactManager):
- Методы для добавления, обновления, удаления, получения контактов.
- Методы для поиска контактов по различным критериям (имя, фамилия, телефон).
- Методы для фильтрации контактов по группам.
- Валидация данных перед сохранением (например, проверка на дубликаты, обязательность полей).
Класс GroupService (или GroupManager):
- Методы для добавления, обновления, удаления, получения групп.
- Валидация (например, проверка на уникальность имени группы).

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

Пример класса для бизнес-логики (упрощённый):

public class ContactService
{
    private IContactRepository _repository;

    public ContactService(IContactRepository repository)
    {
        _repository = repository;
    }

    public void AddContact(Contact contact)
    {
        // Дополнительная бизнес-логика и валидация
        if (string.IsNullOrWhiteSpace(contact.FirstName) || string.IsNullOrWhiteSpace(contact.LastName))
        {
            throw new ArgumentException("Имя и фамилия контакта обязательны.");
        }
        // Можно добавить проверку на уникальность по email/телефону
        _repository.AddContact(contact);
    }

    public void UpdateContact(Contact contact)
    {
        if (contact.Id == Guid.Empty)
        {
            throw new ArgumentException("Идентификатор контакта не может быть пустым при обновлении.");
        }
        // Повторная валидация
        _repository.UpdateContact(contact);
    }

    public void DeleteContact(Guid contactId)
    {
        _repository.DeleteContact(contactId);
    }

    public IEnumerable<Contact> GetAllContacts()
    {
        return _repository.GetAllContacts();
    }

    public IEnumerable<Contact> SearchContacts(string searchTerm)
    {
        return _repository.GetAllContacts()
                          .Where(c => c.FullName.Contains(searchTerm, StringComparison.OrdinalIgnoreCase) ||
                                      c.PhoneNumber.Contains(searchTerm) ||
                                      c.Email.Contains(searchTerm, StringComparison.OrdinalIgnoreCase));
    }

    // Методы для групп аналогично
}

Уровень доступа к данным: Интерфейсы для работы с различными источниками хранения

Уровень доступа к данным (DAL) является критически важным для изоляции бизнес-логики от конкретной технологии хранения. Для этого мы будем использовать паттерн «Репозиторий» (Repository Pattern), который предполагает определение интерфейсов для каждой сущности.

Интерфейсы IContactRepository и IGroupRepository будут описывать методы для выполнения CRUD-операций:

// Определен ранее
public interface IContactRepository
{
    void AddContact(Contact contact);
    Contact GetContactById(Guid id);
    void UpdateContact(Contact contact);
    void DeleteContact(Guid id);
    IEnumerable<Contact> GetAllContacts();
}

public interface IGroupRepository
{
    void AddGroup(Group group);
    Group GetGroupById(Guid id);
    void UpdateGroup(Group group);
    void DeleteGroup(Guid id);
    IEnumerable<Group> GetAllGroups();
}

Эти интерфейсы будут реализованы конкретными классами (SqliteContactRepository, JsonContactRepository), каждый из которых будет работать со своим типом хранилища. Такой подход позволяет легко менять источник данных без изменения бизнес-логики или пользовательского интерфейса, что существенно упрощает процесс модификации и расширения приложения.

Реализация базовых операций (CRUD) и механизмов хранения данных

Ядром любого приложения, работающего с информацией, является способность управлять этой информацией. В контексте «Адресной книги» это означает возможность добавлять новых людей, просматривать их данные, вносить изменения и удалять устаревшие записи. Эти четыре фундаментальные операции, известные как CRUD (Create, Read, Update, Delete), составляют основу взаимодействия с данными. Выбор же механизма постоянного хранения этих данных определяет надёжность и масштабируемость приложения.

CRUD-операции для контактов и групп

CRUD-операции являются краеугольным камнем управления данными. Их реализация в C# для Windows Forms будет задействовать элементы управления UI для сбора информации, классы бизнес-логики для обработки и валидации, и уровень доступа к данным для сохранения изменений.

Рассмотрим примеры реализации для сущности Contact:

Create (Добавление):
Когда пользователь нажимает кнопку «Добавить контакт», открывается форма ContactDetailsForm. После заполнения полей и нажатия «Сохранить», данные из TextBox‘ов собираются в новый объект Contact. Затем этот объект передаётся в ContactService, который, в свою очередь, вызывает метод AddContact() соответствующей реализации IContactRepository.

// В ContactDetailsForm, после нажатия кнопки "Сохранить"
private void btnSave_Click(object sender, EventArgs e)
{
    try
    {
        Contact newContact = new Contact
        {
            FirstName = txtFirstName.Text,
            LastName = txtLastName.Text,
            PhoneNumber = txtPhoneNumber.Text,
            Email = txtEmail.Text,
            Address = txtAddress.Text,
            DateOfBirth = dtpDateOfBirth.Checked ? (DateTime?)dtpDateOfBirth.Value : null,
            // GroupId можно получить из ComboBox_Group.SelectedItem
        };
        _contactService.AddContact(newContact); // _contactService - экземпляр ContactService
        this.DialogResult = DialogResult.OK;
        this.Close();
    }
    catch (ArgumentException ex)
    {
        MessageBox.Show(ex.Message, "Ошибка ввода", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Произошла ошибка при сохранении контакта: {ex.Message}", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

Read (Чтение):
Чтение данных происходит при загрузке главной формы, а также при поиске или фильтрации. Метод GetAllContacts() из ContactService (через репозиторий) возвращает список объектов Contact, которые затем отображаются в DataGridView.

// В MainForm, при загрузке или обновлении списка
private void LoadContacts()
{
    try
    {
        var contacts = _contactService.GetAllContacts(); // _contactService - экземпляр ContactService
        dgvContacts.DataSource = contacts.ToList(); // dgvContacts - DataGridView
        dgvContacts.Columns["Id"].Visible = false; // Скрыть ID для пользователя
        dgvContacts.Columns["GroupId"].Visible = false; // Скрыть GroupId
        // Настроить отображение других колонок
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Ошибка загрузки контактов: {ex.Message}", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

Update (Обновление):
При редактировании контакта, сначала из DataGridView выбирается существующий контакт. Его данные загружаются в ContactDetailsForm. После изменения полей и нажатия «Сохранить», обновлённый объект Contact (с тем же Id) передаётся в ContactService для вызова метода UpdateContact().

// В ContactDetailsForm, если форма открыта для редактирования
// (предполагаем, что contactToEdit передаётся в конструктор формы)
private Contact _contactToEdit;

public ContactDetailsForm(Contact contactToEdit, ContactService contactService)
{
    InitializeComponent();
    _contactToEdit = contactToEdit;
    _contactService = contactService;

    // Заполнить поля формы данными из _contactToEdit
    txtFirstName.Text = _contactToEdit.FirstName;
    txtLastName.Text = _contactToEdit.LastName;
    // ... и так далее для всех полей
    if (_contactToEdit.DateOfBirth.HasValue)
    {
        dtpDateOfBirth.Value = _contactToEdit.DateOfBirth.Value;
        dtpDateOfBirth.Checked = true;
    }
    else
    {
        dtpDateOfBirth.Checked = false;
    }
}

private void btnSave_Click(object sender, EventArgs e)
{
    try
    {
        // Обновить свойства _contactToEdit новыми значениями из формы
        _contactToEdit.FirstName = txtFirstName.Text;
        _contactToEdit.LastName = txtLastName.Text;
        // ...
        _contactService.UpdateContact(_contactToEdit);
        this.DialogResult = DialogResult.OK;
        this.Close();
    }
    catch (ArgumentException ex)
    {
        MessageBox.Show(ex.Message, "Ошибка ввода", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Произошла ошибка при обновлении контакта: {ex.Message}", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}

Delete (Удаление):
Пользователь выбирает контакт в DataGridView и нажимает кнопку «Удалить». После подтверждения (например, через MessageBox.Show), Id выбранного контакта передаётся в ContactService для вызова DeleteContact().

// В MainForm, после нажатия кнопки "Удалить контакт"
private void btnDeleteContact_Click(object sender, EventArgs e)
{
    if (dgvContacts.SelectedRows.Count > 0)
    {
        if (MessageBox.Show("Вы уверены, что хотите удалить выбранный контакт?", "Подтверждение удаления", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
        {
            try
            {
                // Получить Id выбранного контакта из DataGridView
                Guid contactId = (Guid)dgvContacts.SelectedRows[0].Cells["Id"].Value;
                _contactService.DeleteContact(contactId);
                LoadContacts(); // Перезагрузить список контактов
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при удалении контакта: {ex.Message}", "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
    else
    {
        MessageBox.Show("Пожалуйста, выберите контакт для удаления.", "Предупреждение", MessageBoxButtons.OK, MessageBoxIcon.Information);
    }
}

Аналогичные операции будут реализованы и для сущности «Группа», с использованием GroupService и IGroupRepository.

Выбор и реализация механизмов хранения данных

Выбор механизма хранения данных является одним из ключевых решений при проектировании приложения. Для курсовой работы можно рассмотреть два основных подхода: использование локальных баз данных или файловых форматов. Каждый из них имеет свои преимущества и недостатки.

Таблица 1: Сравнение механизмов хранения данных

Критерий	SQL Server Compact / SQLite	XML / JSON файлы
Сложность настройки	Требует установки драйвера/библиотеки, создания схемы.	Простое чтение/запись строк, но требует ручной сериализации.
Производительность	Высокая для больших объёмов, эффективный поиск, индексы.	Может быть медленнее для больших объёмов, линейный поиск.
Целостность данных	Встроенные механизмы (транзакции, ограничения).	Требует ручной реализации логики целостности в коде.
Масштабируемость	Хорошо масштабируется для локальных нужд.	Ограничена для очень больших объёмов или сетевого доступа.
Удобство запросов	SQL-запросы позволяют сложную фильтрацию и агрегацию.	Требует ручной фильтрации/поиска в коде C#.
Портативность	Одна файл-база данных (например, `.sqlite` или `.sdf`).	Один или несколько файлов.
Использование	Для структурированных данных, требующих гибких запросов.	Для простых данных, конфигураций, обмена данными.

Использование SQL Server Compact/SQLite

Для локального хранения данных в настольных приложениях идеальными кандидатами являются легковесные базы данных, такие как SQL Server Compact (ранее поддерживался, но сейчас менее актуален) или, что более предпочтительно, SQLite. SQLite — это встраиваемая, самодостаточная, бессерверная, безнастроечная, транзакционная база данных, которая хранит всю базу данных в одном кроссплатформенном файле. Она идеально подходит для сценариев, где не требуется полноценный сервер баз данных или нужна отдельная база данных для каждой установки приложения.

Подключение и создание схем баз данных:
Для работы с SQLite в C# необходимо добавить соответствующий NuGet-пакет, например, System.Data.SQLite или Microsoft.Data.SQLite (для более новых версий .NET, но System.Data.SQLite будет более релевантен для VS 2013).

ER-диаграмма для «Адресной книги»:

+-----------------+      +-----------------+
|     Groups      |      |     Contacts    |
+-----------------+      +-----------------+
| GroupId (PK)    |<-----| GroupId (FK)    |
| Name            |      | ContactId (PK)  |
| Description     |      | FirstName       |
+-----------------+      | LastName        |
                         | PhoneNumber     |
                         | Email           |
                         | Address         |
                         | DateOfBirth     |
                         | Notes           |
                         +-----------------+

Примеры взаимодействия с базой данных на C# с использованием ADO.NET (System.Data.SqlClient для SQL Server, аналогично для SQLite):

Хотя System.Data.SqlClient используется для взаимодействия с SQL Server, для SQLite используется похожий подход с классами SQLiteConnection, SQLiteCommand, SQLiteDataReader.

// Пример для SQLite
public class SqliteContactRepository : IContactRepository
{
    private string _connectionString = "Data Source=addressbook.sqlite;Version=3;";

    public SqliteContactRepository()
    {
        // Создание таблицы, если она не существует
        using (var connection = new SQLiteConnection(_connectionString))
        {
            connection.Open();
            string createTableSql = @"
                CREATE TABLE IF NOT EXISTS Groups (
                    GroupId TEXT PRIMARY KEY,
                    Name TEXT NOT NULL,
                    Description TEXT
                );
                CREATE TABLE IF NOT EXISTS Contacts (
                    ContactId TEXT PRIMARY KEY,
                    FirstName TEXT NOT NULL,
                    LastName TEXT NOT NULL,
                    PhoneNumber TEXT,
                    Email TEXT,
                    Address TEXT,
                    DateOfBirth TEXT, -- Сохраняем как текст ISO 8601
                    Notes TEXT,
                    GroupId TEXT,
                    FOREIGN KEY (GroupId) REFERENCES Groups(GroupId) ON DELETE SET NULL
                );";
            using (var command = new SQLiteCommand(createTableSql, connection))
            {
                command.ExecuteNonQuery();
            }
        }
    }

    public void AddContact(Contact contact)
    {
        using (var connection = new SQLiteConnection(_connectionString))
        {
            connection.Open();
            string insertSql = @"
                INSERT INTO Contacts (ContactId, FirstName, LastName, PhoneNumber, Email, Address, DateOfBirth, Notes, GroupId)
                VALUES (@ContactId, @FirstName, @LastName, @PhoneNumber, @Email, @Address, @DateOfBirth, @Notes, @GroupId);";
            using (var command = new SQLiteCommand(insertSql, connection))
            {
                command.Parameters.AddWithValue("@ContactId", contact.Id.ToString());
                command.Parameters.AddWithValue("@FirstName", contact.FirstName);
                command.Parameters.AddWithValue("@LastName", contact.LastName);
                command.Parameters.AddWithValue("@PhoneNumber", contact.PhoneNumber ?? (object)DBNull.Value);
                command.Parameters.AddWithValue("@Email", contact.Email ?? (object)DBNull.Value);
                command.Parameters.AddWithValue("@Address", contact.Address ?? (object)DBNull.Value);
                command.Parameters.AddWithValue("@DateOfBirth", contact.DateOfBirth?.ToString("yyyy-MM-dd") ?? (object)DBNull.Value);
                command.Parameters.AddWithValue("@Notes", contact.Notes ?? (object)DBNull.Value);
                command.Parameters.AddWithValue("@GroupId", contact.GroupId?.ToString() ?? (object)DBNull.Value);
                command.ExecuteNonQuery();
            }
        }
    }

    public IEnumerable<Contact> GetAllContacts()
    {
        List<Contact> contacts = new List<Contact>();
        using (var connection = new SQLiteConnection(_connectionString))
        {
            connection.Open();
            string selectSql = "SELECT * FROM Contacts;";
            using (var command = new SQLiteCommand(selectSql, connection))
            {
                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        contacts.Add(new Contact
                        {
                            Id = Guid.Parse(reader["ContactId"].ToString()),
                            FirstName = reader["FirstName"].ToString(),
                            LastName = reader["LastName"].ToString(),
                            PhoneNumber = reader["PhoneNumber"] as string,
                            Email = reader["Email"] as string,
                            Address = reader["Address"] as string,
                            DateOfBirth = reader["DateOfBirth"] != DBNull.Value ? (DateTime?)DateTime.Parse(reader["DateOfBirth"].ToString()) : null,
                            Notes = reader["Notes"] as string,
                            GroupId = reader["GroupId"] != DBNull.Value ? (Guid?)Guid.Parse(reader["GroupId"].ToString()) : null
                        });
                    }
                }
            }
        }
        return contacts;
    }

    // Методы UpdateContact, DeleteContact, GetContactById и методы для Group будут реализованы аналогично.
}

Хранение данных в файлах XML/JSON

Альтернативой базам данных является использование файловых форматов, таких как XML (eXtensible Markup Language) и JSON (JavaScript Object Notation). Эти форматы особенно удобны для хранения конфигурационных данных, небольших объёмов структурированных данных или для обмена данными между различными системами.

Преимущества JSON:
JSON особенно популярен благодаря своей простоте, удобочитаемости и компактности. Он легче парсится машинами и легче читается человеком по сравнению с XML. Компактность способствует более быстрой передаче данных по сети, что делает его предпочтительным выбором для веб-API и мобильных приложений. Легкость интеграции с большинством языков программирования, включая C#, Java и Python, также способствует его широкому распространению.
Пространство имён System.Text.Json:
В .NET (начиная с .NET Core 3.0 и доступный в .NET 5+), пространство имён System.Text.Json предоставляет высокопроизводительные и гибкие функциональные возможности для сериализации объектов C# в JSON и десериализации JSON обратно в объекты. Для Visual Studio 2013 и .NET Framework 4.5/4.5.1 можно использовать более старый Newtonsoft.Json (JSON.NET), который является де-факто стандартом для .NET Framework, или же, при определённых условиях, попытаться интегрировать System.Text.Json через пакеты совместимости, но это может быть сложнее. В рамках данной работы мы рассмотрим System.Text.Json как актуальный пример, подразумевая, что аналогичный подход применим и для Newtonsoft.Json.

Ключевым классом является JsonSerializer, предоставляющий статические методы Serialize() и Deserialize().

По умолчанию выходные д��нные JSON минифицируются (без пробелов и отступов). Для удобочитаемости (pretty-printing) при сериализации необходимо установить свойство JsonSerializerOptions.WriteIndented в true.

Примеры кода для чтения и записи данных контактов в JSON файлы:

using System.IO;
using System.Text.Json;
using System.Collections.Generic;
using System.Linq;

public class JsonContactRepository : IContactRepository
{
    private readonly string _filePath = "contacts.json";
    private readonly JsonSerializerOptions _options = new JsonSerializerOptions { WriteIndented = true }; // Для красивого JSON

    public JsonContactRepository()
    {
        // Создать файл, если его нет
        if (!File.Exists(_filePath))
        {
            File.WriteAllText(_filePath, "[]"); // Пустой массив JSON
        }
    }

    private List<Contact> LoadContactsFromFile()
    {
        string json = File.ReadAllText(_filePath);
        return JsonSerializer.Deserialize<List<Contact>>(json) ?? new List<Contact>();
    }

    private void SaveContactsToFile(List<Contact> contacts)
    {
        string json = JsonSerializer.Serialize(contacts, _options);
        File.WriteAllText(_filePath, json);
    }

    public void AddContact(Contact contact)
    {
        List<Contact> contacts = LoadContactsFromFile();
        contacts.Add(contact);
        SaveContactsToFile(contacts);
    }

    public Contact GetContactById(Guid id)
    {
        return LoadContactsFromFile().FirstOrDefault(c => c.Id == id);
    }

    public void UpdateContact(Contact contact)
    {
        List<Contact> contacts = LoadContactsFromFile();
        var existingContact = contacts.FirstOrDefault(c => c.Id == contact.Id);
        if (existingContact != null)
        {
            // Обновляем поля существующего контакта
            existingContact.FirstName = contact.FirstName;
            existingContact.LastName = contact.LastName;
            existingContact.PhoneNumber = contact.PhoneNumber;
            existingContact.Email = contact.Email;
            existingContact.Address = contact.Address;
            existingContact.DateOfBirth = contact.DateOfBirth;
            existingContact.Notes = contact.Notes;
            existingContact.GroupId = contact.GroupId;
            SaveContactsToFile(contacts);
        }
        else
        {
            throw new InvalidOperationException($"Контакт с ID {contact.Id} не найден для обновления.");
        }
    }

    public void DeleteContact(Guid id)
    {
        List<Contact> contacts = LoadContactsFromFile();
        contacts.RemoveAll(c => c.Id == id);
        SaveContactsToFile(contacts);
    }

    public IEnumerable<Contact> GetAllContacts()
    {
        return LoadContactsFromFile();
    }
}

Аналогичный JsonGroupRepository может быть создан для работы с группами. Выбор между базой данных и файлами зависит от требований к производительности, объёму данных, сложности запросов и удобству развёртывания. Для курсовой работы оба варианта являются допустимыми и демонстрируют разные подходы к управлению данными.

Реализация дополнительных функций

Помимо базовых CRUD-операций, современные приложения часто предлагают дополнительные функции, которые значительно повышают их ценность и удобство использования. Для «Адресной книги» такими возможностями могут стать экспорт данных в различные форматы и прямая отправка электронных писем из приложения. Реализация этих функций продемонстрирует продвинутые навыки программирования и способность интегрировать сторонние сервисы или библиотеки.

Экспорт данных

Возможность экспортировать данные контактов из приложения является весьма востребованной функцией. Она позволяет пользователям создавать резервные копии, переносить данные между системами или делиться ими в удобном формате. Для нашей «Адресной книги» рассмотрим экспорт в XML, JSON, а также кратко упомянем DOCX и HTML.

Экспорт в XML и JSON: Использование существующих механизмов сериализации

Поскольку мы уже рассматривали использование XML и JSON для хранения данных, механизмы сериализации и десериализации могут быть легко адаптированы для экспорта.

Экспорт в JSON:
Это наиболее простой вариант, если вы уже используете JSON для хранения. Достаточно получить все контакты из репозитория и сериализовать их в строку JSON, которая затем записывается в файл, выбранный пользователем.

using System.IO;
using System.Text.Json;
using System.Windows.Forms; // Для SaveFileDialog

public class ExportService
{
    private readonly IContactRepository _contactRepository;

    public ExportService(IContactRepository contactRepository)
    {
        _contactRepository = contactRepository;
    }

    public void ExportContactsToJson()
    {
        using (SaveFileDialog sfd = new SaveFileDialog())
        {
            sfd.Filter = "JSON Files (*.json)|*.json|All Files (*.*)|*.*";
            sfd.DefaultExt = "json";
            sfd.Title = "Экспорт контактов в JSON";

            if (sfd.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    var contacts = _contactRepository.GetAllContacts().ToList();
                    var options = new JsonSerializerOptions { WriteIndented = true };
                    string jsonString = JsonSerializer.Serialize(contacts, options);
                    File.WriteAllText(sfd.FileName, jsonString);
                    MessageBox.Show("Контакты успешно экспортированы в JSON.", "Экспорт завершён", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Ошибка при экспорте в JSON: {ex.Message}", "Ошибка экспорта", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }
    }
    // Аналогично для XML, используя System.Xml.Serialization.XmlSerializer
}

Экспорт в XML:
Для экспорта в XML можно использовать класс System.Xml.Serialization.XmlSerializer. Он позволяет сериализовать объекты C# в XML-формат.

using System.Xml.Serialization;
using System.IO;
using System.Windows.Forms;
using System.Linq;

// ... в классе ExportService
public void ExportContactsToXml()
{
    using (SaveFileDialog sfd = new SaveFileDialog())
    {
        sfd.Filter = "XML Files (*.xml)|*.xml|All Files (*.*)|*.*";
        sfd.DefaultExt = "xml";
        sfd.Title = "Экспорт контактов в XML";

        if (sfd.ShowDialog() == DialogResult.OK)
        {
            try
            {
                var contacts = _contactRepository.GetAllContacts().ToList();
                XmlSerializer serializer = new XmlSerializer(typeof(List<Contact>));
                using (TextWriter writer = new StreamWriter(sfd.FileName))
                {
                    serializer.Serialize(writer, contacts);
                }
                MessageBox.Show("Контакты успешно экспортированы в XML.", "Экспорт завершён", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при экспорте в XML: {ex.Message}", "Ошибка экспорта", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

Экспорт в DOCX или HTML: Обзор возможных подходов и библиотек

Экспорт в форматы DOCX (Microsoft Word) или HTML требует более сложных решений, так как эти форматы не являются простыми текстовыми структурами.

Экспорт в DOCX:
Для работы с файлами DOCX в C# обычно используются сторонние библиотеки, поскольку встроенных механизмов .NET для этого нет. Популярные библиотеки:
- NPOI: Порт Apache POI для .NET, позволяет работать с форматами MS Office (XLS, DOCX, PPT). Бесплатная, но имеет довольно низкоуровневый API.
- DocX: Удобная библиотека для создания и модификации DOCX-файлов.
- Aspose.Words for .NET: Мощная коммерческая библиотека с очень богатым функционалом.
Реализация потребует создания документа, добавления в него таблицы или параграфов с данными контактов. Это довольно объёмная задача, выходящая за рамки простого примера, но для курсовой работы можно ограничиться обзором этих библиотек и указанием их как потенциальных путей расширения.
Экспорт в HTML:
Экспорт в HTML относительно прост, так как HTML — это текстовый формат. Можно вручную сгенерировать HTML-таблицу с данными контактов.

// ... в классе ExportService
public void ExportContactsToHtml()
{
    using (SaveFileDialog sfd = new SaveFileDialog())
    {
        sfd.Filter = "HTML Files (*.html)|*.html|All Files (*.*)|*.*";
        sfd.DefaultExt = "html";
        sfd.Title = "Экспорт контактов в HTML";

        if (sfd.ShowDialog() == DialogResult.OK)
        {
            try
            {
                var contacts = _contactRepository.GetAllContacts().ToList();
                System.Text.StringBuilder htmlBuilder = new System.Text.StringBuilder();
                htmlBuilder.Append("<!DOCTYPE html>\n<html>\n<head><title>Контакты</title>");
                htmlBuilder.Append("<style>table, th, td { border: 1px solid black; border-collapse: collapse; padding: 8px; }</style>");
                htmlBuilder.Append("</head>\n<body>\n<h1>Список контактов</h1>\n");
                htmlBuilder.Append("<table>\n<thead>\n<tr><th>Имя</th><th>Фамилия</th><th>Телефон</th><th>Email</th><th>Адрес</th><th>День рождения</th></tr>\n</thead>\n<tbody>\n");

                foreach (var contact in contacts)
                {
                    htmlBuilder.Append("<tr>");
                    htmlBuilder.Append($"<td>{contact.FirstName}</td>");
                    htmlBuilder.Append($"<td>{contact.LastName}</td>");
                    htmlBuilder.Append($"<td>{contact.PhoneNumber}</td>");
                    htmlBuilder.Append($"<td>{contact.Email}</td>");
                    htmlBuilder.Append($"<td>{contact.Address}</td>");
                    htmlBuilder.Append($"<td>{contact.DateOfBirth?.ToShortDateString() ?? ""}</td>");
                    htmlBuilder.Append("</tr>\n");
                }

                htmlBuilder.Append("</tbody>\n</table>\n</body>\n</html>");
                File.WriteAllText(sfd.FileName, htmlBuilder.ToString());
                MessageBox.Show("Контакты успешно экспортированы в HTML.", "Экспорт завершён", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Ошибка при экспорте в HTML: {ex.Message}", "Ошибка экспорта", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

Отправка электронных писем из приложения

Интеграция функции отправки электронных писем может быть полезна для быстрого взаимодействия с контактами из адресной книги. Например, можно добавить кнопку «Отправить email» рядом с каждым контактом.

В .NET Framework для отправки электронной почты используется класс SmtpClient из пространства имён System.Net.Mail.

Конфигурация `SmtpClient`: `Host`, `Port`, `Credentials`, `EnableSsl`

Прежде чем отправлять письмо, необходимо настроить параметры SMTP-сервера.

using System.Net.Mail;
using System.Net;
using System.Windows.Forms;

public class EmailService
{
    private readonly string _smtpHost;
    private readonly int _smtpPort;
    private readonly string _username;
    private readonly string _password;
    private readonly bool _enableSsl;
    private readonly string _fromAddress;

    public EmailService(string smtpHost, int smtpPort, string username, string password, bool enableSsl, string fromAddress)
    {
        _smtpHost = smtpHost;
        _smtpPort = smtpPort;
        _username = username;
        _password = password;
        _enableSsl = enableSsl;
        _fromAddress = fromAddress;
    }

    public void SendEmail(string toAddress, string subject, string body, bool isHtmlBody, List<Attachment> attachments = null)
    {
        using (SmtpClient smtpClient = new SmtpClient(_smtpHost, _smtpPort))
        {
            smtpClient.EnableSsl = _enableSsl;
            smtpClient.Credentials = new NetworkCredential(_username, _password);
            smtpClient.DeliveryMethod = SmtpDeliveryMethod.Network; // Указываем, что почта отправляется через сеть

            using (MailMessage mailMessage = new MailMessage(_fromAddress, toAddress, subject, body))
            {
                mailMessage.IsBodyHtml = isHtmlBody;
                if (attachments != null)
                {
                    foreach (var attachment in attachments)
                    {
                        mailMessage.Attachments.Add(attachment);
                    }
                }

                try
                {
                    smtpClient.Send(mailMessage); // Синхронная отправка
                    MessageBox.Show("Письмо успешно отправлено!", "Отправка почты", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                catch (SmtpException ex)
                {
                    MessageBox.Show($"Ошибка SMTP: {ex.StatusCode} - {ex.Message}", "Ошибка отправки почты", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Произошла ошибка при отправке письма: {ex.Message}", "Ошибка отправки почты", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
        }
    }
}

Создание и отправка `MailMessage`: `Attachments`, `Body`, `From`, `To`, `Subject`, `IsBodyHtml`

Класс MailMessage представляет само электронное сообщение.

From: Адрес отправителя.
To: Адрес получателя (можно добавить несколько).
Subject: Тема письма.
Body: Содержимое письма.
IsBodyHtml: Флаг, указывающий, является ли Body HTML-кодом.
Attachments: Коллекция для добавления вложений.

Особенности использования `SmtpClient`: Синхронные и асинхронные методы

Синхронные методы (Send()): Метод SmtpClient.Send() отправляет сообщение, блокируя выполнение программы до завершения передачи письма на SMTP-сервер. Для небольших приложений или нечастых отправок это может быть приемлемо, но в GUI-приложениях блокировка основного потока может привести к «зависанию» интерфейса.
Асинхронные методы (SendAsync(), SendMailAsync()): Для более отзывчивого пользовательского интерфейса рекомендуется использовать асинхронные методы. SendAsync() и SendMailAsync() отправляют сообщение в фоновом режиме, не блокируя основной поток. По завершении операции (успешно или с ошибкой) возникает событие SendCompleted, которое можно обработать для уведомления пользователя или выполнения дальнейших действий.

// Асинхронная отправка
public async Task SendEmailAsync(string toAddress, string subject, string body, bool isHtmlBody, List<Attachment> attachments = null)
{
    using (SmtpClient smtpClient = new SmtpClient(_smtpHost, _smtpPort))
    {
        smtpClient.EnableSsl = _enableSsl;
        smtpClient.Credentials = new NetworkCredential(_username, _password);
        smtpClient.DeliveryMethod = SmtpDeliveryMethod.Network;

        using (MailMessage mailMessage = new MailMessage(_fromAddress, toAddress, subject, body))
        {
            mailMessage.IsBodyHtml = isHtmlBody;
            if (attachments != null)
            {
                foreach (var attachment in attachments)
                {
                    mailMessage.Attachments.Add(attachment);
                }
            }

            try
            {
                await smtpClient.SendMailAsync(mailMessage); // Асинхронная отправка
                MessageBox.Show("Письмо успешно отправлено (асинхронно)!", "Отправка почты", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (SmtpException ex)
            {
                MessageBox.Show($"Ошибка SMTP: {ex.StatusCode} - {ex.Message}", "Ошибка отправки почты", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Произошла ошибка при отправке письма: {ex.Message}", "Ошибка отправки почты", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

Для использования await необходимо, чтобы вызывающий метод был помечен как async.

Контекст нерекомендации для новых проектов и альтернативы (MailKit):
Важно отметить, что Microsoft не рекомендует использовать SmtpClient для новых проектов в .NET (особенно для .NET Core и .NET 5+), предлагая вместо него сторонние библиотеки, такие как MailKit. Основная причина заключается в том, что SmtpClient — это более старый API, который может быть менее устойчивым к современным изменениям протоколов SMTP, предлагать менее гибкие механизмы аутентификации и требовать больше ручной работы по сравнению с современными библиотеками. Однако, для проектов на .NET Framework 4.0 до 4.8 (что соответствует Visual Studio 2013), SmtpClient по-прежнему полностью поддерживается и является рабочим решением для большинства задач. Для курсовой работы его использование вполне оправдано.

Тестирование, отладка и документирование курсовой работы

Создание работающего программного обеспечения — это только половина дела. Чтобы проект был действительно качественным, надёжным и соответствовал академическим требованиям, необходимы тщательное тестирование, эффективная отладка и всестороннее документирование. Эти этапы критически важны для выявления и устранения ошибок, обеспечения соответствия требованиям и демонстрации глубокого понимания процесса разработки.

Методологии тестирования приложения

Тестирование — это систематический процесс проверки программного обеспечения с целью выявления дефектов, подтверждения его соответствия заданным требованиям и оценки качества. В контексте разработки курсовой работы, тестирование позволяет убедиться, что «Адресная книга» функционирует так, как ожидается, без непредвиденных сбоев или некорректного поведения.

Важность тестирования:
Тестирование и отладка являются ключевыми процессами, поскольку они позволяют проверить соответствие программного обеспечения требованиям, выявить ошибки, пробелы и несоответствия до выпуска продукта. Это значительно снижает затраты на исправление дефектов на ранних стадиях разработки, а также повышает удовлетворённость пользователей и надёжность приложения. Ведь если приложение не работает, какая от него польза?

Основные виды тестирования, применимые к настольным приложениям:

Модульное тестирование (Unit Testing):
- Суть: Тестирование отдельных, наименьших логических частей кода (модулей, классов, методов) в изоляции.
- Применение к «Адресной книге»: Тестирование методов класса ContactService (например, AddContact с некорректными данными, SearchContacts с разными запросами), методов репозитория (AddContact в базу данных или файл). Для этого можно использовать фреймворки, такие как NUnit или MSTest.
Интеграционное тестирование (Integration Testing):
- Суть: Проверка взаимодействия между различными модулями или компонентами системы.
- Применение к «Адресной книге»: Тестирование взаимодействия между UI и бизнес-логикой, или между бизнес-логикой и уровнем доступа к данным (например, добавление контакта через UI, которое затем сохраняется в базе данных).
Системное тестирование (System Testing):
- Суть: Тестирование всей интегрированной системы на соответствие требованиям.
- Применение к «Адресной книге»: Проверка полного цикла работы приложения: от запуска до завершения, включая все функции CRUD, экспорт, отправку почты, работу с группами.
Пользовательское приёмочное тестирование (User Acceptance Testing — UAT):
- Суть: Тестирование конечными пользователями (в данном случае, преподавателем или студентами-коллегами) для подтверждения, что приложение соответствует их ожиданиям и бизнес-требованиям.
- Применение к «Адресной книге»: Демонстрация приложения и сбор обратной связи.
Тестирование пользовательского интерфейса (UI Testing):
- Суть: Проверка корректности отображения элементов, их расположения, реакции на действия пользователя (клики, ввод данных).
- Применение к «Адресной книге»: Ручная проверка всех форм, кнопок, текстовых полей; проверка валидации ввода.

Отладка в Visual Studio 2013

Отладка — это процесс обнаружения и исправления ошибок (багов) в программном коде. Visual Studio 2013 предоставляет мощный набор инструментов для эффективной отладки, позволяя разработчику буквально «шагнуть» внутрь работающей программы.

Эффективная отладка в Visual Studio обеспечивается следующими инструментами и функциями:

Точки останова (Breakpoints):
- Назначение: Позволяют приостановить выполнение программы в определённой строке кода.
- Установка: Щелчок левой кнопкой мыши по серой полосе слева от строки кода. Красный кружок указывает на установленную точку останова.
- Условные точки останова: Можно настроить точку останова так, чтобы она срабатывала только при выполнении определённого условия (например, contact.Id == someSpecificGuid). Это очень полезно при работе с циклами или большими наборами данных.
Пошаговое выполнение кода:
После срабатывания точки останова программа приостанавливается, и вы можете пошагово выполнять код:
- «Шаг с заходом» (Step Into — F11): Выполняет текущую строку и, если это вызов метода, переходит внутрь этого метода.
- «Шаг с о��ходом» (Step Over — F10): Выполняет текущую строку и, если это вызов метода, выполняет метод целиком, не заходя внутрь.
- «Шаг с выходом» (Step Out — Shift+F11): Выполняет оставшуюся часть текущего метода и возвращается к точке вызова.
- «Продолжить» (Continue — F5): Продолжает выполнение программы до следующей точки останова или до завершения программы.
Окна для инспекции переменных:
Во время отладки Visual Studio предоставляет несколько окон для просмотра и изменения значений переменных:
- «Локальные» (Locals): Отображает переменные, находящиеся в текущей области видимости.
- «Контрольные значения» (Watch): Позволяет вручную добавить любые переменные или выражения, значения которых вы хотите отслеживать.
- «Автоматические» (Autos): Автоматически отображает переменные, используемые в текущей и предыдущих строках кода.
- «Интерпретация» (Immediate): Позволяет выполнять произвольные выражения C# в контексте текущего состояния отладчика, просматривать значения переменных и даже изменять их.
Стек вызовов (Call Stack):
Окно «Стек вызовов» показывает последовательность вызовов методов, которые привели к текущей точке выполнения. Это очень полезно для понимания потока выполнения программы.

Эффективное использование этих инструментов отладки значительно сокращает время на поиск и исправление ошибок, делая процесс разработки более продуктивным.

Требования к документированию курсовой работы

Документирование является неотъемлемой частью любой академической работы по программированию. Оно демонстрирует глубокое понимание проекта, его структуры, логики и используемых технологий. Хорошо документированный проект легко понять, поддерживать и расширять.

Стандарты и рекомендации по созданию технической документации для академического проекта «Адресная книга» должны включать следующие разделы:

Титульный лист: Стандартный для курсовой работы (название ВУЗа, факультета, кафедры, тема работы, данные студента и научного руководителя).
Оглавление: Структурированный список всех разделов и подразделов с номерами страниц.
Введение:
- Актуальность проблемы (управления контактами).
- Цели и задачи курсовой работы (создание функционального приложения, освоение технологий).
- Обзор используемых технологий (Windows Forms, C#, Visual Studio 2013, .NET Framework 4.5/4.5.1).
Теоретические основы:
- Подробное описание Windows Forms как платформы.
- Описание языка C# и его особенностей.
- Глубокое изложение принципов ООП (абстракция, инкапсуляция, наследование, полиморфизм) с примерами из вашего проекта «Адресная книга».
Проектирование приложения:
- Описание архитектуры приложения: Подробное объяснение выбранной многослойной архитектуры (уровень представления, бизнес-логики, доступа к данным), обоснование выбора.
- Проектирование классов сущностей: Описание классов Contact и Group, их свойств и методов.
- ER-диаграммы или структуры данных:
  - Для баз данных: графическое представление связей между таблицами Contacts и Groups.
  - Для XML/JSON: описание структуры XML- или JSON-файлов, включая примеры данных.
- Описание пользовательского интерфейса (UI/UX): Макеты всех форм (главная форма, форма контакта, форма группы) с описанием назначения каждого элемента управления. Объяснение принципов, обеспечивающих удобство использования.
Детали реализации основных функций:
- Пошаговое описание реализации CRUD-операций для контактов и групп с фрагментами кода на C#.
- Описание выбранного механизма хранения данных (SQLite/XML/JSON), обоснование выбора. Примеры кода для взаимодействия с выбранным хранилищем.
- Описание реализации дополнительных функций (экспорт данных, отправка электронной почты) с примерами кода и объяснением используемых классов/библиотек.
Тестирование и отладка:
- Описание применяемых методологий тестирования.
- Примеры тестовых сценариев для ключевых функций.
- Руководство по отладке приложения в Visual Studio.
Руководство пользователя и разработчика:
- Инструкции по сборке и развёртыванию приложения: Как скомпилировать проект в Visual Studio, какие зависимости необходимы для запуска.
- Инструкции по установке (если требуется).
- Инструкции по использованию приложения для конечного пользователя.
- Рекомендации по дальнейшему развитию проекта.
Заключение: Обобщение результатов, выводы, достигнутые цели.
Список использованных источников: Перечень всех книг, статей, онлайн-ресурсов, использованных при выполнении работы, оформленный согласно требованиям ВУЗа.
Приложения (при необходимости): Полный листинг кода, скриншоты, дополнительные диаграммы.

Чёткая и полная документация не только повышает академическую ценность вашей работы, но и демонстрирует способность мыслить системно и представлять результаты своей работы в профессиональном формате.

Заключение

Разработка приложения «Адресная книга» на Windows Forms с использованием C# и Visual Studio 2013, подробно описанная в данном руководстве, представляет собой комплексный и многогранный учебный проект. Мы успешно прошли путь от фундаментальных теоретических концепций до практической реализации, охватывая все ключевые аспекты, необходимые для выполнения академической курсовой работы.

Были рассмотрены основы платформы Windows Forms и языка C#, заложен прочный фундамент объектно-ориентированного программирования с его принципами абстракции, инкапсуляции, наследования и полиморфизма, что позволило создать масштабируемую и поддерживаемую архитектуру приложения. Мы углубились в проектирование многослойной структуры, определив уровни представления, бизнес-логики и доступа к данным, а также разработали классы сущностей «Контакт» и «Группа».

Ключевым этапом стала реализация базовых CRUD-операций и выбор механизмов постоянного хранения данных. Были проанализированы и представлены решения для локальных баз данных, таких как SQLite, а также для файловых форматов XML и JSON, с детальными примерами сериализации и десериализации. Кроме того, мы расширили функционал приложения, добавив возможность экспорта данных в различные форматы и интегрировав функцию отправки электронных писем с использованием класса SmtpClient, рассмотрев как синхронные, так и асинхронные подходы.

Наконец, особое внимание было уделено вопросам качества и академической ценности проекта. Мы обсудили методологии тестирования, освоили мощные инструменты отладки Visual Studio 2013 и определили всеобъемлющие требования к документированию курсовой работы.

В итоге, студент, опираясь на это руководство, не только создаст функциональное приложение «Адресная книга», но и получит глубокое понимание принципов программной инженерии, современных подходов к разработке настольных приложений и академических стандартов представления проектных работ. Этот проект послужит отличной базой для дальнейшего профессионального роста и изучения более сложных систем, демонстрируя готовность студента к решению реальных задач в области программной инженерии.

Список использованной литературы

Прайс Д., Гандэрлой М. Visual C#.NET. Полное руководство. – К.: ВЕК+, СПб.: КОРОНА принт, К.: НТИ, М.: Энтроп, 2004. – 960 с.
Майо Д. Самоучитель Microsoft Visual Studio 2010 = Microsoft Visual Studio 2010: A Beginner’s Guide (A Beginners Guide). – C.: БХВ-Петербург, 2010. – 464 с.
Ник Рендольф, Дэвид Гарднер, Майкл Минутилло, Крис Андерсон Visual Studio 2010 для профессионалов = Professional Visual Studio 2010. — М.: Диалектика, 2011. — 1184 с.
Что такое Windows Forms — Windows Forms | Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/dotnet/desktop/winforms/overview/?view=netframework-4.8 (дата обращения: 29.10.2025).
Работа с электронной почтой в C# и .NET — Metanit. URL: https://metanit.com/sharp/net/5.6.php (дата обращения: 29.10.2025).
Отправка и пересылка сообщений — Отправка email через Outlook с использованием C# | Documentation. URL: https://docs.aspose.com/email/net/sending-and-forwarding-messages/ (дата обращения: 29.10.2025).
SmtpClient Class (System.Net.Mail) — Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/dotnet/api/system.net.mail.smtpclient?view=netframework-4.8 (дата обращения: 29.10.2025).
CRUD Operations Using ADO.NET DataReader in Windows Forms — C# Corner. URL: https://www.c-sharpcorner.com/article/crud-operations-using-adonet-datareader-in-windows-forms/ (дата обращения: 29.10.2025).
SmtpClient.Send Method (System.Net.Mail) — Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/dotnet/api/system.net.mail.smtpclient.send?view=netframework-4.8 (дата обращения: 29.10.2025).
Внутренняя структура проекта Windows Forms. URL: https://it-academy.by/vnutrennyaya-struktura-proekta-windows-forms.html (дата обращения: 29.10.2025).
Using SQLite in C# — Building Simple, Powerful, Portable Databases for Your Application. URL: https://www.iamtimcorey.com/downloads/?code=SQLiteInCSharp (дата обращения: 29.10.2025).
Основные принципы ООП в C# .NET — run-dev. URL: https://run-dev.ru/blog/oop-in-csharp (дата обращения: 29.10.2025).
Принципы ООП в примерах для начинающих — Habr. URL: https://habr.com/ru/articles/765052/ (дата обращения: 29.10.2025).
Объектно-ориентированное программирование — METANIT.COM. URL: https://metanit.com/sharp/tutorial/1.1.php (дата обращения: 29.10.2025).
Программирование Object-Oriented (C#) — Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/dotnet/csharp/fundamentals/tutorials/oop (дата обращения: 29.10.2025).
Сериализация JSON в C# — .NET — Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/dotnet/standard/serialization/system-text-json/serialize-how-to?pivots=dotnet-8-0 (дата обращения: 29.10.2025).
C# и .NET | Сериализация в JSON. JsonSerializer — METANIT.COM. URL: https://metanit.com/sharp/net/24.1.php (дата обращения: 29.10.2025).
Сериализация и десериализация JSON с помощью C# — .NET | Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/dotnet/standard/serialization/system-text-json/overview (дата обращения: 29.10.2025).
Создание приложения Windows Forms с помощью C# — Visual Studio (Windows) | Microsoft Learn. URL: https://learn.microsoft.com/ru-ru/visualstudio/get-started/csharp/create-a-windows-desktop-application-in-visual-studio?view=vs-2022 (дата обращения: 29.10.2025).
C# и Windows Forms | Работа с формами — Metanit. URL: https://metanit.com/sharp/wf/1.2.php (дата обращения: 29.10.2025).
C#. Урок 9. Классы и объекты. Начальное знакомство с ООП — Devpractice. URL: https://devpractice.ru/csharp-lesson-9-classes-objects-oop/ (дата обращения: 29.10.2025).