Asp объявления библиотеки типов


Содержание

Клиентские библиотеки ASP.NET AJAX

До сих пор в большинстве ситуаций применялись функции верхнего уровня, предоставляемые платформой ASP.NET AJAX. Мы начали с рассмотрения поддержки веб-служб, после чего исследовали основные серверные элементы управления, такие как UpdatePanel, Timer и UpdateProgress. В ходе этого вы ознакомились с несколькими нюансами стороны клиентской части модели ASP.NET AJAX — например, с псевдонимом $get и событиями PageRequestManager. Тем не менее, внутренняя инфраструктура осталась без внимания.

Многие разработчики предпочтут именно этот подход. В большинстве ситуаций они будут полагаться на серверные функции ASP.NET AJAX и обращаться к клиентской модели лишь для обработки отдельных событий. Однако существует одна задача, которая требует лучшего понимания клиентской модели: создание специальных элементов управления, которые используют функции ASP.NET AJAX.

В последующих разделах вы ознакомитесь с клиентскими библиотеками и научитесь их использовать. После получения твердого представления об этих основах вы узнаете, как создавать базовый клиентский элемент управления ASP.NET AJAX. Но это не означает, что этот пример легко получится расширить для создания полноценного веб-элемента управления ASP.NET. Разработка пользовательского элемента управления средствами ASP.NET AJAX — сложная и кропотливая задача. Если вы разрабатываете бизнес-приложения, то, вероятно, предпочтете применять существующие элементы управления ASP.NET AJAX, а не вручную кодировать собственные.

Модель клиента

Основным строительным блоком ASP.NET AJAX являются клиентские библиотеки JavaScript. Они служат своего рода «клеем», который скрепляет все остальные компоненты. На рисунке ниже показано место клиентских библиотек в высокоуровневой модели ASP.NET AJAX:

Клиентские библиотеки привносят в мир JavaScript определенные черты среды .NET. Они состоят из трех основных частей:

Расширения JavaScript

Эти расширения предоставляют способ применения объектно-ориентированных технологий в сочетании с обыкновенным кодом JavaScript.

Базовые классы JavaScript

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

Платформа пользовательского интерфейса (UI Framework)

Эта платформа основана на инфраструктуре, созданной базовыми классами. Платформа UI Framework привносит понятия клиентских элементов управления и клиентской страницы.

В целом клиентские библиотеки довольно компактны и требуют от клиента загрузки менее 200 Кбайт кода сценария. При посещении сайта, построенного на основе ASP.NET, этот код сценария загружается только однажды, а затем кэшируется браузером. Кроме того, ASP.NET отправляет сжатую версию документа сценария, если браузер поддерживает это.

Объектно-ориентированное программирование в JavaScript

JavaScript не является настоящим объектно-ориентированным языком, поскольку в нем отсутствует поддержка базовых объектно-ориентированных возможностей, таких как наследование и интерфейсы. Однако JavaScript часто называют языком, основанным на объектах, потому что JavaScript предоставляет встроенные объекты (для окна браузера, текущего HTML-документа и т.д.).

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

Создать одноразовый объект с любым выбранным набором свойств достаточно легко. Для этого сначала создается обыкновенный объект (с помощью ключевого слова var), а затем — свойства за счет присваивания им требуемых значений. Например, в следующем коде создается объект сотрудника с двумя присоединенными строковыми переменными — FirstName и LastName:

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

JavaScript — очень гибкий и нестрогий язык. В предыдущем примере свойства FirstName и LastName создаются автоматически, как только им присваиваются значения — нет никакой необходимости вначале явно объявлять свойства. Эта особенность облегчает создание объектов, но, вместе с тем, чревата множеством потенциальных проблем. Например, легко случайно создать новое свойство, обращаясь к одному из существующих свойств, но непреднамеренно используя неправильное имя.

Чтобы создать более стандартизированное определение объекта, разработчики JavaScript обычно прибегают к одному из двух приемов: замыканиям или прототипам.

Замыкания

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

Модель замыкания проще всего понять, рассмотрев пример. Вот как выглядит код замыкания, которое определяет класс Employee, содержащий имя и фамилию сотрудника:

Переменные, определяемые в замыкании (в этом примере _firstName и _lastName) локальны для функции Employee() и не могут быть доступны за ее пределами. С другой стороны, методы (в этом примере set_FirstName(), get_FirstName() и т.д.) могут быть вызваны в любом месте.

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

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

В ранних сборках ASP.NET AJAX для реализации объектно-ориентированного программирования использовались замыкания. Однако в последующих сборках стала применяться система прототипов.

Формально функция Employee() обеспечивает себя четырьмя новыми свойствами: set_FirstName, get_FirstName, set_LastName и get_LastName. Каждому свойству она назначает функцию. Это позволяет вызывать каждое свойство, как если бы оно было методом. Другими словами, записывая emp.get_FirstName(), вы обращаетесь к свойству get_FirstName(), которое фактически является функцией.

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

Прототипы

Другим подходом, применяемым разработчиками для определения классов в JavaScript, являются прототипы. По ряду технических соображений прототипы являются предпочтительной технологией в ASP.NET AJAX. Прототипы обеспечивают более высокую производительность в некоторых браузерах (таких как Firefox и Google Chrome) и они предоставляют лучшую поддержку для рефлексии, IntelliSense и отладки. Эти различия обусловлены тем, что члены прототипов являются встроенными внутрь, в то время как замыкания создают свои члены при каждом создании экземпляра объекта.

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

Ниже приведен измененный код, в котором объект Employee определяется с помощью прототипа:

Сам объект Employee, фактически является ссылкой на функцию, которая играет роль конструктора. Эта функция инициализирует все приватные члены. Общедоступные члены определяются отдельно, за счет добавления в прототип. Код, который использует прототипную версию класса Employee, остается тем же.

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

Почти столь же важно то, что прототипы облегчают в ASP.NET AJAX решение определенных задач, таких как рефлексия. Таким образом, прототипный подход является предпочтительным.

Регистрация классов в ASP.NET AJAX

Замыкания и прототипы уже доступны в языке JavaScript. В последующих разделах мы рассмотрим три компонента, которые ASP.NET AJAX добавляет в арсенал средств объектно-ориентированной разработки: пространства имен, наследование и интерфейсы. Но прежде чем любую из этих функциональных возможностей можно будет использовать, класс JavaScript потребуется зарегистрировать в ASP.NET AJAX.

Это не представляет особой сложности. Для начала удостоверьтесь, что код JavaScript находится на веб-странице, которая включает в себя клиентские библиотеки ASP.NET AJAX. (Для этого проще всего добавить к странице элемент управления ScriptManager и располагать блоки сценария после него.) Как только клиентские библиотеки ASP.NET AJAX доступны, необходимо вызвать метод registerClass() для своей функции конструктора после определения прототипа:

Помните, что формально переменная Employee является ссылкой на функцию конструктора, которая используется для создания объектов сотрудников. Вызов метода registerClass() возможен потому, что клиентские библиотеки ASP.NET AJAX добавляют методы для регистрации классов, пространств имен, интерфейсов и перечислений.

Даже после регистрации класса Employee вы продолжаете пользоваться тем же самым кодом для создания объектов сотрудников. Однако теперь ASP.NET AJAX знает о классе и предоставляет ему несколько больше встроенной функциональности. Один из примеров — рефлексия, которая позволяет извлекать из класса информацию о типе с помощью примерно такого кода:

При использовании этого кода с экземпляром незарегистрированного класса будет отображаться имя класса Object. Однако если класс Employee был зарегистрирован, отобразится более точное имя — Employee.

Класс Object предоставляет еще несколько членов, которые можно применять для получения информации о типе из зарегистрированного специального класса, в том числе implementsInterface (для проверки того, что реализует ли класс конкретный интерфейс), getInterfaces (для выяснения всех интерфейсов, реализуемых классом), inheritsFrom (для проверки того, унаследован ли данный класс от указанного класса, непосредственно или косвенно) и isInstanceOfType (для проверки того, является ли объект экземпляром указанного класса или класса, унаследованного от него).

Во время отладки можно пошагово выполнять JavaScript-код клиентских библиотек ASP.NET AJAX. Например, если включить отладку клиентского сценария и поместить точку останова на оператор кода, который вызывает registerClass(), можно войти в функцию registerClass(). Лучше всего то, что ScriptManager достаточно интеллектуален, чтобы понять, что выполнение осуществляется в режиме отладки, и поэтому использует отладочную версию клиентских библиотек JavaScript — т.е. можно наблюдать аккуратно сформатированную, прокомментированную версию кода JavaScript. Этот прием является отличным способом узнать больше о работе ASP.NET AJAX.

Базовые типы

Клиентские библиотеки ASP.NET AJAX расширяют несколько базовых типов JavaScript с помощью вспомогательных функций. Во многих случаях эти расширения вынуждают эти типы работать подобно их аналогам .NET. В таблице ниже перечислены типы JavaScript, которые расширяет ASP.NET AJAX:

Расширенные типы JavaScript в ASP.NET AJAX

Добавляет статические методы, которые позволяют добавлять, удалять, очищать и искать элементы массива

Добавляет метод parse(), который позволяет преобразовывать строковое представление булевского типа в сам булевский тип

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

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

Добавляет небольшой набор методов манипулирования строками для усечения строк и сравнения начала или конца строки с другой строкой. (Класс Sys.StringBuilder добавляет еще один способ создания строк.)

Добавляет ряд свойств для обычных типов ошибок, которые возвращают соответствующие объекты исключений. Например, Error.argument возвращает объект Sys.ArgumentException

Добавляет методы getType() и getTypeName(), которые служат отправными точками для отражения информации о типе (как было продемонстрировано в предыдущем разделе)

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

