Я новичок в идее аспектно-ориентированного программирования, но я хотел бы изучить идею его использования в моем проекте для обработки журналов, отчетов и т.д. С этой целью у меня есть несколько вопросов:
Аспектно-ориентированное программирование - это гораздо больше, чем просто ведение журнала, отчетность и т.д., как вы увидите, если вы посмотрите на веб-сайт PostSharp. Лично я не делал так много статического трения IL, в основном динамического генерации IL для создания перехватчиков AOP, и при этом я в основном использовал его для переноса и перехвата разрешений из инверсии контейнеров управления.
AOP может улучшить обработку исключений, улучшить отслеживание, улучшить перехват транзакций.
NHibernate, например, имеет своего рода AOP, хотя он статичен во время компиляции с точки зрения простых обработчиков событий; но для определенных событий в двигателе вы можете присоединить перехватчики (такие же аспекты, события, которые являются точками и т.д.). Я использую это для ввода, используя бизнес-объекты IoC в свои объекты домена.
Мощные AOP-фреймворки позволяют вам обобщать и даже более мощные, позволяя вам обобщать без накладных расходов во время выполнения; в принципе у вас есть несколько разных способов сделать это:
(0). (не реально) "предварительный процессор" AOP aka шаблоны в С++, ifdefs и т.д.
Использование в транзакциях Посмотрите Castle.Facilities.AutomaticTransactionManagement.TransactionFacility для отличного способа обработки транзакций с использованием AOP и возможностей перехвата DynamicProxy2. Объект транзакции, интегрированный с System.Transcations и System.EnterpriseServices, заключается в использовании координатора распределенных транзакций (COM-компонента) для управления транзакциями. Кроме того, есть несколько примеров p/invoke в ядре, чтобы позаботиться о TxF и TxR-компонентах ядра Vista (aka Server 2008), которые позволяют использовать транзакции в NTFS и в реестре, тем самым гарантируя, что CRUD вы выполняете ACID, что также прекрасно интегрируется с System.Transactions для создания вложенных транзакций.
Использование в инвариантной проверке Вы также можете использовать их для разработки по контракту, добавив некоторые атрибуты к вашим параметрам.
public void PerformOperation([NotNull, NotEmpty] string value) {
// use string
[NotNull] return new string(' ', 5); // can return with attributes as well
}
Проблема с этим в настоящий момент связана с накладными расходами на присоединение этих метаданных и их проверку во время выполнения. Тем не менее, вы можете указать атрибут проверки ограничений, который будет применяться только при компиляции с помощью DEBUG, а затем эти метаданные не приведут к значительному ухудшению производительности.
Если вы хотите перейти к аксиоматическим доказательствам, взгляните на Sing #/SpeС# вместо этого, так как это более формально, а работа выполняется компилятором.
Что нужно знать о Самый важный момент, который нужно знать, состоит в том, что если проблема, то есть какая-то часть кода, которая работает до или после вашего метода, изменяет поток управления, возможно, возвращая неожиданный тип, возвращение слишком рано или вообще не ведет себя в том числе метод, который вы вызывали у вас, могут возникать ошибки, которые трудно отлаживать.
Кроме того, остерегайтесь бросания исключений из атрибутов, потому что вы никогда не знаете, когда или с какой сборки происходит отражение; отражение вашего атрибута может не произойти, когда вы ожидаете. Это случилось с самим собой, когда я добавлял типы в атрибуты и тщательно проверял их.
Также остерегайтесь того факта, что вы открываете возможный вектор атаки при добавлении глобальных "точечных сокращений", которые, если кто-то получает доступ, могут использоваться для перенаправления больших частей вашей системы.
Другие рамки Если вам интересно узнать больше об АОП в целом, я предлагаю вам ознакомиться с презентациями Рикарда Эберга на Qi4J, это очень хорошая структура в Java для AOP (java имеет несколько другую наследуемую по наследству семантику, хотя это делает сложную битку для использования в С#/F #/Nermle/Boo.
AOP + AddIns Еще одна интересная возможность использования аспектно-ориентированного программирования с создаваемыми во времени сборками, такими как dynamicproxy2, заключается в том, что вы также можете использовать их для обертывания объектов, пересекающих границы приложений, что упрощает создание надстройки. Я тайно надеялся, что Microsoft будет использовать это, когда они создадут свою AddIn-framework для 3.5, но, к сожалению, они выбрали статический код-ген, что приводит к довольно большим накладным расходам при создании надстроек для разработчика. Проблема заключается в том, что тип, загруженный для "более чем отражения" в AppDomain, не может быть снова выгружен, если полный AppDomain не выгружен, поэтому вам нужно 1) задуматься над плагином, не загружая его, чтобы увидеть, на что он способен, если только вы позволяете записывать или генерировать много метаданных вручную (и верить в это) и 2) некоторый объект, чтобы удерживать дескриптор вашего объекта, чтобы он не был GCed, и вы не знаете тип (следовательно, сборка IContract и AddInHandle-class) - это, вероятно, можно было бы сделать с хорошим динамическим прокси-сервером/AOP.
Использование AOP для глобальной коллекции мусора... в распределенной системе, работающей на linux/windows в общей языковой инфраструктуре. Документ немного загрузился, поэтому Я загрузил его на свой сервер, чтобы я знал, где он находится.
Post Scriptum (Если вы используете нестандартный язык в среде CLR, а не DLR IL-weaving, возможно, создаете нестандартный код. Особенно интересно для F #, я думаю, потому что использование большого количества нестандартного кода для большой пользы язык (кортежи говорят) - вы можете отметить свою сборку с помощью [assembly: CLSCompliant], если вы хотите получить предупреждения об этом во время компиляции.)
Я не могу говорить о специфике .NET, но AOP и более общая идея о возможности прикрепления крючков к произвольным методам - это удобный метод, который может решить некоторые неприятные проблемы.
Одним из примеров является дизайн по контракту. Скажем, у вас есть куча методов, на которых вы хотите применить некоторые общие контракты. Вы можете добавить некоторый "совет" (термин AOP) до и после вызова каждого метода без необходимости вырезать и вставлять его в каждый метод.
Во время тестирования часто бывает полезно узнать, что происходит в каком-то внутреннем методе. Сколько раз это называлось и, возможно, то, что оно возвращало. Вы можете добавить аспект для этого мониторинга, не добавляя отвлекающий тестовый код к самому методу. Редактирование кода для этого метода может быть даже невозможным.
Просто следите за тем, как реализованы аспекты. Некоторые реализации представляют собой сложные предварительные процессоры, которые могут сделать отладку вашего кода более сложной. Другие плавно переходят на язык. Динамические языки очень хорошо обрабатывают АОП. Perl имеет Aspect.pm для AOP и более общий Hook::LexWrap для выполнения крючков метода.
AOP мне интересен. Мне кажется, что регистрация и мониторинг производительности, отчетность - это то, что AOP предназначен для обработки. Для .NET, Post Sharp - очень хорошая основа для АОП.
Я немного экспериментировал с ним, но, похоже, он очень хорошо реализован.
Если вы собираетесь посмотреть Post Sharp, вы можете скачать Google Book Downloader из CodePlex. Я думаю, что этот проект использует его.
Не думайте, что это нечто совершенно другое. АОП улучшает (ИМО) ваш дизайн, уменьшая сцепление, увеличивая сплоченность, отдельные проблемы, предоставляя объект определенной ответственности типа 1. Если вы из мира .net, PostSharp использует пользовательские атрибуты для плетения советов. Если вы из мира Java, вы можете использовать расширение Java, называемое AspectJ. АОП имеет больше приложений, чем обычно.