Just Developer Blog, заметки с тегом: C#

Использование QLPreviewController для просмотра файлов (iOS)

Wed, 13 Jan 2016 22:10:14 +0300

Для реализации просмотра файлов различных форматов (изображения, word, excel, txt, медиа и т. п.) в iOS существует очень удобный класс QLPreviewController. Для его удобного использования необходимо сделать следующее:

Создать класс-наследник QLPreviewController, который инкапсулирует все детали реализации
Создать класс QLPreviewControllerDataSource, который будет являться источником данных для контроллера
Создать классы-наследники QLPreviewItem, которые будут хранить информацию о просматриваемом элементе

Без лишних слов сразу взглянем на код контроллера

/// <summary>
/// Контроллер, который позволяет отобразить документы (изображения, ворд, экзель, пдф и т.п.) в виде превью
/// поддерживает несколько документов для отображения
/// </summary>
public class QuickLookPreviewController : QLPreviewController
{
    /// <summary>
    /// Отобразить список NSUrl'ов
    /// </summary>
    /// <returns><c>true</c>, if urls was previewed, <c>false</c> otherwise.</returns>
    /// <param name="urls">Urls.</param>
    public bool PreviewUrls(params NSUrl[] urls)
    {
        List<QLPreviewItem> items = new List<QLPreviewItem>();
        foreach (NSUrl url in urls)
        {
            QLPreviewItemNsUrl item = new QLPreviewItemNsUrl(url);
            if (QLPreviewController.CanPreviewItem(item))
            {
                items.Add(item);
            }
        }

        return PreviewItems(items.ToArray());
    }

    /// <summary>
    /// Отобразить список QLPreviewItem
    /// </summary>
    /// <returns><c>true</c>, if items was previewed, <c>false</c> otherwise.</returns>
    /// <param name="items">Items.</param>
    public bool PreviewItems(params QLPreviewItem[] items)
    {
        if (items.Length > 0)
        {
            DataSource = new PreviewControllerDataSource(items);
            return true;
        }

        return false;
    }

    /// <summary>
    /// QL Preview источник данных
    /// </summary>
    private class PreviewControllerDataSource : QLPreviewControllerDataSource
    {
        private QLPreviewItem[] _items = new QLPreviewItem[0];

        public PreviewControllerDataSource(params QLPreviewItem[] items)
        {
            _items = items;
        }

        public override nint PreviewItemCount(QLPreviewController controller)
        {
            return _items.Length;
        }

        public override IQLPreviewItem GetPreviewItem(QLPreviewController controller, nint index)
        {
            return _items[index];
        }
    }

    /// <summary>
    /// QL Preview Item, принимающий NSUrl
    /// </summary>
    public class QLPreviewItemNsUrl : QLPreviewItem
    {
        private NSUrl _documentUrl;

        public QLPreviewItemNsUrl(NSUrl documentUrl)
        {
            _documentUrl = documentUrl;
        }

        public override string ItemTitle
        {
            get
            {
                return _documentUrl.LastPathComponent;
            }
        }
        public override NSUrl ItemUrl
        {
            get
            {
                return _documentUrl;
            }
        }
    }

    /// <summary>
    /// QL Preview Item, принимающий имя и путь к файлу из файловой системы
    /// </summary>
    public class QLPreviewItemFileSystem : QLPreviewItem
    {
        string _fileName, _filePath;

        public QLPreviewItemFileSystem(string fileName, string filePath)
        {
            _fileName = fileName;
            _filePath = filePath;
        }

        public override string ItemTitle
        {
            get
            {
                return _fileName;
            }
        }
        public override NSUrl ItemUrl
        {
            get
            {
                return NSUrl.FromFilename(_filePath);
            }
        }
    }

    /// <summary>
    /// QL Preview Item, принимающий имя ипуть к файлу из бандла
    /// </summary>
    public class QLPreviewItemBundle : QLPreviewItem
    {
        string _fileName, _filePath;
        public QLPreviewItemBundle(string fileName, string filePath)
        {
            _fileName = fileName;
            _filePath = filePath;
        }

        public override string ItemTitle
        {
            get
            {
                return _fileName;
            }
        }
        public override NSUrl ItemUrl
        {
            get
            {
                var documents = NSBundle.MainBundle.BundlePath;
                var lib = Path.Combine(documents, _filePath);
                var url = NSUrl.FromFilename(lib);
                return url;
            }
        }
    }
}

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

QuickLookPreviewController previewController = new QuickLookPreviewController();
if (previewController.PreviewUrls(new NSUrl[]{ fileUrl }))
{
    this.NavigationController.PushViewController(previewController, true);
}

Использование Fragment без UI для хранения данных

Fri, 19 Jun 2015 21:01:03 +0300

Fragment — это сущность, позволяющая инкапсулировать часть интерфейса и его логику для переиспользования. Фрагменты были представлены в Android 3.0 и позволили существенно упростить работу по проектированию интерфейса для устройств с различными размерами экранов (так называемая парадигма Responsive Design, когда одно и то же приложение выглядит по разному на устройствах с различной диагональю экрана).

Фрагменты очень удобны и обладают следующими основными свойствами:

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

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

Для многих начинающих разработчиков, пришедших с десктопных платформ, может стать настоящим откровением поведение Android например при изменении ориентации устройства — в таком случае Activity будет уничтожена и создана вновь с лэндскейпным лэйаутом. Соответственно если к Activity привязан какой-либо источник данных — он будет так же пересоздан (или перезагружен, в случае ContentProvider).