В последующих разделах будет показано, как создать более интеллектуальные классы, которые существуют в отдельных пространствах имен, наследуются от других классов и реализуют интерфейсы. Затем мы рассмотрим ряд более сложных классов из клиентских библиотек ASP.NET AJAX.

Пространства имен

Традиционно все функции JavaScript существуют в одном глобальном пространстве имен. Однако ASP.NET AJAX добавляет возможность выделить функции, которые представляют классы, в отдельные логические пространства имен. Это особенно полезно для предотвращения любого конфликта между вашим классом и встроенными классами ASP.NET AJAX.


Для регистрации пространства имен необходимо вызвать метод Type. registerNamespace() перед созданием своего класса. Затем тип нужно поместить в пространство имен с использованием полностью квалифицированного имени (вроде Business.Employee). Например:

Если теперь вызвать метод Object.getTypeName(), то получится полностью квалифицированное имя класса.

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

Приемлемы оба подхода, но продемонстрированный в предыдущем примере является наиболее распространенным, и именно он используется в JavaScript-файлах ASP.NET AJAX. Нужно только помнить, что, остановив свой выбор на этом двухэтапном подходе, по соглашению к каждому элементу нужно обращаться с применением полностью квалифицированного пространства имен и класса, но использовать знак доллара ($) вместо точки (.), как в Business$Employee$set_FirstName.

Наследование

ASP.NET AJAX предлагает также поддержку для создания классов, унаследованных от других классов. При регистрации производного класса в качестве второго аргумента нужно указать имя базового класса. Ниже приведен пример создания класса SalesEmployee, унаследованного от Employee. Для того чтобы это работало, класс Employee должен быть определен ранее в блоке сценария (или в предыдущем блоке сценария):

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

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

Единственной примечательной особенностью кода SalesEmployee является вызов метода initializeBase(), который позволяет конструктору обращаться к конструктору базового класса, чтобы он мог инициализировать имя и фамилию. Метод initializeBase() — один из членов, которые ASP.NET AJAX добавляет к базовому типу функции. Наряду с initializeBase() можно использовать метод callBaseMethod(), чтобы инициировать метод, который присутствует в базовом классе, но переопределен в производном классе.

Интерфейсы

Для определения интерфейса в JavaScript применяется тот же самый подход с прототипом, который используется при создании класса. Свойство prototype представляет элементы интерфейса. Однако необходимо предпринять дополнительные меры, чтобы интерфейс нельзя было использовать в качестве объекта. Эти правила не являются общепринятыми, поэтому вам самим придется позаботиться о создании интерфейса, который ведет себя должным образом.

Первым делом, конструктор интерфейса не должен содержать никакого кода и не должен присваивать никаких данных. Вместо этого он должен просто генерировать исключение NotImplementedException для предотвращения создания его экземпляров. Аналогично, члены, которые определены в прототипе, не должны содержать никакого кода и должны генерировать исключение NotImplementedException при их вызове. Это требование делает определения интерфейсов JavaScript несколько более длинными, чем определения интерфейсов C#.

Проще всего разобраться в модели интерфейса ASP.NET AJAX — рассмотреть один из интерфейсов, определенных в ASP.NET AJAX. Интерфейс Sys.IDisposable предоставляет эквивалент ASP.NET AJAX интерфейса System.IDisposable в .NET, который дает объектам способ немедленного освобождения используемых ими ресурсов. Интерфейс Sys.IDisposable определяет единственный метод по имени dispose().

Ниже приведен полный код интерфейса IDisposable:

Для регистрации интерфейса вместо метода register >registerInterface(). Перед использованием интерфейса следует удостовериться, что класс включает члены с требуемыми именами:

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

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

Ниже приведен фрагмент кода, который можно использовать для тестирования поведения по освобождению ресурсов. Когда объект SalesEmployee будет освобожден, отобразится соответствующее сообщение:

Платформа веб-страниц

Как было показано, клиентские библиотеки ASP.NET AJAX используют многоуровневую архитектуру. На самом нижнем уровне располагается набор усовершенствований языка JavaScript, которые делают возможными объектно-ориентированные модели, и набор расширений базовых типов данных JavaScript. ASP.NET AJAX включает в себя также ряд базовых клиентских классов и клиентскую модель страницы, которая построена на фундаменте этой инфраструктуры. Эта модель содержит классы для функции обратного вызова веб-службы, рассмотренной ранее, определенные классы поддержки веб-элементов управления, таких как UpdatePanel, и классы элементов управления, которые заключают в себе страницу и ее элементы.

Класс приложения

Отправная точка модели веб-страницы — класс Sys.Application. Когда веб-страница, поддерживающая ASP.NET AJAX, загружается в веб-браузер, создается экземпляр класса Sys.Application. Объект Application управляет компонентами на странице и загружает любые внешние файлы сценариев, которые зарегистрированы в ScriptManager. Элемент ScriptManager вставляет код, который создает объект Application, и объект Application выполняет всю клиентскую работу для серверного компонента ScriptManager.

Объект Application генерирует два ключевых события. Событие load происходит после того, как страница впервые обработана в браузере, и после каждой обратной отправки, включая асинхронные обратные отправки. Событие unload происходит, когда пользователь переходит к новой странице. Чтобы обработать эти события, понадобится добавить JavaScript-функции со следующими именами:

Во многих предшествующих примерах применялась функция pageLoad() — и теперь должно быть понятно, как она вписывается в инфраструктуру ASP.NET AJAX.

Класс Application предоставляет также событие init, которое возникает после того, как все сценарии были загружены для страницы, но перед созданием ее объектов. Событие init инициируется только однажды, при первой обработке страницы, но не происходит после асинхронных обратных отправок. Для присоединения к событию init обработчика служит метод Application. add_init() .Компоненты ASP.NET AJAX реагируют на событие init, чтобы создать клиентские элементы управления.

Класс PageRequestManager

Еще одним исключительно важным классом является PageRequestManager. Он создается, если страница поддерживает частичную визуализацию и использует один или более элементов управления UpdatePanel на стороне сервера.

Класс PageRequestManager инициирует ряд событий, на которые можно реагировать с помощью клиентского кода JavaScript. Эти события перечислены в таблице ниже. В предыдущих примерах PageRequestManager применялся для обработки ошибок асинхронного обратного вызова элементом управления UpdatePanel (за счет обработки endRequest) и реализации отмены элементом управления UpdateProgress (посредством обработки initializeRequest).

Тип Описание
Array
События PageRequestManager

Происходит до начала асинхронной обратной отправки. В этот момент обратную отправку можно отменить с помощью свойства Cancel объекта Sys.WebForms.InitializeRequestEventArgs, переданного обработчику события

Происходит перед запросом асинхронной обратной отправки (но после initializeRequest). В этот момент можно инициализировать индикаторы ожидания на странице (например, запустить подходящую анимацию). Это событие предоставляет объект Sys.WebForms.BeginRequestEventArgs, который можно использовать для выяснения того, какой элемент вызвал обратную отправку

Происходит после получения ответа на асинхронный обратный вызов, но до обновления страницы. В этот момент можно удалить индикаторы ожидания. Это событие предоставляет объект Sys.WebForms.PageLoadingEventArgs с информацией о панелях, которые будут обновлены в результате ответа на асинхронную обратную отправку

Происходит после получения ответа на асинхронный обратный вызов и обновления страницы. Это событие предоставляет объект Sys.WebForms.PageLoadedEventArgs, который подробно описывает, какие панели были обновлены и созданы

Происходит после обработки асинхронного ответа (после события pageLoaded) или во время обработки ответа в случае ошибки. В этот момент можно выполнить проверку на наличие ошибки и обеспечить специализированное уведомление об ошибке. Это событие предоставляет объект Sys.WebForms.End-RequestEventArgs, который подробно описывает произошедшую ошибку

Клиентский элемент управления AJAX

Полное описание платформы веб-страницы выходит за рамки этой статьи. Чтобы больше узнать о клиентской модели, обратитесь к документации ASP.NET AJAX Roadmap. Однако можно узнать очень много нового, рассмотрев краткий пример из интенсивного курса. В этом разделе будет продемонстрирован один из примеров из документации по ASP.NET AJAX: клиентская кнопка, которая обновляет свой внешний вид, когда курсор мыши перемещается над ней. В целях лучшей организации весь код этой кнопки размещен в отдельном JavaScript-файле HoverButton.js.

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

Общая структура кода имеет следующий вид:

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

Прототип включает в себя методы для получения и установки текста кнопки и методы для присоединения обработчиков событий к этим трем событиям. ASP.NET AJAX поддерживает модель событий более высокого уровня, чем чистый JavaScript. Одно из преимуществ этой модели событий — то, что она решает проблемы совместимости браузеров.

Для присоединения и отсоединения обработчиков событий в JavaScript служат методы addHandler() и removeHandler(). Код реализации имеет следующий вид:

Прототип класса HoverButton содержит еще два метода: initialize(), который вызывается автоматически при создании объекта HoverButton, и dispose(), который вызывается при его освобождении.

Метод initialize() устанавливает связь между специальными событиями, которые определены в классе HoverButton, и событиями JavaScript, которые существуют в странице. Например, в следующем коде событие hover устанавливается так, чтобы оно инициировалось при наведении курсора мыши на кнопку или при передаче фокуса кнопке:

В соответствии с этим кодом делегат hoverHandler должен быть инициирован при наступлении события mouseover или focus для клиентского элемента. Делегат hoverHandler определен в конце прототипа. Он просто запускает связанный обработчик событий, как показано ниже:

И, наконец, метод initialize() вызывает базовый метод initialize() в классе Control. Задача метода dispose() проще. Он просто проверяет существование обработчиков событий, и удаляет их, если те существуют. Ниже показана оставшаяся часть класса HoverButton:

