# MethodTimer.Fody
**Repository Path**: anysharp/method-timer.-fody
## Basic Information
- **Project Name**: MethodTimer.Fody
- **Description**: MethodTimer.Fody 是一个功能强大的库，可以用于测量 .NET 应用程序中的方法的执行时间。允许你在不修改代码的情况下，自动地测量和记录方法的执行时间。
这个工具是基于.NET的 weaving 技术，通过修改IL（Intermediate Language，中间语言）代码来插入计时逻辑，从而在方法调用前后记录时间戳，进而计算出方法的执行时间。
- **Primary Language**: Unknown
- **License**: MIT
- **Default Branch**: master
- **Homepage**: https://www.cnblogs.com/1312mn/p/18317245
- **GVP Project**: No
## Statistics
- **Stars**: 1
- **Forks**: 1
- **Created**: 2024-10-14
- **Last Updated**: 2024-11-01
## Categories & Tags
**Categories**: Uncategorized
**Tags**: Fody
## README
# 
MethodTimer.Fody
[](https://gitter.im/Fody/Fody)
[](https://www.nuget.org/packages/MethodTimer.Fody/)
Injects some very basic method timing code.
**See [Milestones](../../milestones?state=closed) for release notes.**
### This is an add-in for [Fody](https://github.com/Fody/Home/)
**It is expected that all developers using Fody [become a Patron on OpenCollective](https://opencollective.com/fody/contribute/patron-3059). [See Licensing/Patron FAQ](https://github.com/Fody/Home/blob/master/pages/licensing-patron-faq.md) for more information.**
## Usage
See also [Fody usage](https://github.com/Fody/Home/blob/master/pages/usage.md).
### NuGet installation
Install the [MethodTimer.Fody NuGet package](https://nuget.org/packages/MethodTimer.Fody/) and update the [Fody NuGet package](https://nuget.org/packages/Fody/):
```powershell
PM> Install-Package Fody
PM> Install-Package MethodTimer.Fody
```
The `Install-Package Fody` is required since NuGet always defaults to the oldest, and most buggy, version of any dependency.
### Add to FodyWeavers.xml
Add `` to [FodyWeavers.xml](https://github.com/Fody/Home/blob/master/pages/usage.md#add-fodyweaversxml)
```xml
```
### Your Code
```csharp
public class MyClass
{
[Time]
public void MyMethod()
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
}
```
### What gets compiled without an Interceptor
```csharp
public class MyClass
{
public void MyMethod()
{
var stopwatch = Stopwatch.StartNew();
try
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
finally
{
stopwatch.Stop();
Trace.WriteLine("MyClass.MyMethod " + stopwatch.ElapsedMilliseconds + "ms");
}
}
}
```
### What gets compiled with an Interceptor
If you want to handle the logging you can define a static class to intercept the logging.
The interceptor takes one of the two following forms.
**Note:** when both methods are available, the intercepter will prefer the `TimeSpan` overload.
#### Interceptor with elapsed duration as long (milliseconds)
```csharp
public static class MethodTimeLogger
{
public static void Log(MethodBase methodBase, long milliseconds, string message)
{
//Do some logging here
}
}
```
Then this will be compiled
```csharp
public class MyClass
{
public void MyMethod()
{
var stopwatch = Stopwatch.StartNew();
try
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
finally
{
stopwatch.Stop();
MethodTimeLogger.Log(methodof(MyClass.MyMethod), stopwatch.ElapsedMilliseconds);
}
}
}
```
#### Interceptor with elapsed duration as TimeSpan
```csharp
public static class MethodTimeLogger
{
public static void Log(MethodBase methodBase, TimeSpan elapsed, string message)
{
//Do some logging here
}
}
```
Then this will be compiled
```csharp
public class MyClass
{
public void MyMethod()
{
var stopwatch = Stopwatch.StartNew();
try
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
finally
{
stopwatch.Stop();
MethodTimeLogger.Log(methodof(MyClass.MyMethod), stopwatch.Elapsed);
}
}
}
```
### Using parameters inside the logging
If you want to get the parameter values inside the logging, you can use a string format in the attribute definition.
```csharp
public class MyClass
{
[Time("File name: '{fileName}'")]
public void MyMethod(string fileName)
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
}
```
Then this will be compiled
```csharp
public class MyClass
{
public void MyMethod(string fileName)
{
var stopwatch = Stopwatch.StartNew();
try
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
finally
{
stopwatch.Stop();
var message = string.Format("File name: '{0}'", fileName);
MethodTimeLogger.Log(methodof(MyClass.MyMethod), stopwatch.ElapsedMilliseconds, message);
}
}
}
```
The following values are allowed:
* Any parameter name (e.g. `{fileName}`)
* `{this}` (calls `ToString()` on the instance itself) - Note that this is not available on static methods, the weaver will throw an error if being used in a static method
**Note 1:** sub-properties are not (yet?) supported. [Support Fody on OpenCollective](https://opencollective.com/fody) and this might be implemented!
**Note 2:** this feature requires an updated Log method call with the definition below. If this method (with the *message* parameter) is not found, the weaver will raise an error.
```
public static void Log(MethodBase methodBase, long milliseconds, string message)
```
## Whats in the NuGet
In addition to the actual weaving assembly the NuGet package will also add a file `TimeAttribute.cs` to the target project.
```csharp
[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Constructor,AllowMultiple = false)]
class TimeAttribute : Attribute
{
}
```
At compile time this attribute and all usages to it will be removed from the target assembly. If you want to re-use the class in a common assembly change the class from `internal` to `public`. This will result in the class not being removed at compile time.
## Icon
Icon courtesy of [The Noun Project](https://thenounproject.com)