Чтобы этого не произошло можно создать специальный фрагмент без UI и передать в его конструкторе значение true в сеттер setRetainInstance (Java), либо установить значение true свойству RetainInstance (C#). Далее инициализировать и сохранить в нём нашу модель.

Все, после подобных манипуляций получим постоянный доступ к модели с сохранением её состояния даже при пересоздании родительской Activity.

Ниже небольшой пример кода на C# и Xamarin:

/// <summary>
/// Фрагмент без интерфейса, будет хранить нашу модель
/// (данный фрагмент будет ретейниться после уничтожения основной вьюхи и наши данные не будут перегенериваться при пересоздании Activity)
/// </summary>
public class ModelHolderFragment : Android.App.Fragment{
	public static string SearchTag = "MODEL_HOLDER_FRAGMENT";

	public ViewPagerItem[] DataSourceItems { get; private set;}

	public override void OnCreate (Bundle savedInstanceState)
	{
		base.OnCreate (savedInstanceState);

		DataSourceItems = GenViewPagerItems ();

		//установим флаг, который запретит фрагменту умирать при уничтожении основной вьюхи
		RetainInstance = true;
	}

	/// <summary>
	/// Генерация фейковых данных
	/// </summary>
	/// <returns>The view pager items.</returns>
	private ViewPagerItem[] GenViewPagerItems(){
		...
		return items;
	}
}

///Хэндлер события OnCreate родительской Activity - тут создадим экземпляр нашего фрагмента
protected override void OnCreate(Bundle savedInstanceState) {
	base.OnCreate(savedInstanceState);
	SetContentView (Resource.Layout.activity_main);

	//инициализируем фрагмент без интерфейса для хранения модели только при первом создании вьюхи
	if (savedInstanceState == null) {
		FragmentManager.BeginTransaction ().Add ((Android.App.Fragment)new ModelHolderFragment (), ModelHolderFragment.SearchTag).Commit();
		FragmentManager.ExecutePendingTransactions ();
	}
	_model = (ModelHolderFragment)FragmentManager.FindFragmentByTag (ModelHolderFragment.SearchTag);
}

Использование паттерна ViewHolder

Wed, 17 Jun 2015 10:56:43 +0300

С этой статьи я бы хотел начать цикл кратких заметок о разработке под мобильные устройства. Приложения под телефоны и планшеты — мое давнее увлечение. К сожалению плотно заняться которым, в силу различных обстоятельств, я смог только сейчас. В прочем хватит лирики, начнём. В качестве платформы я выбрал Android, как наиболее массовую и открытую систему. В качестве языка программирования сегодня будем использовать C#, писать будем на Xamarin с использованием Android API.

Практически любое мобильное приложение это некий экран с набором однотипных информационных элементов, для отображения которых обычно используется список или какой-либо грид. Из-за того, что платформа мобильная и работает на устройстве с небольшим объёмом памяти и слабым процессором (хаха! В моем первом компьютере было памяти раз в 15 меньше и процессор существенно слабее, чем сейчас в среднем телефоне) операционная система вынуждена ресурсы экономить. Соответственно если речь идёт о списке (ListView в Android), а если точнее об адаптере, который предоставляет данные для списка (например ArrayAdapter в Android) мы сталкиваемся с одной из особенностей, вызванных необходимостью беречь ресурсы.

Такая особенность заключается в том, что лист не создаёт ячейки под каждую из записей подключенного источника данных. Он создаёт лишь то количество ячеек, сколько может уместиться на экране в данный момент плюс по одной лишней ячейке сверху и снизу. Такое поведение характерно не только для Android, но и для iOS.

При этом когда пользователь прокручивает список система не удаляет ячейки, она старается их переиспользовать.

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

Все бы ничего, но если лэйаут ячейки сложный то мы напрямую сталкиваемся с необходимостью проводить поиск элементов в лэйауте (TextView, ImageView и т. п.) для заполнения их актуальными данными. Вроде бы ничего страшного, вызвал FindViewById() с нужным id элемента, получил его и нет проблем, но выполнение метода FindViewById() это длительная операция, потому что она тянет за собой траверс по XML-коду лэйаута нашей ячейки. В итоге на сложных лэйаутах имеем просадку по производительности скроллинга списка.

Чтобы решить данную проблему нам необходимо использовать паттерн ViewHolder. Кратко его суть заключается в следующем:

Реализуем класс, который в конструкторе принимает нашу View, делает траверс и ищет все её элементы, которые нам потребуются для заполнения данных;
Записываем ссылки на эти элементы в соответствующие поля класса, снабжаем их геттерами, чтобы потом к ним обращаться;
При создании нашей View — создаём наш класс-ViewHolder и записываем ссылку на него в свойстве Tag у нашей View;
Теперь при попытке переиспользовать View нам не нужно делать повторный поиск элементов в лэйауте, достаточно получить ссылку на ViewHolder из свойства Tag и обратиться к соответствующим геттерам холдера;
PROFIT.

Если делать реализацию на Java сложностей возникнуть не должно, но если использовать C# и Xamarin мы столкнемся с корнями, растущими из Java :-)

Предположим есть такой класс:

public class MyViewHolder{
public TextView MyTextView {get; private set;}

public MyViewHolder(View view){
...
}
}

Если теперь попытаться присвоить ссылку на него свойству Tag нашей View у нас ничего не получится. Поскольку Tag принимает объект типа Java.Lang.Object, а наш класс наследован от типа Object. Прямое кастование к нужному типу так же не приведёт к успеху. Кастование сначала к Object, а потом к Java.Lang.Object не даст ошибки компиляции, зато упадёт в рантайме.

Что же делать? Все просто :-) наследовать наш класс от типа Java.Lang.Object и будет счастье!

Небольшой пример того, как все это работает:

public class TimetableItemAdapter : ArrayAdapter<TimetableItem>
{
	/// <summary>
	/// Класс ViewHolder, нужен что бы исключить множественный траверс по элементам вьюхи, для производительности
	/// </summary>
	public class TimetableItemViewHolder : Java.Lang.Object{
		public TextView TimeText { get; private set;}
		public TextView DescriptionText { get; private set;}
		public ImageView AcceptButton { get; private set;}

		public TimetableItem BoundedItem { get; set;}