И последний нюанс. Сценарий должен уведомлять класс Application о достижении конца его кода. Для этого в конец страницы понадобится добавить следующий оператор кода:

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

Теперь, когда имеется код JavaScript для клиентского компонента, его можно использовать внутри страницы. Прежде всего, сценарий должен быть зарегистрирован в ScriptManager, как показано в следующем примере:

Библиотека Интернет Индустрии I2R.ru

Малобюджетные сайты.

Продвижение веб-сайта.

Контент и авторское право.

Компоненты ASP. Службы COM+ в ASP-компонентах и ASP-приложениях

Создавать и успешно использовать ASP-компоненты можно и без прямого обращения к каким-либо службам COM+. Однако именно эти службы могут внести ту «изюминку», которая превратит просто удовлетворительно работающее ASP-приложение в хорошо масштабируемое и соответствующее предъявляемым ему требованиям, независимо от того, каковы эти требования.


Службы COM+, к которым, прежде всего, стоит обратиться в разработке ASP-компонентов, — это управление транзакциями (transaction management), активация по требованию (just-in-time activation, JIT) и резервирование (pooling). Кроме того, можно использовать новые интерфейсы, которые были созданы для поддержания большей части возможностей этих служб. Однако перед рассмотрением всех этих новшеств обратимся к применению компонентов в приложениях.

Разработка систем на основе компонентов

Именно система, построенная на основе компонентов, выделяет индивидуальные процессы в многократно используемые порции кода и данных, а затем использует один или несколько этих компонентов для сознания полноценных приложений. Среди нескольких типов приложений различают клиент-серверную (client/server), распределенную (distributed) и многоярусную (n-tier) системы. В клиент-серверной системе (client-server system) процессы распределяются между клиентом и сервером, причем клиент отвечает за все взаимодействия с пользователем, отображение данных и подтверждение полномочий клиента, а сервер обрабатывает большую часть обращений к базам данных, проверяет полномочия сервера и контролирует бизнес-правила. В распределенной системе (distributed system) компоненты приложений могут располагаться на разных машинах и географически находиться в разных местах. Кроме того, для обработки множественных запросов может быть создано несколько экземпляров одного и того же компонента, таким образом, появляется возможность предоставлять одну и ту же услугу сразу множеству клиентов. И наконец, многослойная система (n-tier system) объединяет в себе элементы как клиент-серверной, так и распределенной систем. Здесь, как и в клиент-серверной системе, присутствует иерархия компонентов, однако сами по себе компоненты могут дублироваться для распределения загрузки процессов, а также распределяться на большом количестве машин и мест, как это происходит в распределенной системе. Стандартная n-ярусная система может состоять из клиента, выполняющего все взаимодействия с пользователем, проверку полномочий клиента и отображение данных; бизнес-уровня, контролирующего бизнес-правила, общие вопросы управления транзакциями и проверку полномочий, и уровня данных, обрабатывающего все прямые обращения к данным.

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

Другим преимуществом компонентов является тот факт, что гораздо больше родовых функций (generic functions) может быть разделено на отдельные компоненты и, таким образом, использовано во всей системе. Кроме того, применение компонентов упрощает модель и конструкцию n-ярусной системы. В качестве примера можно привести систему, в которой интерфейсный компонент проверяет достоверность адресной информации. Проверка достоверности достаточно характерна: она просто подтверждает тот факт, что все необходимые поля, такие как «Город» или «Почтовый индекс», заполнены. Тогда бизнес-уровень сможет обрабатывать для приложения адресную информацию, исходя из типа бизнеса. На основе адресной информации бизнес-уровень может вести поиск, например, зон отгрузки для компонента с помощью соответствующего приложения или зон доставки для виртуальной системы заказов. Компонент может обратиться к уровню данных для сохранения адресной информации, извлечения дополнительной информации или даже для запуска других виртуальных бизнес-компонентов, выполняющих какую-либо еще обработку информации. Уровень данных сам по себе может быть разделен по отдельным машинам, отдельным базам данных или даже различным типам хранилищ данных, вместе с некоторой информацией, идущей на долговременное или кратковременное хранение (если информация может потребоваться лишь в некоторой специфической задаче, а затем должна быть удалена).

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

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

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

Интерфейсы COM+

Большинство важнейших интерфейсов COM, таких как, например, IUnknown и IDispatch, с появлением среды COM+ не претерпело каких-либо изменений и по сию пору решает все те же знакомые нам задачи. Главное отличие между COM и COM+ состоит в том, что та функциональность, которая в Windows NT и Windows 98 выполнялась средствами MTS, нынче полностью интегрирована в архитектуру COM+. Такого рода интеграция не только принесла с собой новые возможности, предоставляемые службами COM+, но и позволила существенно улучшить характеристики компонентов.

Разумеется, разработчики COM+ не забыли о необходимости поддержки новых служб COM+, а также нескольких новых интерфейсов уже имеющимися средствами, реализованными в MTS. В следующих нескольких разделах нами будут рассмотрены несколько ключевых интерфейсов, без знания которых, как нам кажется, разработка ASP-компонентов была бы бессмысленна.

Интерфейс IObjectContext

В главе 4 мы обсуждали концепцию контекстов (contexts) как совокупностей объектов, отвечающих одинаковыми требованиями. Среди таких требований может быть, например, возможность резервирования (pooling) для компонентов или их совместное участие в транзакциях.

В Windows 2000 контекст компонентов представляет собой набор свойств времени выполнения (runtime properties), непосредственная работа с которым может вестись с помощью объекта ObjectContext, управляющего контекстной информацией для компонента. Для доступа к свойствам объекта ObjectContext используется интерфейс IObjectContext, доступный, в свою очередь, с помощью библиотеки типов служб COM+.

Ответ на вопрос о том, каким именно образом осуществляется доступ к объекту ObjectContext, зависит от того, каким языком программирования вы пользуетесь. Например, если взять Visual Basic, то здесь сначала производится импорт ссылки на библиотеку типов служб COM+ в рабочий проект, и только потом можно создать ссылку на объект ObjectContext и вызвать для создания экземпляра метод GetObjectContext:

Dim objContext As ObjectContext
Set objContext = GetObjectContext

В Visual С++ под Windows NT для доступа к объекту ObjectContext также можно применить метод GetObjectContext:

CComPtr m_spObjectContext;
hr = GetObjectContext(&m_spObjectContext);

В то же время, в Visual C++ под Windows 2000 для передачи интерфейсу идентификатора GUID уже используется метод CoGetObjectContext:

hr = CoGetObjectContext(IID_IObjectContextInfo,
(void **)&m_spObjectContext);

Независимо от того, применяется ли метод GetObjectContext или метод CoGetObjectContext, результаты будут одними и теми же, поскольку вызов метода CoGetObjectContext в COM+ является оболочкой для вызова метода GetObjectContext. В Visual С++ придется также добавить в путь библиотеки компонента ссылку на заголовочный файл comsvcs.h служб COM+ и ссылку на файл связанного объекта comsvcs.lib.

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

табл. 1. Методы интерфейса IObjectContext

Событие Описание
initializeRequest
beginRequest
pageLoading
pageLoaded
endRequest
Метод Описание
CreateInstance Создает экземпляр объекта
DisableCommit Показывает, что компонент не готов к выполнению транзакции
EnableCommit Показывает, что компонент все еще обрабатывается, но транзакция может быть выполнена
IsCallerInRole Показывает, соответствует ли вызывающий определенной роли (с учетом ролевой безопасности)
IsInTransaction Показывает, участвует ли компонент в транзакции
IsSecurityEnabled Показывает, включена ли защита
SetAbort Показывает, что компонент завершил работу и транзакция прервана
SetComplete Показывает, что компонент завершил работу и транзакция готова к принятию

Интерфейс обладает следующими свойствами:

  • ContextInfo — возвращает ссылку на объект контекстной информации, связанный с компонентом;
  • Count — показывает число именованных свойств объекта;
  • Item — содержит имена свойств;
  • Security — возвращает ссылку на объект Security, связанный с объектом ObjectContext.

Интерфейс информации контекста IObjectContextInfo более подробно будет рассмотрен в следующем разделе. Для обращения к встроенным ASP-объектам применяется коллекция Item. Получить доступ к ней можно непосредственно из Visual Basic:

Dim oc As ObjectContext
Dim app As Application
Set oc = GetObjectConext
Set app = oc.Item(«Application»)

Получить доступ к ASP-объектам можно и через объект ObjectContext:

Set app = oc(«Application»)

Из других программных языков для обращения к объектам ASP придется применить другие технологии. В C++, например, для получения доступа к определенному ASP-объекту нужно послать запрос экземпляру интерфейса IGetContextProperties:

CComPtr pProps; //свойства контекста

//получение ObjectContext
hr = CoGetObjectContext(IID_IObjectContext,
(void **)&m_spObjectContext);
if (FAILED(hr)) return hr;

//получение свойств контекста
hr = m_spObjectContext ->
QueryInterface( IID_IGetContextProperties,
(void**)&pProps );
if (FAILED(hr)) return hr;

получение свойства Response
bstrProp = «Response»;
hr = pProps->GetProperty( bstrProp, &vt ) ;
if (FAILED(hr)) return hr;

p > hr = piDispatch->QueryInterface( IID_IResponse,
(void**)&m_piResponse );

В документации к интерфейсу IGetContextProperties сообщается, что он действует только в среде Windows NT, но и в Windows 2000 с его помощью также можно обращаться к встроенным ASP-объектам.

Интерфейс IObjectContextInfo

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

табл. 2. Методы интерфейса IObjectContextInfo

Метод Описание
GetActivityId Возвращает идентификатор текущей активности
GetContextId Возвращает идентификатор текущего контекста
GetTransaction Возвращает указатель на интерфейс ITransaction
GetTransactionId Возвращает идентификатор текущей транзакции
IsInTransaction Показывает, участвует ли компонент в транзакции

