Для данного класса я хотел бы иметь функцию трассировки, т.е. я хотел бы регистрировать каждый вызов метода (сигнатура метода и фактические значения параметров) и каждый выход метода (только сигнатура метода).
Как мне сделать это, если:
- Я не хочу использовать сторонние библиотеки AOP для C #,
- Я не хочу добавлять дублирующийся код ко всем методам, которые я хочу отследить,
- Я не хочу менять общедоступный API класса - пользователи класса должны иметь возможность вызывать все методы одинаково.
Чтобы сделать вопрос более конкретным, давайте предположим, что есть 3 класса:
public class Caller
{
public static void Call()
{
Traced traced = new Traced();
traced.Method1();
traced.Method2();
}
}
public class Traced
{
public void Method1(String name, Int32 value) { }
public void Method2(Object object) { }
}
public class Logger
{
public static void LogStart(MethodInfo method, Object[] parameterValues);
public static void LogEnd(MethodInfo method);
}
Как вызвать Logger.LogStart и Logger.LogEnd для каждого вызова Method1 и Method2 без изменения метода Caller.Call и без явного добавления вызовов в Traced.Method1 и Traced.Method2 ?
Изменить: Каково было бы решение, если бы мне позволили немного изменить метод Call?
c#
reflection
aop
Подмастерье
источник
источник
Ответы:
C # не AOP-ориентированный язык. Он имеет некоторые функции AOP, и вы можете эмулировать некоторые другие, но создание AOP с C # является болезненным.
Я искал способы сделать именно то, что вы хотели сделать, и я не нашел простого способа сделать это.
Насколько я понимаю, это то, что вы хотите сделать:
и для этого у вас есть два основных варианта
Унаследуйте свой класс от MarshalByRefObject или ContextBoundObject и определите атрибут, который наследуется от IMessageSink. Эта статья имеет хороший пример. Тем не менее, вы должны учитывать, что при использовании MarshalByRefObject производительность будет падать до чертиков, и я имею в виду, я говорю о 10-кратной потере производительности, поэтому подумайте, прежде чем пытаться это делать.
Другой вариант - ввести код напрямую. Во время выполнения это означает, что вам придется использовать отражение, чтобы «читать» каждый класс, получать его атрибуты и вводить соответствующий вызов (и в этом отношении я думаю, что вы не можете использовать метод Reflection.Emit, так как я думаю, что Reflection.Emit не не позволяет вам вставить новый код в уже существующий метод). Во время разработки это будет означать создание расширения для компилятора CLR, которое я, честно говоря, понятия не имею, как это делается.
Последний вариант - использование инфраструктуры IoC . Возможно, это не идеальное решение, так как большинство IoC-фреймворков работают путем определения точек входа, которые позволяют подключать методы, но, в зависимости от того, чего вы хотите достичь, это может быть справедливым приближением.
источник
Reflection.Emit
. Это подход, выбранный Spring.NET . Однако это потребует использования виртуальных методовTraced
и не очень подходит для использования без какого-либо контейнера IOC, поэтому я понимаю, почему этот параметр отсутствует в вашем списке.Самый простой способ добиться этого - использовать PostSharp . Он внедряет код в ваши методы на основе атрибутов, которые вы к нему применяете. Это позволяет вам делать именно то, что вы хотите.
Другой вариант - использовать API профилирования для внедрения кода внутри метода, но это действительно хардкор.
источник
Если вы напишите класс - назовите его Tracing - который реализует интерфейс IDisposable, вы можете обернуть все тела метода в
В классе Tracing вы можете обрабатывать логику трасс в методе constructor / Dispose, соответственно, в классе Tracing, чтобы отслеживать вход и выход из методов. Такой что:
источник
Этого можно добиться с помощью функции перехвата DI-контейнера, такого как Castle Windsor . Действительно, можно настроить контейнер таким образом, чтобы перехватывались все классы, у которых есть метод, декорированный определенным атрибутом.
Что касается пункта № 3, OP запросил решение без AOP Framework. В следующем ответе я предположил, что следует избегать Aspect, JointPoint, PointCut и т. Д. Согласно документации по перехвату от CastleWindsor , ни один из них не требуется для выполнения запрошенного.
Настройте общую регистрацию Перехватчика, основываясь на наличии атрибута:
Добавьте созданную IContributeComponentModelConstruction в контейнер
И вы можете делать все, что вы хотите в самом перехватчике
Добавьте атрибут logging в ваш метод для регистрации
Обратите внимание, что некоторая обработка атрибута потребуется, если требуется перехватить только какой-либо метод класса. По умолчанию все открытые методы будут перехвачены.
источник
Если вы хотите отслеживать ваши методы без ограничений (без адаптации кода, без AOP Framework, без дублированного кода), позвольте мне сказать вам, вам нужно немного магии ...
Серьезно, я решил внедрить AOP Framework, работающий во время выполнения.
Вы можете найти здесь: NConcern .NET AOP Framework
Я решил создать эту AOP Framework, чтобы дать ответ на такие потребности. это простая библиотека, очень легкая. Вы можете увидеть пример регистратора на домашней странице.
Если вы не хотите использовать стороннюю сборку, вы можете просмотреть исходный код (с открытым исходным кодом) и скопировать оба файла Aspect.Directory.cs и Aspect.Directory.Entry.cs в соответствии с вашими пожеланиями. Эти классы позволяют заменить ваши методы во время выполнения. Я бы просто попросил вас уважать лицензию.
Я надеюсь, что вы найдете то, что вам нужно, или убедите вас, наконец, использовать AOP Framework.
источник
Взгляните на это - довольно тяжелые вещи .. http://msdn.microsoft.com/en-us/magazine/cc164165.aspx
Essential .net - don box имел главу о том, что вам нужно, называется Перехват. Я кое-что здесь почистил (извините за цвета шрифта - у меня тогда была темная тема ...) http://madcoderspeak.blogspot.com/2005/09/essential-interception-using-contexts.html
источник
Я нашел другой способ, который может быть проще ...
Объявите метод InvokeMethod
Затем я определяю свои методы так
Теперь я могу иметь проверку во время выполнения без внедрения зависимости ...
Нет ошибок в сайте :)
Надеемся, вы согласитесь, что это меньше веса, чем AOP Framework или происходит от MarshalByRefObject или с использованием классов удаленного взаимодействия или прокси-классов.
источник
Сначала вы должны изменить свой класс для реализации интерфейса (а не реализации MarshalByRefObject).
Затем вам понадобится универсальный объект-обертка на основе RealProxy, чтобы украсить любой интерфейс, чтобы позволить перехватывать любой вызов к декорированному объекту.
Теперь мы готовы перехватывать вызовы Method1 и Method2 ITraced
источник
Вы можете использовать фреймворк с открытым исходным кодом CInject на CodePlex. Вы можете написать минимальный код для создания инжектора и заставить его быстро перехватывать любой код с помощью CInject. Плюс, так как это с открытым исходным кодом, вы можете расширить это.
Или вы можете выполнить шаги, упомянутые в этой статье, по перехвату вызовов методов с использованием IL и создать свой собственный перехватчик с использованием классов Reflection.Emit в C #.
источник
Я не знаю решения, но мой подход был бы следующим.
Украсьте класс (или его методы) пользовательским атрибутом. Где-то еще в программе, пусть функция инициализации отражает все типы, читает методы, украшенные атрибутами, и вводит некоторый код IL в метод. На самом деле может быть более практичным заменить метод заглушкой, которая вызывает
LogStart
метод, а затем методLogEnd
. Кроме того, я не знаю, можете ли вы изменить методы, используя отражение, так что может быть более практичным заменить весь тип.источник
Вы можете использовать шаблон GOF Decorator и «декорировать» все классы, которые нуждаются в трассировке.
Вероятно, это действительно практично только с контейнером IOC (но, как указывалось ранее, вы можете рассмотреть возможность перехвата метода, если собираетесь идти по пути IOC).
источник
вам нужно уговорить Айенде за ответ о том, как он это сделал: http://ayende.com/Blog/archive/2009/11/19/can-you-hack-this-out.aspx
источник
AOP является обязательным условием для реализации чистого кода, однако, если вы хотите заключить блок в C #, универсальные методы имеют относительно более простое использование. (с интеллигентным смыслом и строго типизированным кодом) Конечно, это не может быть альтернативой для АОП.
Хотя PostSHarp имеет небольшие проблемы с ошибками (я не чувствую уверенности в использовании на производстве), это хороший материал.
Общий класс обертки,
использование может быть таким (с интеллигентным смыслом, конечно)
источник
источник
Лучшее, что вы можете сделать до выхода C # 6 с именем nameof - это использовать медленные выражения StackTrace и linq.
Например, для такого метода
Такая строка может быть выдана в вашем лог-файле
Вот реализация:
источник