		public TimetableItemViewHolder(View view, TimetableItem item){
			TimeText = view.FindViewById<TextView>(Resource.Id.timetable_time_text);
			DescriptionText = view.FindViewById<TextView>(Resource.Id.timetable_description_text);
			AcceptButton = view.FindViewById<ImageView>(Resource.Id.timetable_accept);

			BoundedItem = item;
		}
	}

	private MainActivity _context;

	public TimetableItemAdapter(Context context, int resource, IList<TimetableItem> objects) : base(context, resource, objects) {
		_context = (MainActivity)context;
	}
			
	public override View GetView(int position, View convertView, ViewGroup parent) {
		View resultView = null;
		TimetableItemViewHolder holder = null;
		TimetableItem item = GetItem(position);

		if(convertView != null){
			resultView = convertView;
			holder = (TimetableItemViewHolder)convertView.Tag;
			holder.BoundedItem = item;
		}else{
			resultView = ((LayoutInflater)_context.GetSystemService(Context.LayoutInflaterService))
				.Inflate(Resource.Layout.timetable_list_item, parent, false);
			holder = new TimetableItemViewHolder(resultView, item);
			resultView.Tag = holder;
		}

		if(item != null && holder != null){
			holder.TimeText.Text = item.Time;
			holder.DescriptionText.Text = item.Description;
		}

		return resultView;
	}
}

Во ViewHolder не обязательно хранить только ссылки на элементы лэйаута, иногда может потребоваться хранить и какие-либо сопутствующие данные. Например в коде выше во ViewHolder записывается дополнительно ссылка на элемент из источника данных, для последующего использования где-нибудь. Но в данном случае нужно помнить, что при переиспользовании View нужно не забыть записать в свойство ссылку на новый элемент источника данных.

Универсальный импортировщик заявок на стеклопакеты

Sat, 07 Feb 2015 15:03:25 +0300

Одной из задач последних двух месяцев было написание универсального средства для импорта заявок на стеклопакеты (далее СП). Почему нужно именно универсальное средство и в чем его универсальность, спросите вы.

Для любого крупного производителя СП рано или поздно встает вопрос об автоматизированном приеме заявок от клиентов. Поток заказов (заявок) растет, вносить их вручную становится экономически не выгодно. Очень крупные предприятия (например СТИС) могут себе позволить разработать собственный формат заявки и заставить своих клиентов использовать только его, но заводы поменьше не могут себе позволить такую роскошь — им приходится принимать заявки в том формате, в котором хочет клиент. На такие предприятия и рассчитывалось данное универсальное средство импорта.

Формат заявки может очень сильно отличаться, наиболее распространенным естественно является обычный Excel, некоторые клиенты отправляют заявку в формате CSV. Самые суровые формируют заявку в WORD или просто пишут на бумажке, сканируют и отправляют по электронной почте.

На данный момент средство импорта имеет поддержку Excel, CSV и Word, но в данной статье мы опишем только импорт из Excel и CSV. Поддержку Word добавлял мой коллега и друг Евгений Мельник, если он захочет — расскажет про этот вид импорта.

Итак основные задачи, которые ставились перед нами:

—Разработать архитектуру, предоставляющую инфраструктуру для импорта заявок;
—Должна быть возможность легко добавлять новые форматы файлов для импорта без правки архитектуры, простой реализацией собственных классов;
—Должна быть возможность создавать шаблоны для импорта под каждого конкретного контрагента;
—Средство импорта должно преобразовывать любой бред, написанный контрагентом в заявке в понятные основному ПП данные, это в первую очередь касается формулы СП (об этом поговорим отдельно);
—Создать интерфейс, позволяющий выбрать соответствующий шаблон и импортировать заявку;
—Добавить административный интерфейс, позволяющий создавать, редактировать и удалять шаблоны заявок;
—Предоставить возможность разграничить права на интерфейсы пользователя;
—Полная интеграция с основным ПП нашей компании — winDraw;
—Используем C# 2.0 и компоненты DevExpress 10.2.

Говоря о шаблонах для каждого контрагента и преобразовании его данных в данные, понятные основному ПП нужно понимать одну особенность производства СП.

Видов стеклопакетов существует огромное количество, и речь идет не только об их форме, но в первую очередь об их формуле. Пакет может быть однокамерным (состоять из 2-х стекол и одной рамки), а может быть двухкамерным (состоять из 3 стекол и двух рамок). Также может сильно отличаться тип стекол в пакете, это может быть просто 4-мм стекол, а может быть и 5-мм, 6-мм. Стекло может быть закаленным, армированным, это может быть триплекс (состоит из трех стекол, склеенных между собой). На стекло может быть наклеена пленка, бронировочная или просто цветная. Она может быть наклеена только на 1-е стекло, а может и на оба. Размер камеры (толщина дистанционной рамки) может существенно различаться. В камеру может быть закачан аргон или другой газ.

Как вы видите нюансов очень много. Специально, что бы установить хоть какую-то систему во всем этом многообразии был разработан ГОСТ, описывающий СП в целом и маркировку СП в частности ГОСТ 24866-99. Но большинство клиентов не стремятся использовать стандарт, им просто нужно получить свои стеклопакеты. И тут начинается самое интересное. Клиент пишет вместо стандартного разделителя «x» тире «-» или пробел. Либо просто пишет в заявке «Двухкамерный СП из стекла 4мм». Описываемые клиентом маркировки стекол могут существенно отличаться от маркировок, указанных в программе.

Поскольку предусмотреть все варианты написания того или иного стекла или рамки физически невозможно, было принято решение — для каждого клиента создать таблицу замен его написания на наше. Но, если использовать таблицу замен может возникнуть проблема литерал AR, описывающий аргон легко может поломать строку HP CARBON 05, которая описывает пленку. Т.е, что бы таблица замен работала корректно нужно производить поиск и замену сначала самых длинных литералов, а затем более коротких. Необходимо просто вычислить длину строки при добавлении и хранить ее рядом с литералом для замены, тогда определение порядка просмотра таблицы становится очевидным.