Если в компонентах COM+ осуществляется синхронизация (описываемая позже), метод GetActivityId возвращает идентификатор текущей активности, в противном случае будет возвращено значение Null.

Метод GetTransaction возвращает указатель на интерфейс ITransaction. С помощью этого интерфейса можно принять или прервать транзакцию, хотя реализуются эти функции с помощью объекта ObjectContext или интерфейса IContextState, рассматриваемых далее.

Интерфейс IContextState

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

На практике есть два условных бита, устанавливаемых при работе с методами SetComplete и SetAbort. Первый из их — бит завершения (done bit), его установка указывает COM+, что обработка компонента завершена. Второй — бит согласованности (consistency bit). Установка этого бита определяет, может ли быть транзакция принята или она должна быть прервана.

Оба метода, SetComplete и SetAbort, интерфейса IObjectContext одновременно устанавливают оба бита, причем оба устанавливают бит завершения в значение True, указывая, что обработка компонента завершена. В то же время, с помощью интерфейса IContextState можно идентифицировать факт окончания работы компонента отдельно от статуса транзакции.

В табл. 3 приведены четыре метода интерфейса IContextState.

табл. 3. Методы интерфейса IContextState

Метод Описание
GetDeactivateOnReturn Получает состояние бита завершения
GetMyTransactionVote Получает состояние бита согласованности
SetDeactivateOnReturn Сигнализирует о завершении работы компонента
SetMyTransactionVote Идентифицирует возможность принятия либо прерывания транзакции

Бит завершения можно получать и устанавливать с помощью методов SetDeactivateOnReturn и GetDeactivateOnReturn. Компонент деактивируется по завершении методов только при значении бита завершения, установленном в True.

Чтобы убедиться во всех этих возможностях, создайте компонент Visual Basic, реализующий для перехвата событий JIT интерфейс IObjectControl. (Интерфейс IObjectControl подробно описывается в следующем разделе.) У этого метода будет два компонента, каждый из которых вызывает метод SetDeactivateOnReturn интерфейса IContextState. Первая функция будет вызывать метод, передавая логическое значение False, вторая — True.

Создайте проект Visual Basic и назовите его asp0501, а класс генерируемого компонента — done. Присоедините к проекту библиотеки типов служб COM+ и Microsoft Active Server Pages. Коль скоро библиотеки типов добавлены как ресурсы, реализуйте, как показано в листинге 5.1, JIT-методы Activate, Deactivate и CanBePooled интерфейса IObjectControl.

Листинг 1. Реализация JIT-функций интерфейса IObjectControl

Dim objResponse As Response

Private Sub ObjectControl_Activate()
Set objResponse = GetObjectContext().Item(«Response»)
objResponse.Write «

Активирован

Private Sub ObjectControl_Deactivate()
objResponse.Write «


Деактивирован

Private Function ObjectControl_CanBePooled() As Boolean
ObjectControl_CanBePooled = False
End Function

В методе Activate созданная ссылка на встроенный ASP-объект Response используется для отображения сообщения о том, что метод активирован. В методе Deactivate на web-страницу выводится сообщение о том, что компонент деактивирован.

Далее, добавьте две функции компонента, вызываемые ASP-страницей. Первая, под именем function1, обращается к интерфейсу IContextState и вызывает его метод SetDeactivateOnReturn, передавая значение False. Вторая функция, function2, также вызывает метод SetDeactivateOnReturn, но на сей раз передается значение True. В листинге 5.2 приведен программный код обеих функций, который и нужно добавить к нашему компоненту.

Листинг 2. Подпрограммы, вызывающие метод SetDeactivateOnReturn

Dim iCntxt As IContextState
Set iCntxt = GetObjectContext

iCntxt.SetDeactivateOnReturn False
End Sub

Dim iCntxt As IContextState
Set iCntxt = GetObjectContext

iCntxt.SetDeactivateOnReturn True
End Sub

После того как проект компонента скомпилирован и добавлен к приложению COM+, протестируйте новый компонент с помощью ASP-сценария примерно такого содержания (как в странице asp0501.asp):

Первой вызывается функция function2, деактивирующая компонент при возвращении значения функцией. Благодаря этому при обращении к функции компонента будет отображаться сообщение «Активирован», а при возвращении функцией значения будет отображаться сообщение «Деактивирован» еще до сообщения «Вызов function 1».

Следует заметить, что при вызове первой функции, не деактивирующей компонент, сообщение «Деактивирован» при возвращении функцией значения не появится.

Наконец, при повторном вызове функции function2, должны быть отображены оба сообщения, «Активирован» и «Деактивирован», при этом генерируется web-страница со следующими сообщениями:

Вызов function 2

Вызов function 1

Вызов function 2

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

Интерфейс IObjectControl

В этом разделе показано, как можно управлять временем жизни (lifetime) компонента с помощью интерфейса IContextState. В примере также используется активация по требованию (just-in-time activation, JIT) — для управления созданием экземпляра компонента и записи на web-страницу с помощью методов Activate и Deactivate интерфейса IObjectControl сообщений об активации и деактивации компонента.

Разрешение активации по требованию компонента означает, что компонент активируется, только когда он реально требуется, а не при первоначальном создании на ASP-странице. Кроме того, компонент деактивируется, только когда он помечается как готовый к деактивации, удаляется внутри ASP-страницы (например, установлен в Nothing, если вы работаете с VBScript) или процесс выходит за пределы страницы.

Процесс активации и деактивации управляется COM+ с помощью программных ключей, указываемых разработчиками, как, например, тот, что показан в этом разделе для вызова метода SetDeactivateOnReturn интерфейса IContextState.

Как разработчик компонента, вы можете перехватывать моменты активации и деактивации компонента путем реализации методов Activate и Deactivate интерфейса IObjectControl. В этом случае вы не зависите от ресурсов (типа ссылки на объект Response в листинге 5.1) в период простоя компонента и ожидания вызова его методов.

При реализации интерфейса IObjectControl вы должны реализовать и методы Activate и Deactivate — а кроме того, еще и метод CanBePooled. Этот последний метод определяет, находится ли компонент в состоянии, когда он может быть резервирован (pooled). Позднее в этой главе при описании служб COM+ мы рассмотрим резервирование (pooling) компонентов более подробно.

Чтобы воспользоваться преимуществами активации по требованию, компонент должен быть установлен в приложение COM+, а активация по требованию разрешена. Впрочем, поддержка активации по требованию в приложении COM+ для всех компонентов включена по умолчанию.

Интерфейсы IObjectControl и IObjectContext были реализованы в Windows NT и управляются посредством MTS. Фактически же, ASP-компоненты, созданные для Windows NT, за исключением использующих специфические службы NT, можно без проблем перенести на Windows 2000 и COM+, что и обсуждается в следующем разделе.

ПРИМЕЧАНИЕ
В Windows NT приходилось избегать применения обработчиков событий Initialize и Terminate, поскольку они не позволяли обратиться к экземпляру объекта ObjectContext. Это ограничение в Windows 2000 снято. И все же, по-прежнему важно рассмотреть реализацию интерфейса IObjectControl и перехват (trapping) событий Activate и Deactivate для обеспечения доступа к глобальным ресурсам и их высвобождения.

Перенос пакетов MTS в приложения COM+

В Windows NT (or Windows 9x) компонентами можно было управлять как частью пакетов (packages) MTS. Будучи частью пакета MTS, компонент мог воспользоваться некоторыми возможностями MTS, например, выполнением транзакций и активацией по требованию. Те же и многие другие возможности доступны также и в COM+, и обратиться к ним из существующих компонентов можно, перенеся в новую среду пакеты MTS, компоненты или то и другое.

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

Можно относительно просто перенести пакеты MTS в COM+, создав с помощью консоли служб компонентов (Component Services Console) новое приложение COM+ и установив переключатель Install Pre-built Application(s) (Установить готовое приложение). Когда мастер установки приложения COM (COM Application Install Wizard) запросит имя существующего приложения, найдите или выберите созданный ранее PAK-файл.

При импорте существующего пакета MTS в новое приложение COM+ диспетчер служб компонентов (Component Services Manager) импортирует также роли (roles) и пытается сопоставить существующую функциональность MTS новой функциональности служб COM+ — включая настройки транзакций и активации по требованию.

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

В следующем разделе обсуждаются некоторые настройки приложений COM+, влияющие на ASP-приложения.

СОВЕТ
За дополнительной информацией о работе с консолью служб компонентов (Component Services Console) обратитесь к справочной системе Windows 2000.

Активация приложений COM+

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

ПРИМЕЧАНИЕ
В этом разделе рассмотрены не все возможные службы COM+, а лишь самые необходимые для разработки ASP-компонентов, например, безопасность, транзакции и объединение объектов. Активация по требованию подробно рассмотрена в разделе «Интерфейс IObjectControl».

Управлять безопасностью ASP-приложения на уровне страницы или ресурса можно с помощью средств безопасности NTFS или средств безопасности IIS. С помощью средств ролевой безопасности приложений COM+ можно добавить и еще один уровень безопасности.

При реализации ролевой безопасности внутри приложения COM создается роль, и для этой роли добавляются пользователи. После этого при обращении к компоненту или методу компонента COM+ проверяет полномочия безопасности роли, членом которой является пользователь, в соответствии с требованиями по безопасности компонента или метода компонента, и отказывает в доступе, если полномочия пользователя этим требованиям не отвечают.

Приложение COM+ можно создать по двум различным схемам активации: активации внутри клиентского процесса и активации в изолированном процессе.