Простая заявка на СП выглядит следующим образом:

Если проанализировать ее формат становится ясно, что состоит она из 2-х частей:

—Заголовочная часть, которая содержит основную информацию о компании-клиенте, номере заявки, дате отправки и желаемой дате получения стеклопакетов;
—Табличной части с формулами СП, их размерами и количеством.

Стало ясно, что наиболее простым внутренним представлением данных будем именно табличный формат, используем DataTable как основное хранилище исходных данных

Была разработана следующая архитектура, рассмотрим ее подробнее:

Основу всего составляют 3 интерфейса:

—IDataProvider — этот интерфейс реализуют классы, которые предоставляют данные для импорта. Т. е. преобразуют исходный файл в понятную ядру таблицу;
—IDataParser — интерфейс, который позволит реализовать классы, преобразующие клиентский бред в понятные нам данные (организует работу с таблицей замен, преобразует строки в числа, разложит формат габаритных размеров СП в понятные нам два числа);
—IXmlSerializable — нужен для сериализации/десериализации шаблонов клиентов.

Рассмотрим код наших интерфейсов:

interface IDataParser<T>
{
    T Parse(string val, DocumentTemplate template);
}
...
interface IDataProvider
{
     /// <summary>
    /// Возвращает тип провайдера (Excel, CSV, Word и т.д.)
    /// </summary>
    string ProviderType { get; }

    /// <summary>
    /// Необходимо задавать фильтр расширений для файла, загружаемого провайдером
    /// </summary>
    string FileExtensionFilter { get; }

    /// <summary>
    /// Загружает данные и возвращает таблицу для разбора
    /// </summary>
    /// <returns>Таблица для разбора</returns>
    DataTable LoadData();
}
...
interface IXmlSerializable
{
    XmlElement Serialize(XmlDocument doc);
    bool Deserialize(XmlElement element);
}

Все выглядит очень просто. Стоит отдельно сказать про класс DocumentTemplate, это как раз то место, в котором хранится вся информация о шаблоне под конкретного клиента, а именно:

—Какой формат используется для загрузки этого шаблона (какой провайдер данных);
—С какой строки начинается табличная часть;
—Какую колонку нужно анализировать в табличной части, что бы понять, что она закончилась (просто смотрит, если в колонке нет данных — значит табличная часть закончилась);
—Хранит список экземпляров класса TemplateField для табличной части и заголовочной части (TemplateField описывает конкретное поле в таблице, его номер строки и колонки, внутреннее имя, содержит описание);
—Хранит таблицу замен для преобразования формул СП клиента в формулы СП основной программы;
—Хранит объект типа CustomerInformation, описывающий данные клиента (id клиента, его наименование), для подстановки в сформированный заказ после импорта;
—Реализует методы интерфейса IXmlSerializable для сериализации/десериализации.

Шаблон сам по себе ничего не делает, он просто хранит данные. Сердцем всего является класс DataLoader

Код данного класса особо ничем не примечателен, за исключением кода загрузки заявки по выбранному шаблону:

/// <summary>
/// Загружает заявку по выбранному шаблону
/// </summary>
/// <param name="template"></param>
private void LoadTemplate(DocumentTemplate template)
{
    if(template == null) return;

    //выберем провайдер и инициализируем его
    IDataProvider provider = null;
    if (template.Type == "Excel") provider = new ExcelDataProvider();
    if (template.Type == "Word") provider = new WordDataProvider();

    if (provider == null)
    {
        throw new ApplicationException("Ошибка при поиске провайдера данных для шаблона с типом \"" + template.Type + "\"");
    }

    //загрузим данные через провайдер
    DataTable dtData = provider.LoadData();
    if (dtData == null)
    {
        throw new ApplicationException("Ошибка при загрузке данных из файла");
    }

    //получим массивы заголовочных полей и табличных полей, что бы найти данные в таблице, предоставленной провайдером
    DocumentTemplate.TemplateField[] headerFields = template.HeaderFields;
    DocumentTemplate.TemplateField[] tableFields = template.TableField;

    //инициализируем класс, который работает с заказом winDraw, вся спицифичная кухня, касающаяся winDraw происходит внутри
    OrderData orderData = new OrderData();

    //далее используя шаблон и таблицу от провайдера будем заполнять данные в OrderData
    if (template.Customer != null)
    {
        orderData.CustomerInformation = template.Customer.Clone();
    }

    //сначала вытащим все данные из шапки
    foreach (DocumentTemplate.TemplateField field in headerFields)
    {
        switch (field.Name)
        {
            case "customer":
                orderData.Customer = GetHeaderStringData(field, dtData);
                break;

            case "shipmentAddress":
                orderData.ShipmentAddress = GetHeaderStringData(field, dtData);
                break;

            case "comment":
                orderData.Comment = GetHeaderStringData(field, dtData);
                break;

            case "dateApplication":
                orderData.DateApplication = GetHeaderStringData(field, dtData);
                break;

            case "dateShipment":
                orderData.DateShipment = GetHeaderStringData(field, dtData);
                break;
        }
    }

    //теперь вытащим все данные из табличной части
    for (int idx = template.TablePartStartRow; idx < dtData.Rows.Count; idx++)
    {
        DataRow currentRow = dtData.Rows[idx];
        //условие прекращения работы цикла, когда данные в таблице закончились
        if(currentRow[template.TablePartEndColumn] == DBNull.Value || string.IsNullOrEmpty(currentRow[template.TablePartEndColumn].ToString())) break;

        OrderData.OrderPositionData position = orderData.AddNewPosition();

        DocumentTemplate.TemplateField fieldWidth = null;
        DocumentTemplate.TemplateField fieldHeight = null;

        foreach (DocumentTemplate.TemplateField field in tableFields)
        {
            switch (field.Name)
            {
                case "formula":
                    position.Formula = GetTableFormulaData(field, currentRow, template);
                    break;

                case "width":
                    fieldWidth = field;
                    break;

                case "height":
                    fieldHeight = field;
                    break;

                case "qu":
                    position.Qu = GetTableIntData(field, currentRow);
                    break;

                case "comment":
                    position.Comment = GetTableStringData(field, currentRow);
                    break;

                case "orderName":
                    position.OrderName = GetTableStringData(field, currentRow);
                    break;
            }
        }

        if(fieldWidth == null || fieldHeight == null) throw new ApplicationException("Ошибка при загрузке полей Ширина, Высота");

        //если колонка ширины равна колонке высоты - значит наш клиент пишет ширину и высоту через спец сепаратор :)
        if (fieldWidth.Column == fieldHeight.Column)
        {
            if (currentRow[fieldWidth.Column] != DBNull.Value)
            {
                string val = currentRow[fieldWidth.Column].ToString();

                //тут применен такой хитрый хак, из-за того, что для Word нужно более одного сепаратора при расчленении строки
                string[] separators = template.WidthHeightSeparator.Split(new char[] {'|'});
                string[] par = val.Split(separators,
                    StringSplitOptions.RemoveEmptyEntries);

                position.Width = _intParser.Parse(par[0], template);
                position.Height = _intParser.Parse(par[1], template);
            }
        }
        else
        {
            //иначе наш клиент молодец и пишет ширину/высоту в разных столбцах
            position.Width = GetTableIntData(fieldWidth, currentRow);
            position.Height = GetTableIntData(fieldHeight, currentRow);
        }
    }

    //в финале создаем заказ
    orderData.CreateOrder();
}

Интерес так же могут вызвать методы:

private string GetHeaderStringData(DocumentTemplate.TemplateField field, DataTable dtData)
private string GetTableStringData(DocumentTemplate.TemplateField field, DataRow currentRow)
private string GetTableFormulaData(DocumentTemplate.TemplateField field, DataRow currentRow, DocumentTemplate template)
private int GetTableIntData(DocumentTemplate.TemplateField field, DataRow currentRow)

Это всего лишь обертки над классами-парсерами, реализующими интерфейс IDataParser. Рассмотрим их подробнее:

/// <summary>
/// Строковый парсер
/// </summary>
public class StringDataParser : IDataParser<string>
{
    public string Parse(string val, DocumentTemplate template)
    {
        return val.Trim();
    }
}

/// <summary>
/// Парсер чисел
/// </summary>
public class IntDataParser : IDataParser<int>
{
    public int Parse(string val, DocumentTemplate template)
    {
        return Convert.ToInt32(GetOnlyNumericInformation(val));
    }

    /// <summary>
    /// Оставляет только ту информацию, которая относится к числовой (числа, знаки , и .)
    /// Так же исключает сливание вместе двух чисел, например:
    /// ,113,33 443 - будет равно 133,33
    /// </summary>
    /// <param name="val"></param>
    /// <returns></returns>
    private string GetOnlyNumericInformation(string val)
    {
        val = val.Trim();
        bool digitsStarted = false;

        StringBuilder sb = new StringBuilder();
        for (int idx = 0; idx < val.Length; idx++)
        {
            char c = val[idx];

            if (IsNumericChar(c))
            {
                if (!digitsStarted) digitsStarted = true;
                sb.Append(c);
            }
            else
            {
                if(digitsStarted) break;
            }
        }

        string result = sb.ToString().Trim(',').Trim('.');
        return result.Replace(',', '.');
    }

    /// <summary>
    /// Свой вариант метода char.IsDigit, считает числовым еще и символы: . ,
    /// </summary>
    /// <param name="c"></param>
    /// <returns></returns>
    private bool IsNumericChar(char c)
    {
        return char.IsDigit(c) || c == ',' || c == '.';
    }
}

/// <summary>
/// Парсер формулы СП
/// </summary>
public class FormulaDataParser : IDataParser<string>
{
    public string Parse(string val, DocumentTemplate template)
    {
        foreach (DataRow dr in template.DtChanges.Select("", "complexity DESC"))
        {
            string searchString = dr["search"].ToString();
            string replaceString = dr["replace"].ToString();

            val = val.Replace(searchString, replaceString);
        }

        return val;
    }
}

Самое интересное происходит в классе FormulaDataParser, тут мы видим как преобразовать формулу СП клиента в понятную нам формулу, используя таблицу замен. При этом в поле complexity хранится длина исходной строки, что бы организовать последовательность просмотра таблицы в правильном порядке

И в конце хочется показать что же получилось, как выглядит интерфейс пользователя:

Окно, которое видит менеджер. Можно выбрать шаблон заявки и импортировать ее

Окно, которое видит администратор по конкретной заявке. Можно настроить все параметры полей (заголовочных и табличных), а так же заполнить таблицу замен

Реализация механизма плагинов в программе

Sun, 04 Jan 2015 23:31:19 +0300

Рано или поздно практически любой разработчик популярной программы сталкивается с необходимостью реализации возможности написания плагинов для нее. Лучше, если данная возможность заложена изначально. Наиболее простым путем в реализации такого функционала является создание специального интерфейса (например IPlugin). Данный интерфейс может содержать все необходимые методы и свойства для класса, работающего в инфраструктуре плагинов. Позже программа при загрузке сборки с плагином будет искать все классы, реализующие этот интерфейс, инстанциировать их как плагины и отображать их список в интерфейсе пользователя.

В основе работы всей инфраструктуры плагинов лежит такая возможность Microsoft .NET Framework как Рефлексия (пространство имен System.Reflection, более подробно можно почитать на MSDN)

У меня есть векторный редактор, который имеет три типа «кистей»:

— Кисти рисования
— Кисти для редактирования уже нарисованных примитивов (обрезка линий, удлинение линий и т. п.)
— Кисти для реализации расчетного функционала (простой пример — посчитать длины определенных элементов на чертеже)
Будем использовать его как пример реализации инфраструктуры для работы плагинов.

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

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

Первым шагом необходимо реализовать интерфейс для каждого типа кисти (исходные интерфейсы в редакторе довольно сложны, имеют много методов и свойств, в примере они намеренно упрощены)

Обычно простейший интерфейс для плагина может выглядеть следующим образом:

public interface IPlugin
{
	//Возвращает наименование плагина
	string Name { get; }

	//Инициализирует плагин
	void Init();

	//Метод, который собственно делает всю работу плагина
	void DoWork();
}

Из кода становится ясно, что после инстанциации плагинов достаточно получить имя каждого (поле Name), вывести этот список в интерфейс. После чего когда пользователь выберет определенный плагин — вызвать его метод Init(), который инициализирует его и затем вызвать метод DoWork(), который сделает уже работу плагина.

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

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

public interface IDrawObject
{
	//Возвращает строковый ID кисти
	string Id { get; }
	
	//Клонирует кисть
	IDrawObject Clone();

	//Отрисовывает примитив кисти
	void Draw(ICanvas canvas, RectangleF unitrect);

	//Инициализирует новый экземпляр кисти
	void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap)
}

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

public interface IEditTool
{
        //Возвращает строковый ID кисти
        string Id { get; }

        //Клонирует кисть
	IEditTool Clone();

        //Реализация логики кисти, обработка нажатия на экран
	public DrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
}

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

public interface ICalcTool
{
        //Возвращает строковый ID кисти
        string Id { get; }

        //Клонирует кисть
        ICalcTool Clone();

        //Запускает расчетный алгоритм кисти
        void PerformCalc(IModel model);
}

Следующим этапом для каждого типа кисти необходимо реализовать атрибут, позволяющий добавить дополнительную информацию к кисти (ее имя, описание, имя файла иконки, хоткей для запуска и т. п.). Пример для кисти рисования:

/// <summary>
/// Атрибут, описывающий графический объект
/// </summary>
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public class DrawToolAttribute : Attribute
{
        /// <summary>
        /// Имя кисти рисования
        /// </summary>
        public string Name { get; private set; }
        /// <summary>
        /// Описание кисти рисования
        /// </summary>
        public string Description { get; private set; }
        /// <summary>
        /// Изображение для кнопки кисти рисования
        /// </summary>
        public string GlyphFileName { get; private set; }
        /// <summary>
        /// Горячая клавиша
        /// </summary>
        public Keys Shortcut { get; private set; }

        public DrawToolAttribute()
        {
            Name = string.Empty;
            Description = string.Empty;
            GlyphFileName = string.Empty;
            Shortcut = Keys.None;
        }

        /// <summary>
        /// В конструкторе передаем все необходимые параметры для описания кисти
        /// </summary>
        public DrawToolAttribute(string name, string description, string glyphFileName, Keys shortcut)
        {
            if (name == null) throw new ArgumentNullException("name");
            if (description == null) throw new ArgumentNullException("description");
            if (glyphFileName == null) throw new ArgumentNullException("glyphFileName");

            Name = name;
            Description = description;
            GlyphFileName = glyphFileName;
            Shortcut = shortcut;
        }
}

//Аналогичным способом реализованы атрибуты для кисти редактирования и кисти расчета:
public class EditToolAttribute : Attribute
{
...
}

public class CalcToolAttribute : Attribute
{
...
}

Перед определением заголовка класса атрибута использован специализированный атрибут AttributeUsage, который позволяет описать возможные применения создаваемого атрибута, в нашем случае атрибуты должны применяться только к классу. Так же устанавливается свойство Inherited в значение false, которое запрещает наследование атрибута производными классами (если имеется базовый класс, к которому применен наш атрибут, то при наследовании от этого класса наш атрибут наследоваться не будет).

Так же стоит знать, что любой новый атрибут должен наследоваться от класса Attribute, это является обязательным условием.

Ниже пример использования нашего атрибута при создании плагина с кистью рисования «Креста»

[DrawTool("Крест", "Инструмент рисования креста", "cross_tool.png", (System.Windows.Forms.Keys.Control | System.Windows.Forms.Keys.R))]
class Cross : IDrawObject
{
...
}

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

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

— Последовательно загружать сборки (с расширением dll) с диска
— Для каждой сборки получать все типы, находящиеся в этой сборке
— Для каждого типа получить список его кастомных атрибутов
— Проверить, реализует ли тип один из интерфейсов плагинов (IDrawObject, IEditTool, ICalcTool)
— Проверить, имеет ли тип один из атрибутов, описывающих кисть
— Если описанные выше условия выполняются — то необходимо инстанциировать кисть и добавить ее в соответствующий список.

В работе всего этого хозяйства будут использоваться классы из пространства имен System.Reflection, а именно следующие:

— Assembly, представляет саму сборку
— Activator, предоставляет возможность инстанциировать экземпляр класса
— MemberInfo, предоставляет сведения об атрибутах компонента и дает доступ к его свойствам
— Так же используем метод IsAssignableFrom класса Type, который позволяет определить унаследован ли наш тип от другого типа

static class PluginManager
{
        /// <summary>
        /// Загружать ли плагины при старте
        /// </summary>
        public static bool IsLoadPlugins = false;

        /// <summary>
        /// Возвращает список объектов рисования
        /// </summary>
        public static IEnumerable<IDrawObject> DrawObjectInstances { get; private set; }
        /// <summary>
        /// Возвращает список кистей редактирования
        /// </summary>
        public static IEnumerable<IEditTool> EditToolInstances { get; private set; }
        /// <summary>
        /// Возвращает список расчетных инструментов
        /// </summary>
        public static IEnumerable<ICalcTool> CalcToolInstances { get; private set; }

        /// <summary>
        /// Флаг об успешной загрузке сборок плагинов
        /// </summary>
        public static bool IsPluginsLoaded
        {
            get
            {
                if (_pluginCache == null || _pluginCache.Count == 0) return false;
                return true;
            }
        }

        /// <summary>
        /// Загружает все модули в словарь и возвращает его
        /// </summary>
        public static bool LoadAllModules(string path)
        {
            InitCollections();

            if (!IsLoadPlugins)
            {
                return false;
            }

            if (string.IsNullOrEmpty(path)) return false;

            foreach (string fileName in Directory.GetFiles(path/*, "*.dll"*/))
            {
                Assembly asm = null;
                string asmPath = Path.Combine(path, fileName);
                bool isAsm = false;
                bool isPlugin = false;

                try
                {
                        asm = Assembly.LoadFile(asmPath);

                        foreach (Type type in asm.GetTypes())
                        {
                            foreach (Attribute attribute in type.GetCustomAttributes(typeof (Attribute), true))
                            {
                                //кисти рисования
                                if (
                                    //если тип поддерживает соответствующий атрибут
                                    attribute is DrawToolAttribute
                                    &&
                                    //и отвечает соответствующему интерфейсу
                                    typeof (IDrawObject).IsAssignableFrom(type)
                                    )
                                {
                                    //инстанциируем экземпляр кисти из плагина
                                    DrawObjectInstances.Add(Activator.CreateInstance(type) as IDrawObject);
                                    break;
                                }

                                //кисти редактирования
                                if (
                                    //если тип поддерживает соответствующий атрибут
                                    attribute is EditToolAttribute
                                    &&
                                    //и отвечает соответствующему интерфейсу
                                     typeof (IEditTool).IsAssignableFrom(type)
                                    )
                                {
                                    //инстанциируем экземпляр кисти из плагина
                                    EditToolInstances.Add(Activator.CreateInstance(type) as IDrawObject);
                                    break;
                                }

                                //расчетные кисти
                                if (
                                    //если тип поддерживает соответствующий атрибут
                                    attribute is CalcToolAttribute
                                    &&
                                    //и отвечает соответствующему интерфейсу
                                     typeof (ICalcTool).IsAssignableFrom(type)
                                    )
                                {
                                    //инстанциируем экземпляр кисти из плагина
                                    CalcToolInstances.Add(Activator.CreateInstance(type) as IDrawObject);
                                    break;
                                }
                            }
                        }
                }
                catch(ApplicationException ex)
                {
                    MessageBox.Show("Ошибка при загрузке плагина из сборки " + fileName, "Ошибка", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }

            return true;
        }

        /// <summary>
        /// Инициализирует пустые коллекции элементов плагинов (необходимо для случая, когда редактор загружается с выключенной возможностью использования плагинов, просто инициализирует пустые коллекции кистей)
        /// </summary>
        private static void InitCollections()
        {
            DrawObjectInstances = new List<IDrawObject>();
            EditToolInstances = new List<IEditTool>();
            CalcToolInstances = new List<ICalcTool>();
        }
}

Вот собственно и все, что следовало написать по этой теме. Остается только вызвать метод LoadAllModules() для загрузки плагинов и забрать свой плагин из соответствующей коллекции.

В качестве завершения, из статьи мы получили следующую информацию:

— Узнали, как построить простую (и не совсем простую) инфраструктуру плагинов для своей программы
— Рассмотрели реализацию простейшего интерфейса для плагина
— Узнали как реализовать собственный атрибут
— Разобрались с тем, как загружать сборки с диска, искать в них типы и получить список атрибутов этих типов
— Узнали как инстанциировать типы при помощи класса Activator

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

Пример использования Обобщений (Generics) в C#

Sat, 03 Jan 2015 13:43:56 +0300

Давеча потребовалось реализовать инфраструктуру объектов-оберток для редактора роллет.

Исходная задача была следующей:
— Есть построитель роллет, который имеет ряд коллекций с объектами разных типов, описывающими один из элементов роллеты (привод, направляющая, ламель и т. п.)
— Необходимо реализовать логику расчета роллеты по уже заполненному списку параметров
— Внутренние типы построителя наследуются от базового класса RollCalc.Model.CommonProperties

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

Построим инфраструктуру следующим образом:

— Реализуем абстрактный базовый класс RollCalcElementBase, который будет содержать всю логику по заполнению общих полей для всех типов-наследников. Почему именно базовый класс, а не интерфейс? Чтобы не париться с реализацией базовой логики в каждом классе-наследнике.
— В базовом классе обязательно реализуем метод public virtual void InitFromPresentationObject(T presentationObject), который будет инициализировать экземпляр базового класса по его представлению из объекта редактора роллет
— Реализуем произвольное количество классов-наследников от RollCalcElementBase, в которых можно будет расширить функционал базового класса или переопределить его
— В основном классе программы создадим коллекции наших объектов-наследников
— Там же, в основном классе добавим метод, создающий наши объекты по коллекциям объектов редактора
— Плюс нужен будет метод, получающий экземпляр одного из наших объектов по его типу и наименованию (так уж сложилось, что расчет спецификации роллеты сильно зависит от производителя, а значит и от артикула того или иного элемента)

Весь код был упрощен, что бы не раздувать статью.

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

Код базового класса и классов-наследников:

/// <summary>
    /// Базовый класс элемент роллет
    /// Обратите внимание на предложение where
    /// where T : RollCalc.Model.CommonProperties - накладываем ограничение на использование типа в обобщенном классе, только тип элемента построителя роллет
    /// </summary>
    /// <typeparam name="T">Элемент построителя роллет</typeparam>
    public abstract class RollCalcElementBase<T> where T : RollCalc.Model.CommonProperties
    {
        public string Name { get; set; }

        private bool _enabled;

        public bool Enabled
        {
            get { return _enabled; }
            set
            {
                _enabled = value;
                if (PresentationObject != null) PresentationObject.Visible = value;
            }
        }
        public T PresentationObject { get; set; }

        /// <summary>
        /// Инициализировать из объекта роллеты
        /// </summary>
        /// <param name="presentationObject">объект роллеты</param>
        public virtual void InitFromPresentationObject(T presentationObject)
        {
            Name = presentationObject.Description;
            Enabled = presentationObject.Visible;
            PresentationObject = presentationObject;

            presentationObject.Tag = this;
        }
    }

    /// <summary>
    /// Профиль ламели
    /// </summary>
    public class Profile : RollCalcElementBase<LamellaProfile>
    {
    }

    /// <summary>
    /// Тип короба
    /// </summary>
    public class Collar : RollCalcElementBase<ProtectiveCollarType>
    {
    }

    /// <summary>
    /// Привод роллеты
    /// </summary>
    public class Drive : RollCalcElementBase<DriveSystem>
    {
        public int MaxWeight { get; set; }

        public bool CalcEnabled(decimal rollWidth)
        {
            Enabled = rollWidth <= MaxWeight;
            return Enabled;
        }

        public override void InitFromPresentationObject(DriveSystem presentationObject)
        {
            object tag = presentationObject.Tag;

            base.InitFromPresentationObject(presentationObject);

            if (tag is int)
            {
                MaxWeight = Convert.ToInt32(tag);
            }
        }
    }

Код из основного класса (коллекции наших объектов, а так же методы загрузки и получения экземпляра нашего объекта:

private List<Drive> _drives = new List<Drive>();
        public List<Drive> Drives {get { return _drives; }}

        private List<Profile> _profiles = new List<Profile>();
        public List<Profile> Profiles{get { return _profiles; }}

        private List<Collar> _collars = new List<Collar>();
        public List<Collar> Collars{get { return _collars; }}

        /// <summary>
        /// Загрузка и связывание элемента из списка элементов построителя роллет
        /// Обратите внимание на предложения where в заголовке метода
        /// where T : RollCalc.Model.CommonProperties - ограничивает нас по исходному типу объекта роллеты
        /// where T2 : RollCalcElementBase<T>, new() - вводит следующее ограничение: наследник базового класса RollCalcElementBase<T>, имеющий конструктор без параметров (т.е. именно НАСЛЕДНИК, подставить сюда базовый класс уже не получится, поскольку он абстрактный и сконструировать его мы не сможем
        /// </summary>
        /// <typeparam name="T">элемент построителя</typeparam>
        /// <typeparam name="T2">наш связанный элемент</typeparam>
        /// <param name="list"></param>        
        public void LoadFromElementList<T, T2>(IList<T> list)
            where T : RollCalc.Model.CommonProperties
            where T2 : RollCalcElementBase<T>, new()
        {
            List<T2> elements = new List<T2>();

            //создаем наши объекты по объектам построителя, складываем их в список
            foreach (T sourceElement in list)
            {
                T2 element = new T2();
                element.InitFromPresentationObject(sourceElement);
                elements.Add(element);
            }

            //та самая магия, выбираем по типу нашего объекта соответствующую переменную коллекции и присваиваем нашу коллекцию ей
            if (typeof (T2) == typeof (Drive)) _drives = elements.Cast<Drive>().ToList();
            if (typeof(T2) == typeof(Profile)) _profiles = elements.Cast<Profile>().ToList();
            if (typeof (T2) == typeof (Collar)) _collars = elements.Cast<Collar>().ToList();
        }

        /// <summary>
        /// Возвращает элемент по имени
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="name"></param>
        /// <returns></returns>
        public T GetElementByName<T>(string name)
            where T : class
        {
            //объявляем переменную коллекции нашего базового типа
            List<RollCalcElementBase<RollCalc.Model.CommonProperties>> list = null;

            //делаем обратное действие - по переданному типу Т ищем правильную коллекцию наших объектов-наследников и кастуем их к базовому типу
            if (typeof (T) == typeof (Drive))
            {
                list = _drives.Cast<RollCalcElementBase<RollCalc.Model.CommonProperties>>().ToList();
            }
            if (typeof (T) == typeof (Profile))
            {
                list = _profiles.Cast<RollCalcElementBase<RollCalc.Model.CommonProperties>>().ToList();
            }
            if (typeof (T) == typeof (Collar))
            {
                list = _collars.Cast<RollCalcElementBase<RollCalc.Model.CommonProperties>>().ToList();
            }

            //ищем экземпляр в коллекции по наименованию и возвращаем его (при этом кастуем его к типу-наследнику)
            if (list != null)
            {
                foreach (RollCalcElementBase<CommonProperties> elementBase in list)
                {
                    if (elementBase.Name.ToLower() == name.ToLower())
                    {
                        return elementBase as T;
                    }
                }
            }

            return null;
        }

Вот пожалуй и все пироги, на последок пример кода формирования коллекции наших объектов по базовой коллекции построителя:

RollCalcSettings.Settings.LoadFromElementList<DriveSystem, Drive>(settings.DriveSystems);
RollCalcSettings.Settings.LoadFromElementList<LamellaProfile, Profile>(settings.LamellaProfiles);
RollCalcSettings.Settings.LoadFromElementList<ProtectiveCollarType, Collar>(settings.ProtectiveCollarTypes);

Используя такой подход мы добились следующего:
— Избавили себя от мороки в работе с исходными объектами построителя
— Сохранили связь с исходными объектами (свойство public T PresentationObject { get; set; } в базовом классе)
— Добавили гибкости всей системе за счет возможности расширять функционал наследников наших объектов, например тот или иной элемент роллеты может или не может иметь цвет
— Реализовали один метод инициализации и один метод получения экземпляра для любого типа объекта в системе
— Узнали тонкости в накладывании ограничений на использование обобщенного типа в классе или методе