Если приложение COM+ создано как серверное, обращение к компоненту с ASP-страницы генерирует отдельную программу dllhost.exe для этого компонента и любого другого, являющегося частью приложения COM+. Поскольку компонент находится в отдельном процессе, все вызовы компонента с ASP-страницы должны маршализироваться. Вместе с тем, если компонент некачественный и генерирует нечто опасное для программного обеспечения, это нечто останется внутри файла dllhost.exe и не сможет неблагоприятно повлиять на IIS или остальные ASP-приложения.

Если создать приложение COM+ как библиотечное, при обращении к компоненту с ASP-страницы экземпляр этого компонента (и любого другого внутри приложения COM+) создается внутри того же процесса, что и ASP-страница — если только поточная модель компонента совместима. Поскольку приложения COM+ допускают апартаментно-поточную, произвольно-поточную и нейтрально-поточную модели, экземпляр компонента приложения COM+ должен создаваться внутри процесса ASP-страницы, а все вызовы между сценарием страницы и компонентом должны выполняться в том же потоке.

Службы COM+

Компонент, с помощью диспетчера служб COM+ (COM+ Services Manager) установленный как часть приложения COM+, называется сконфигурированным компонентом (configured component). Такой компонент может воспользоваться преимуществами служб COM+, например, поддержкой транзакций и активацией по требованию. Компонент, не установленный как часть приложения COM+ и зарегистрированный с помощью инструментов разработки (например, VB) или утилиты regsvr32.exe, называется несконфигурированным компонентом (unconfigured component). Этот тип компонента использовать в ASP-приложениях можно, но реализовать интерфейс IObjectControl, воспользоваться преимуществами активации по требованию или применить объект ObjectContext для поддержки транзакций нельзя. Можно, однако, как и прежде, обратиться с помощью объекта ObjectContext к встроенным объектам ASP.

Одним из основных доводов в пользу добавления компонента в приложение COM+ является желание применить компонент в транзакциях. Это момент обсуждается в следующем разделе.

Поддержка транзакций

Одна из проблем при работе с компонентами, построенными на основе технологий COM/DCOM, состоит в том, что связь компонентов, особенно удаленная связь, весьма непроста. Выяснение того, успешно ли завершена обработка компонента, что делать дальше и как восстановить задачу, если один из компонентов не смог ее выполнить, а остальные — смогли, может превратить распределенную систему в плохо реализуемую и трудно управляемую.

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

Кроме того, MTS предоставляет менеджеров (managers) и диспетчеров (dispensers) ресурсов, которые управляют данными хранилищ, например, данными баз данных. По сути, любая система баз данных, поддерживающая транзакции OLE, скажем, SQL Server, может участвовать в транзакциях, управляемых MTS. Это означает, что если компонент, участвующий в транзакции, выполняется с ошибкой, то можно отозвать (вернуть к прежнему состоянию) не только его действия и действия других компонентов, но и любое действие, произведенное базой данных.

Все возможности MTS по работе с транзакциями реализованы в службах COM+ и доступны для сконфигурированных компонентов. Отличие состоит в том, что в COM+ (и Windows 2000) присутствует интерфейс IContextState, позволяющий отделить активацию компонента от управления транзакциями. Этот интерфейс способен сигнализировать, собирается ли компонент принять или прервать транзакцию, при этом компонент остается активированным, как было ранее показано в листинге 5.1.

Что такое транзакции?

Если вы имели опыт работы с коммерческими базами данных, например, с Oracle, Sybase и Microsoft SQL Server, то, возможно, знаете, что представляют собой транзакции. Транзакция (transaction) — это одна или несколько задач, некоторым образом логически сгруппированных, причем все задачи, объединенные в данную группу, либо все вместе успешно завершаются, либо все вместе не выполняются, если хотя бы одна из задач внутри транзакции не выполнена. Если транзакция не состоялась, никаких изменений данных, связанных с данной транзакцией, не делается. Если же выполнение транзакции происходит успешно, все изменения данных принимаются. В качестве примера транзакции с несколькими задачами можно привести перевод денег со сберегательного на расчетный счет. Хотя это и похоже на одну транзакцию, в действительности, происходят сразу две транзакции. Первая транзакция состоит в снятии ваших денег со сберегательного счета (то есть они дебетуются на счет), вторая транзакция заключается в переведении этих денег на расчетный счет (то есть они кредитуются на расчетный счет) . Если операция снятия денег со сберегательного счета прошла успешно, а операция по переводу денег на расчетный счет не была выполнена, вы, весьма вероятно, захотите, чтобы целиком вся транзакция была отозвана и начата заново. Транзакции очень существенны для систем, обновляющих несколько структур данных, например, баз данных. Такие обновления, даже основанные на одной операции, должны быть успешно завершены сразу для всех структур данных, именно для того, чтобы обеспечить успешное завершение одной этой операции.

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

Участие компонентов в транзакциях

Компонент может воспользоваться возможностями транзакций COM+, если он удовлетворяет следующим условиям. Во-первых, компонент должен быть внутрипроцессным сервером (то есть DLL). Во-вторых, он не должен быть свободно-поточным. Далее, если компонент создан в Visual С++, он должен реализовать фабрику классов (class factory) и использовать стандартную маршализацию. Кроме того, для компонента нужно будет создать библиотеку типов.

Если компонент удовлетворяет минимальным требованиям, чтобы получить поддержку транзакций, он должен быть зарегистрирован в COM+. В процессе регистрации тип транзакции, в которой участвует компонент, устанавливается в качестве свойства компонента. Например, на рис. 3 показано окно свойств компонента, для которого требуется транзакция, время ожидания завершения которой определено в 10 секунд.

Чтобы начать транзакцию на ASP-странице, поместите первой строкой страницы следующую директиву:

Для работы с транзакциями компонент должен ссылаться на экземпляр объекта ObjectContext (или интерфейса IObjectContext) или экземпляр интерфейса IContextState. Пометить компонент как готовый к принятию транзакции можно с помощью метода SetComplete объекта ObjectContext или метода SetMyTransactionVote интерфейса IContextState:


Пометить транзакцию для отзыва можно с помощью тех же интерфейсов:

Транзакции COM+ в действии показаны в примерах главы 9, посвященной созданию ASP-компонентов промежуточного слоя с помощью ADO. В этих примерах транзакции выполняются для обновления баз данных — и это их традиционное применение. Транзакции с базами данных можно выполнять непосредственно (не прибегая к транзакциям COM+) с помощью объекта ADO Connection. Тем не менее, примеры этой главы продемонстрируют, что гораздо удобней наладить взаимодействие компонентов и баз данных посредством транзакций COM+.

Транзакции COM+ можно также использовать для управления взаимодействием с другими ресурсами, например, с сообщениями в очереди сообщений. В главе 13, посвященной работе с компонентами MSMQ, транзакции управляют непрерывным удалением сообщений из очереди по мере получения к ним доступа.

Помимо поддержки транзакций и активации по требованию, службы COM+ могут также обеспечивать резервирование (pooling) компонентов.

Резервирование компонентов

Ранее уже отмечалось, что у интерфейса IObjectControl есть три метода: Activate, Deactivate и CanBePooled. У вас уже была возможность поработать с методами Activate и Deactivate, но для резервирования компонентов важен именно метод CanBePooled.

В случае резервирования объектов при пуске приложения COM+ создается минимальный резерв, или пул (pool), компонентов, и все запросы компонента обслуживаются из этого пула посредством менеджера пула (pool manager). Если менеджер получает запрос большего, чем имеется в пуле, числа экземпляров компонента, он создает другой экземпляр компонента, добавляя его в пул — до достижения максимального размера пула. Если же максимальный размер пула достигнут, запрос ставится в очередь до тех пор, пока компонент не станет доступным.

Компоненты, объединяемые в пул, должны соответствовать определенному набору условий. Во-первых, компонент не должен быть отдельно-поточным. Далее, компонент должен поддерживать агрегирование (aggregation), однако при этом свободно-поточный составитель (Free-Threaded Marshaler, FTM) использоваться не может.

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

Если компонент обращается к ресурсам, он должен реализовать три метода интерфейса IObjectControl — Activate, Deactivate и CanBePooled. Обратиться к ресурсу можно с помощью метода Activate (когда компонент создается на клиентской ASP-странице). Этот ресурс может быть высвобожден при высвобождении компонента клиентом (с помощью метода Deactivate). Кроме того, компонент обязан проверить, находятся ли его ресурсы в состоянии, когда их можно резервировать при деактивации компонента. Если резервирование возможно, метод компонента CanBePooled должен возвратить значение True, в противном случае, компонент должен возвратить значение False, чтобы предотвратить возврат компонента в пул.

Наконец, состояние компонента не должно зависеть от сеанса.

Создать резервируемый компонент можно с помощью Visual C++ (или любого другого языка, поддерживающего свободно-поточную или произвольно-поточную модели). Для демонстрации резервирования объектов создайте с помощью мастера ATL COM AppWizard новый проект Visual С++ и назовите его asp0502. Оставьте установленные по умолчанию параметры для MTS, MFC, заместителя (proxy) и исполнителя (stub).

После генерации файлов проекта добавьте новый компонент с помощью мастера ATL Object Wizard. (Подробно работа с этим мастером рассмотрена в главе 14.) Выберите тип Simple Object (Простой объект). Назовите компонент pooledComponent, на вкладке Attributes (Атрибуты) выберите произвольно-поточную модель и поддержку агрегирования (но не поддержку FTM).

Для поддержки интерфейса IObjectControl добавьте в определения класса в файле pooledComponent.h следующую строку:

Добавьте в данные COM ссылку на карту COM (COM map):

При работе с компонентом вам придется обращаться к интерфейсу IObjectContext и встроенному объекту ASP Response, поэтому добавьте в заголовочные файлы библиотеки типов службы COM+ и ASP следующее:

Следует также добавить прототипы метода интерфейса IObjectControl и ссылку на два закрытых (private) члена данных типа интерфейсов IObjectContext и IResponse (встроенного объекта ASP Response). Полный программный код заголовочного файла для резервируемого компонента показан в листинге 5.3.

Листинг 3. Заголовочный файл резервируемого компонента

// pooledComponent.h : объявление CpooledComponent

#ifndef __POOLEDCOMPONENT_H_
#define __POOLEDCOMPONENT_H_

#include «resource.h» // основные символы
#include
#include

/////////////////////////////////////////////////////////////////
// CpooledComponent
class ATL_NO_VTABLE CpooledComponent :
public CComObjectRootEx ,
public CComCoClass ,
public IObjectControl,
public IDispatchImpl
<
public:
CpooledComponent()
<
>

BEGIN_COM_MAP(CpooledComponent)
COM_INTERFACE_ENTRY(IpooledComponent)
COM_INTERFACE_ENTRY(IObjectControl)
COM_INTERFACE_ENTRY(IDispatch)
END_COM_MAP()

// IpooledComponent
public:
STDMETHOD(Activate)();
STDMETHOD_(BOOL, CanBePooled)();
STDMETHOD_(void, Deactivate)();

private: CComPtr m_spObjectContext;
CComPtr m_piResponse;
>;

Далее, с помощью вкладки Link (Связь) диалогового окна Project Settings (Настройки проекта) добавьте в список связанных библиотек проекта библиотеку служб COM+ (comsvcs.lib).

Вам придется реализовать три метода интерфейса IObjectControl. В CPP-файле компонента добавьте код, показанный в листинге 5.4. В этом коде экземпляры IObjectContext и IResponse создаются в методе Activate и высвобождаются в методе Deactivate. Кроме того, метод CanBePooled возвращает значение True и помечает, что компонент можно резервировать (помещать в пул).

Листинг 4. Реализация компонентом методов интерфейса IObjectControl

HRESULT CpooledComponent::Activate()
<
HRESULT hr;
CComBSTR bstrProp;
CComVariant vt;
CComPtr pProps; //Свойства контекста

// получение ObjectContext
hr = CoGetObjectContext(IID_IObjectContext,
(void **)&m_spObjectContext);

if (FAILED(hr)) return hr;

// получение ContextProperties
hr = m_spObjectContext
->QueryInterface( IID_IGetContextProperties,
(void**)&pProps );
if (FAILED(hr)) return hr;

// получение свойства Response
bstrProp = «Response»;
hr = pProps->GetProperty( bstrProp, &vt ) ;
if (FAILED(hr)) return hr;

p > hr = piDispatch->QueryInterface( IID_IResponse,
(void**)&m_piResponse );
return hr;
>

void CpooledComponent::Deactivate()
<
m_piResponse.Release();
m_spObjectContext.Release();
>

BOOL CpooledComponent::CanBePooled()
<
return TRUE;
>

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

С помощью вкладки ClassView (Просмотр классов) добавьте новому компоненту не принимающий никаких параметров метод testPooledComponent. Этот метод прост: он выдает с помощью объекта Response сообщение для web-страницы. Добавьте компоненту программный код метода, показанный в листинге 5.5.

Листинг 5. Единственный метод резервированного компонента

STDMETHODIMP CpooledComponent::testPooledComponent()
<
// печать сообщения
CComVariant vt(«Привет от резервированного компонента»); m_piResponse->Write(vt);

Чтобы воспользоваться резервированием компонентов, компонент нужно добавить в приложение COM+. Создайте новое приложение — с помощью консоли управления службами компонентов (Component Services Management Console) — или воспользуйтесь существующим приложением COM+ и добавьте компонент в приложение.

Добавив компонент в приложение COM+, откройте с помощью контекстного меню диалоговое окно Properties (Свойства) и перейдите на вкладку Activation (Активация). Установите флажок объединения компонентов, задайте минимальный размер пула 10, максимальный — 20.

При первом запуске приложение COM+ создает пул из 10 уже созданных компонентов. При обращении с ASP-страниц к этим компонентам они извлекаются из этого пула до тех пор, пока все не будут активированы. После этого все новые вызовы компонентов будут добавлять экземпляры этих компонентов в пул, пока не будет достигнут максимальный размер пула в 20 экземпляров.

Протестируйте компонент с помощью следующей тестовой ASP-страницы (asp0502.asp):

На этой странице создаются 20 экземпляров компонента и вызывается метод каждого из компонентов. Результатом обращения к этой ASP-странице будет список сообщений со строкой «Привет от резервированного компонента». Первые 10 экземпляров были созданы при запуске приложения COM+, а последние 10 — при обращении к ASP-странице.

Измените теперь число экземпляров на 21 и обратитесь к ASP-странице. Похоже, она виснет. Это происходит потому, что менеджер пула выдал все компоненты из доступного пула, вследствие чего достигнут максимальный размер пула. Запрос 21-го компонента ставится в очередь до тех пор, пока какой-нибудь компонент не освободится. Но поскольку до завершения страницы все компоненты остаются недоступными, а запрос компонента происходит на той же самой странице, экземпляр 21-го компонента не может быть создан, и страница зависает. Фактически страница будут продолжать висеть до истечения времени ожидания запроса компонента. После этого страница выведет следующее сообщение об ошибке («активация COM+ не удалась, поскольку она не может быть завершена в течение заданного времени»):

COM+ activation failed because the activation could not be
completed in the specified amount of time.

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

17 полезных библиотек и инструментов для фронтенда

Мы расскажем о 17 полезных библиотеках и инструментах, которые используют Frontend-разработчики Студии Т. Речь пойдет о технологиях, в ценности которых убедились на личном опыте. Каждая из них увеличит продуктивность и поможет в реализации конкретной задачи.

ИНСТРУМЕНТЫ

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

Fontsquirrel — генератор веб-шрифтов. Загружаешь файл шрифта — получаешь несколько форматов и уже готовый файл со стилями, который можно подключить.

Colorzilla — колорпикер. Аналог пипетки в Photoshop. Решает задачи с цветом. Позволяет получить образец цвета из любой точки браузера и скопировать в нужную программу. Анализирует страницу на палитру цветов и создает расширенные CSS градиенты.

Препроцессор Sass — простой язык стилей и мощный препроцессор. Легкая читабельность кода. Благодаря подключенной библиотеке Compass можно выйти за рамки CSS и работать со спрайтами в автоматическом режиме.

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

PhpStorm — среда разработки. Содержит отличное автодополнение кода. Поддерживает смешивание языков. В него встроен git, который позволяет работать с сервером, минуя лишнее открытие консоли. Удобная установка плагинов. Включает в себя опознаватель языка php для бэкенда. Включает гибкую систему настроек для разработчика.

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


gulp — сборщик проектов. Перед сдачей сайта код необходимо сжать. Делается это для предотвращения кражи и уменьшения «веса». Автоматически сжимает JavaScript файлы, файлы стилей, преобразует SASS в CSS. Браузер читает только CSS. Ставится в проект.

Prettier — автоматически форматирует JavaScript код, при этом гарантирует, что код соответствует заданной максимальной длине строки. В отличие от ESlint, где требуется ручное исправление, Prettir делает все за вас. Интегрируется со средой разработки.

Figma — графический редактор. Объединяет в себе фишки по работе с векторной графикой и прочим инструментами UI-дизайна. Открывает одновременный доступ к проекту. Разработчику достаточно кликнуть на объект и справа видно всю информацию: его высоту, ширину, отступы, цветовой код. Если это шрифт — название, размерности, выравнивание.

Подробнее о Figma и ее функционале читайте тут

Optimizilla — веб-сервис, который уменьшает размер фото без потери качества. Работает с изображениями в форматах JPEG и PNG. Одновременно загружается до 20 изображений. Уровень качества и размер сжатия регулируется.

Clip path — инструмент для создания кривых блоков. Благодаря изменению координат можно создать и изменить любую геометрическую область. Она определяет, какая часть элемента будет видна, остальное скрывается. При создании генерируется CSS код, готовый к работе.

Box shadows — добавляет элементу одну или несколько теней. Тень — копия элемента, смещенная на заданное расстояние. Имеет широкие настройки теней — внешние, внутренние, размытые, плоские. Могут следовать контурам блоков. Тени внутри элемента сделают элемент объемным.

Favicon generator — генератор FAV-иконок под любые разрешения. Загружаешь картинку и сервис генерирует иконку с кодом для HTML. Иконки подойдут как для android, так и для IOS.

json editor online — редактор позволяет избегать ошибок. Пропустить запятую или двоеточие теперь не страшно. Json покажет, как код выглядит в консоли и браузере.

js fiddle — популярная среда веб-разработки. Редактирует и запускает код, написанный на HTML, JavaScript и CSS. Поддерживает библиотеки jQuery. Используется, когда проект большой, нужно добавить небольшую функцию и не запороть код. Тестируем, смотрим как работает функция, и вставляем в проект.

pug — препроцессор для HTML. Код автоматически генерируется в HTML. Позволяет использовать циклы и условия. Создавать переиспользуемые блоки CSS, чтобы избежать дублирования кода. Обычный HTML такого не умеет. Тег с классами в pug пишется в два раза быстрее, чем в HTML.

VirtualBox — виртуальная машина от Microsoft. Отличная возможность протестировать проект на Windows, если работаешь на Mac. В нее выгружаются разные версии, от XP до Windows 10. Позволяет тестировать проекты в любых браузерах — от IE до Chrome.

БИБЛИОТЕКИ

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

JQuery — JavaScript библиотека с широкими возможностями. Проста в понимании и удобна в использовании. Все операции JQuery выполняются из кода JavaScript. Библиотека jQuery управляет поведением html-элементов и меняет структуру веб-страницы. Изменения касаются отображения страницы для пользователя — файлы HTML и CSS не меняются.

jQuery FancyBox — плагин для создания красивых фотогалерей и вывода изображений в модальных окнах. Для использования последней версии придется потратиться. Плагин платный.

Device — определяет тип устройства, с которого зашел пользователь. Помимо этого определяет браузер, ориентацию устройства и тип девайса — смартфон или планшет.

Snap svg — JavaScript библиотека. Позволяет создавать и анимировать векторную графику в современных браузерах. Можно загружать код SVG асинхронно и запрашивать части, которые нужны, для превращения SVG файлов в спрайты.

GSAP.js или Greensock — библиотека JavaScript для создания высокопроизводительных анимаций. По сути, GSAP — манипулятор свойств объекта, который обновляет значения быстро и с высокой точностью. Примерно до 20 раз быстрее, чем jQuery. Анимацию можно останавливать, замедлять, ускорять, делать плавной. Имеет готовый набор функций, которые делают анимацию кроссбраузерной.

jQuery Form Styler — плагин меняет формы обратной связи, делая их привлекательнее. Меняет вид заявки на сайте, делая ее кроссбраузерной.

History — плагин управляет состоянием страницы. Отправляет ссылку на уже подгруженную историю браузера. Состояние страницы при этом сохраняется в виде нормального URL и всё работает так, как будто вы на самом деле переходите с одной страницы на другую.

Owl carousel — плагин для создания слайдеров. Имеет интуитивные настройки точек остановки слайдера. Адаптивен. Отлично работает как на мобильной, так и на десктопной версии. Owl карусель поддерживает модульную структуру плагина. Таким образом, можно отсоединить плагины, которые не используются в проекте, или создать новые, которые необходимы. Css2 поддерживает старые версии браузеров.

JQuery UI — библиотека собрала в себе стандарты фронтенд-разработки. Предоставляет упрощенный доступ к функциям взаимодействия, анимации, эффектов и набору виджетов. В коде прописывается один класс и библиотека делает все за тебя, достаточно обновить страницу.

Barba.js — библиотека делает «приложение одной страницы». Компоненты сайта загружаются на странице единоразово. Иными словами — страница без перезагрузки. Переходя между вкладками ничего не прогружается и создается впечатление, что находишься на одной странице. Как будто ты в приложении.

Пример сайта с использованием Barba.js — http://normsugar.com

Lettering.js — дает полный контроль над текстом. Используется для анимации. С помощью плагина слово разбивается на буквы и с каждой можно работать отдельно.

JQuery scroll bar — библиотека со скроллбаром. Заменяет квадратный скролл Windows на скролл IOS. Сделает сайт аутентичным, если он в стиле хайтек.

Swiper.js — превосходный слайдер, заточен для работы с мобильными версиями сайта и веб-приложениями. Swiper обеспечивает аппаратное ускорение анимации на нативном уровне. Гибкий, имеет множество настроек. Подогнать можно под любой дизайн или задачу.

Sticky kit.js — плагин дает простой способ «прилипания» элементов, которые всегда закреплены при скролле содержимого страницы. Имеет легкий обработчик прокрутки, который работает с кэшированными значениями.

Autosize.js — плагин автоматически регулирует высоту текстовой области, добавляя ей свойство автоматической регулировки высоты. Пользователю удобней просматривать набранную информацию.

Input mask — плагин для установки маски ввода элементу input с помощью кода JavaScript. Для своего функционирования требует наличие подключенной библиотеки jQuery.

PickMeUp.js — плагин jQuery datepicker. Простой и одновременно мощный календарь событий. Имеет гибкие настройки функционала и внешнего вида.

Мы не жадные и любим делиться полезным. Используешь крутой инструмент или библиотеку, но не увидел ее в статье — расскажи в комментариях.

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

Подключение библиотек к ASP.NET

Регистрация: 06-Июл-09
Местонахождение: Russian Federation
Статус: Offline
Количество сообщений: 18 Параметры сообщения

Цитировать Ответить Тема: Подключение библиотек к ASP.NET
Добавлено: 14-Ноя-09 в 01:41

Всем доброго времени суток.

Никогда не сталкивался толком. Возникла необходимость выкачиват ькое какую инфу в excel.
Excel.appl.
не устраивает.

Наткнулся на одну интересную библиотеку. По примерам в инете то чт онужно.
http://www.gemboxsoftware.com

После установки в дирриктории куда стивил в папке bin 2 папки для NET20 и NET30

беру из папки NET20 GemBox.Spreadsheet.dll и GemBox.Spreadsheet.Xml
кидаю в TrafInsp\ASP.NET\bin

D:\Programs\TrafInsp\ASP.NET\bin>gacutil.exe /i GemBox.Spreadsheet.dll
Microsoft (R) .NET Global Assembly Cache Utility. Version 2.0.50727.42
Copyright (c) Microsoft Corporation. All rights reserved.

Assembly successfully added to the cache

Пробывал уже и так:
D:\Programs\TrafInsp\ASP.NET\bin>gacutil.exe /i D:\Programs\TrafInsp\ASP.NET\bin\GemBox.Spreadsheet.dll
Microsoft (R) .NET Global Assembly Cache Utility. Version 2.0.50727.42
Copyright (c) Microsoft Corporation. All rights reserved.

Assembly successfully added to the cache

Без разницы, хотя в списке она присутствует:

AspNetMMCExt, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL
AspNetMMCExt.resources, Version=2.0.0.0, Culture=ru, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL
cscompmgd, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL
GemBox.Spreadsheet, Version=33.1.0.1000, Culture=neutral, PublicKeyToken=b1b72c69714d4847, processorArchitecture=MSIL
GemBox.Spreadsheet, Version=33.1.30.1000, Culture=neutral, PublicKeyToken=b1b72c69714d4847, processorArchitecture=MSIL

IEExecRemote, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL
IEHost, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL
IIEHost, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL

Подключаю её в скрипте:
using GemBox.Spreadsheet; (во всех примерах именно так)

Пишеться
ообщение об ошибке компилятора: CS0246: Не удалось найти имя типа или пространства имен «GemBox» (пропущена директива using или ссылка на сборку?)

Решение ASP.NET с проектом библиотеки классов

У меня есть решение в VS 2008, которое содержит два проекта библиотеки классов и веб-сайт ASP.NET. Сайт ASP.NET ссылается на библиотеки классов, а одна из библиотек содержит элемент LINQ To SQL.

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

Что я делаю неправильно здесь, как я могу настроить эти параметры, чтобы я мог вносить изменения в строку подключения?

Поиск по сайту

Изначально я планировал сделать детальный обзор одной библиотеки компонент для ASP.NET MVC. Далее пришел к выводу, что для ознакомления с ней достаточно просто посмотреть ее демо, рассказать чего-то особенного я не смогу, и решил, что сделаю подборку библиотек с CodePlex’а для ASP.NET MVC проектов:

1. MvcContrib– наверное самая известная opensource библиотека для ASP.NET MVC.

  • Portable Areas
  • HtmlHelpers + controls
  • ModelBinders
  • Filters
  • ViewEngines
  • T4MVC
  • еще много вкусного


Must be в любом проекте, набор возможностей впечатляет.

2. S#arp Architecture– построен на базе ASP.NET MVC и NHibernate. Представляет собой набор библиотек для использования NHibernate в веб среде: работа с БД, валидаторы, IoC-контейнеры и многое другое. Из него надо брать “best practices” и использовать в своих разработках.

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

3. ASP.NET MVC Awesome– набор различных контролов на базе jQuery.

Включает в себя следующе контролы:

  • AutoComplete
  • AjaxDropdown
  • Lookup
  • AjaxRadioList
  • Confirm Dialog
  • Popup, Popup Form
  • Pager
  • AjaxCheckBoxList

4. jQuery ASP.NET MVC Controls – контролы на базе jQuery: datepicker, grid, autocomplete, accordion и многое другое.

5. Telerik Extensions for ASP.NET MVC – расширения от компании Telerik, клиентская часть на основе jQuery. Включает в себя:

  • grid
  • html wysiwyg editor
  • combobox
  • calendar
  • chart
  • menu
  • panelbar (accordion)
  • treeview
  • tabstrip (tab control)
  • etc

По сути аналог MvcContrib, но продвинутей.

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

Не понравилось в нем то, что много нюансов скрыты от разработчика и приходится достаточно подробно изучать исходники, чтоб понять “как эта штука работает и почему”. Хотя может это и плюс – взял готовый пример и использовал у себя.

6. ASP.NET MVC Scaffolding – поддержка scaffolding, как понятно из названия. Есть отличная статья и еще одна по этому поводу.

7. ASP.NET MVC Extensions – MVC расширения на все случаи жизни: model binders, infrastructure tasks, action filter и тд.

8. MVC HTML5 Toolkit – набор html-хелперов для разработки веб сайта с использованием HTML5. Статья +видео о проекте здесь.

9. MvcMaps – общее API для использования Bing Maps и Google Maps на Javascript. Что умеет с примерами использования — здесь.

10. jQuery Grid for ASP.NET MVC – адаптация популярного контрола Grid на jQuery под MVC,

11. MVC Controls Toolkit – широкий набор компонент + валидация (сервер и клиент)

12. FluentFilters – набор фильтров для разнообразных целей.

13. jQuery Mobile Extensions for ASP.NET MVC – построение веб приложения на основе jQuery Mobile на HTML5.

14. Google Map control for MVC – построен с использованием Telerik Extensions.

Вне обзора остались еще десятки полезных и популярных библиотек. Буду рад если кто-то предложит своей вариант и рассмотрит его во всех подробностях.

Подключение статической библиотеки

В .h файле моей программы инициализирована структура.
Мне нужно использовать статическую библиотеку вместо него. Я в Visual Studio скомпилировал статическую библиотеку, где вызываю лишь хедер. Проблема в том, что мне не удается подключить ее к своей программе. Я пытался сделать это с помощью добавления этого: (#pragma comment ( lib, «MathFuncsLib.lib» )) в свойства Студии (Компоновщик -> Ввод -> Дополнительные зависимости), но мне это не помогло.
Я получаю ошибку:

Ошибка LNK1104 не удается открыть файл «#pragma comment ( lib, \MathFuncsLib.lib\ ).obj

Если туда же добавить лишь MathFuncsLib.lib, то компиляция крашится, но не из-за кривого вызова библиотеки, а из-за отсутствия определения структуры.
Не подскажите, как это пофиксить? Спасибо.

1 ответ 1

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

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

13 библиотек С++, о которых нужно знать

Помимо стандартной библиотеки, содержащей основные модули языка С++, разработаны десятки, а то и сотни дополнительных библиотек. Каждая из этих библиотек содержит программы и подпрограммы, производящие ряд действий.

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

Знание и использование ряда полезных библиотек сильно упрощает работу программиста. По этому признаку работодатели легко отличают уверенного профессионала от неопытного новичка.

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

Веб-разработка

V8

Если Вам нужен удобный инструмент для работы с JavaScript, V8 подойдёт идеально.

Свои функции V8 реализует, используя специальные классы, написанные на с++ и объявленные в namespace V8. Работать с джава скрипт — структурами можно через привычную оболочку с++.

Схема взаимодействия объектов с++ и V8 реализована посредством использования v8::Handle (template-классов).

Установка V8 обычно не занимает много времени, а польза для тех, кому периодически приходится работать с JavaScript’ом, неоценима.

Кроме того, о библиотеках, с помощью которых могут взаимодействовать C++ и JavaScript очень любят спрашивать на собеседованиях. Поэтому даже, если вы не собираетесь работать с js , с V8 или другими подобными библиотеками лучше познакомиться.

WebKit

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

Некоторые программисты называют WebKit «чёрным ящиком», органично перерабатывающим html, css и JavaScript в полноценные веб-страницы.

Awesomium

Awesomium — это библиотека для интеграции браузера (на базе Chromium) в своё приложение. Библиотека имеет 2 режима работы: Offscreen и Windowed.

В режиме Offscreen отрисовка и работа скриптов на экране не отображается.

В режиме Windowed средствами библиотеки эффективно выполняется отрисовка в «окне приписки» и обработка активности мыши и клавиатуры.

Awesomium активно применяется в десятках разных приложений. Описаны случаи интеграции этой библиотеки в 3D игры.

Существенный минус – отсутствие активного сообщества, способного познакомить новичка с библиотекой, ответить на вопросы и исправить ошибки. А документация, доступная для работы с Awesomium на с++, даёт довольно смутное представление о принципах работы библиотеки.

Тем не менее, Awesomium остаётся очень удобным инструментом, завоевавшим признание сотен разработчиков по всему миру.

Работа с сервером

Libcurl

Хотите упростить взаимодействие с сервером? – используйте Libcurl.

Libcurl помогает передавать данные (изображения, файлы и пр.) приложениям. Libcurl поддерживает 13 основных протоколов FTP, FTPS, HTTP, HTTPS, TFTP, SCP, SFTP, Telnet, DICT, LDAP, а также POP3, IMAP и SMTP.

Изначально cUrl предназначался для использования на языке С. Сейчас для работы с Libcurl разработаны модули интеграции к 30 языкам программирования. Что говорит о высокой популярности библиотеки в среде разработчиков. На это же указывает высокий рейтинг продукта.


Сжатие данных

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

Zlib

Сжатие любых объёмов данных (даже превышающих объём памяти) с помощью zlib проводится предельно легко.

Zlib написана на языке С и применяется в тысячах проектов. Использование некоторых других библиотек невозможно без использования zlib. Примером такой библиотеки является основная библиотека для работы с растровой графикой в формате .png — libpng.

Работа с изображениями

Libpng и libjpg

Libpng, написанная на C с использованием ассемблера, предназначена для работы с изображениями в формате .png.

Для работы с изображениями в формате .jpg существует библиотека libjpg (также написанная на С с использованием Ассемблера)

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

Работа с PDF

Периодически возникает необходимость конвертировать файлы в формат pdf. Для этого процесса разработана динамическая библиотека DynaPDF.

DynaPDF

DynaPDF – удобный гибкий инструмент. Формат .dll хотя и открывает достаточно широкие возможности, периодически становится причиной возникновения ошибок.

Для успешного устранения ошибок в сети есть много пошаговых инструкций.

Используется для программирования на языках C/C++, C#, Delphi, Lazarus, PHP, VB, VBA, and VB .Net.

Работа с базами данных

Большая часть приложений нуждается во взаимодействии с базами данных. Оттуда получаются и туда передаются потоки необходимой информации. Поэтому большинство работодателей интересует умение соискателей работать с базами данных.

Libpq

Libpq – удобная библиотека для взаимодействия С и PosgreSQL. Благодаря ей из кода С можно вносить изменения в базу данных, добавлять и безвозвратно удалять данные, создавать и удалять таблицы.

Существуют вариации libpq для C++, Python’a, Perl’a, Tcl, ECPG.

Отладка и тестирование

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

Check

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

Для модульного тестирования на языке С++ используется Google C++ Testing Framework (Google Test).

Pcap

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

Pcap предназначена для работы с С и С++. Существуют обёртки, делающие эту библиотеку доступной для работы на других языках программирования.

Ещё Вам может пригодиться…

Libusb

Libusb — это библиотека, которая позволяет обмениваться данными с USB-устройствами прямо из кода программы.

В библиотеке поддерживаются все типы передачи (управление / объем / прерывание / изохронность). Важный элемент библиотеки – журнал сообщений. Он помогает правильно расшифровать коды ошибок, поступающие от USB- устройств.

Предназначена для работы с С. Для других языков программирования разработаны обёртки. Для С++ — Libusbpp

ZBar

Библиотека ZBar предназначена для распознавания штрихкодов из изображений.

ZBar имеет предельно простую и логичную документацию без «тёмной магии» и необъяснимых функций.

Работать с ней легко и удобно. Можно использовать из программных интерфейсов С, С++, Питона и других языков программирования.

Заключение

Большинство описанных библиотек работают и под Windows, и под Linux, и под macOS, и под BSD. Разработчики библиотек предоставляют подробную техническую документацию, а комьюнити готово поделиться пошаговыми инструкциями по установке и ответить на любые рабочие вопросы.

Умение работать с библиотеками – важный навык для любого программиста. Это своеобразный показатель его профессионального уровня и понимания процесса разработки.

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

Не бойтесь новых задач – ищите их решение.

Пишите код, тестируйте и оттачивайте его до блеска. А команда progtips.ru всегда придёт Вам на помощь!

АНОНС

Вы думаете, это все полезные библиотеки? Нет! На десерт мы оставили самое интересное.

В следующем выпуске Вас ждут:

— лучшие графические библиотеки для С++;

— чем пользуются разработчики компьютерных игр в России и на Западе;

и как по графической библиотеке отличить любителя от профессионала.

Не могу нормально подключить библиотеку ASP.Net WebForms

Написал библиотеку классов для работы с бд, далее разработал ASP.Net WebForms приложение. Пришлось формы использовать из-за XP-шного есрвера, где .Net Framework максимум 4.0.x или как-то так. Суть проблемы в том, что у серверу имеется доступ только на загрузку файлов в определенную директорию, где и будет храниться проект. То есть установка проекта с моей стороны выглядит как Ctrl+c + Ctrl+v в папку на сервере. А при попытке открытия .aspx файла формы получаю ошибку:

Description: An error occurred during the compilation of a resource required to service this request. Please review the following specific error details and modify your source code appropriately.

Compiler Error Message: CS0246: The type or namespace name ‘PM20library’ could not be found (are you missing a using directive or an assembly reference?)

Asp объявления библиотеки типов

Каким должен быть интерфейс любой информационной системы? Думаю, мало кто возразит, если отвечу, что прежде всего простым и функциональным. В журнале «Информационные ресурсы России» в 4 выпуске за 2008 год есть публикация под названием «Современная электронная библиотека ВУЗа: движение от становления и развития к соответствию ожиданиям». Статья является результатом исследования относительно электронных библиотек в инновационных вузах РФ. Возвращаясь к заголовку поста есть в публикации и раздел про интерфейс, а именно про интерфейс поисковых систем.
Выдержка:

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

Напомню, что полученые результаты — не просто личный взгляд отдельных экспертов, а статистика мнений всех лиц, связанных с электронной библиотекой от студентов до администрации ВУЗов и сформированных через анкетирование и официальные запросы.
Почему меня так заинтересовала эта тема? Дело в том, что на Арбиконе в ходе доклада представителей Зональной библиотеки ВГУ (аудиозапись) разгорелась жаркая дискуссия относительно поиска на портале сайта библиотеки. Веб-разработчики решили переделать и переделали обычный поиск АБИС на более простой, мотивируя тем, что студентам сложно пользоваться стандартным. Естественно данное заявление вызвало ряд возмущений, было сравнение с простотой гугла, и каждый все равно остался при своем мнении. Исследования и статистика же показывает, что идеальная модель электронного библиотечного каталога должна учитывать преимущества популярных поисковых машин, используемых в сети Интернет. То есть просто, но с возможностью дополнительной и необходимой функциональности.

А какие у вас соображения по данному вопросу? часто ли вы пользуетесь расширенным поиском? согласны ли с выводами исследования по интерфейсу? может быть спустя два года появились еще какие-то немаловажные моменты?

Илон Маск рекомендует:  Что такое код is_writable
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL