C# 调用具有属性的函数
我有一个函数，它使用stopwatch的一个实例通过启动和停止来测量方法的时间。 我是否可以在属性中定义该函数，并用该属性修饰任何给定的方法来度量该方法的时间？ 这将降低LOC。 我不想使用任何第三方库C# 调用具有属性的函数,c#,methods,attributes,C#,Methods,Attributes,我有一个函数，它使用stopwatch的一个实例通过启动和停止来测量方法的时间。 我是否可以在属性中定义该函数，并用该属性修饰任何给定的方法来度量该方法的时间？ 这将降低LOC。 我不想使用任何第三方库 public class AppTrace:BaseModel<AppTrace> { [DataMember] public string Comment; [DataMember] public string MethodName;
public class AppTrace:BaseModel<AppTrace>
{
[DataMember]
public string Comment;
[DataMember]
public string MethodName;
[DataMember]
public DateTime StartTimeStamp;
[DataMember]
public int Duration;
[DataMember]
public int UserObjectId;
[DataMember]
public string MachineName;
[DataMember]
public int ToolId;
private System.Diagnostics.Stopwatch stpWatch;
public AppTrace(string comment,string methodName,int userObjectId ,string machineName = "",int? toolId=null)
{
MethodName = methodName;
UserObjectId = userObjectId;
StartTimeStamp = DateTime.UtcNow;
Comment = comment;
MachineName = machineName;
stpWatch = new System.Diagnostics.Stopwatch();
stpWatch.Start();
}
public AppTrace()
{
}
public void CloseTrace()
{
this.stpWatch.Stop();
Duration=Convert.ToInt32( this.stpWatch.ElapsedMilliseconds);
}
}
公共类AppTrace:BaseModel
{
[数据成员]
公共字符串评论；
[数据成员]
公共字符串方法名；
[数据成员]
公共日期时间StartTimeStamp；
[数据成员]
公共时间；
[数据成员]
公共int-UserObjectId；
[数据成员]
公共字符串MachineName；
[数据成员]
公共int工具ID；
专用系统.Diagnostics.Stopwatch stpWatch；
公共AppTrace（字符串注释、字符串方法名、int userObjectId、字符串machineName=“”、int？toolId=null）
{
MethodName=MethodName；
UserObjectId=UserObjectId；
StartTimeStamp=DateTime.UtcNow；
评论=评论；
MachineName=MachineName；
stpWatch=new System.Diagnostics.Stopwatch（）；
stpWatch.Start（）；
}
公共AppTrace（）
{
}
public void CloseTrace（）
{
这个.stpWatch.Stop（）；
持续时间=Convert.ToInt32（this.stpWatch.elapsedmillisons）；
}
}
如果不是属性，我可以在代表的帮助下完成这项工作吗？正如我在评论中所说的，通常不可能。您可以使用一些AOP框架，它可以非常成功地处理这些事情。或者编写一些调用实用程序 在最简单的情况下，您的实用程序可以如下所示：
public static class Invoke
{
public static TimeSpan Measure(Action action)
{
if (action == null)
{
throw new ArgumentNullException();
}
var stopWatch = Stopwatch.StartNew();
action();
stopWatch.Stop();
return stopWatch.Elapsed;
}
}
Foo// don't use such naming in production code
public class Foo
{
public void DoWork1()
{
// imitating hard computations
Thread.Sleep(TimeSpan.FromSeconds(5));
}
public void DoWork2(int param1)
{
// imitating hard computations
Thread.Sleep(param1);
}
}
public static class Program
{
public static void Main()
{
var foo = new Foo();
// signature of foo.DoWork1 is suitable for Invoke.Measure,
//so you can use it as MethodGroup
var time1 = Invoke.Measure(foo.DoWork1);
Console.WriteLine("Time for 'DoWork1' is {0}s", time1.TotalSeconds);
// signature of foo.DoWork2 is not suitable for Invoke.Measure,
// so you have to call it inside additional lambda
var time2 = Invoke.Measure(() => foo.DoWork2(42));
Console.WriteLine("Time for 'DoWork2' is {0}s", time2.TotalSeconds);
}
}
Timedpublic class Timed<T>
{
public readonly TimeSpan Duration;
public readonly T Result;
// making constructor private to force static factories usage
private Timed(T result, TimeSpan duration)
{
Result = result;
Duration = duration;
}
// static factory method instead of constructor, for generic parameter
// type inference
public static Timed<T> Create(T result, TimeSpan duration)
{
return new Timed<T>(result, duration);
}
}
顺便说一下，
F#REPL#timeF..NETfsi.exepublic static class Invoke
{
public static TimeSpan Measure(Action action)
{
if (action == null)
{
throw new ArgumentNullException();
}
var stopWatch = Stopwatch.StartNew();
action();
stopWatch.Stop();
return stopWatch.Elapsed;
}
}
Foo// don't use such naming in production code
public class Foo
{
public void DoWork1()
{
// imitating hard computations
Thread.Sleep(TimeSpan.FromSeconds(5));
}
public void DoWork2(int param1)
{
// imitating hard computations
Thread.Sleep(param1);
}
}
public static class Program
{
public static void Main()
{
var foo = new Foo();
// signature of foo.DoWork1 is suitable for Invoke.Measure,
//so you can use it as MethodGroup
var time1 = Invoke.Measure(foo.DoWork1);
Console.WriteLine("Time for 'DoWork1' is {0}s", time1.TotalSeconds);
// signature of foo.DoWork2 is not suitable for Invoke.Measure,
// so you have to call it inside additional lambda
var time2 = Invoke.Measure(() => foo.DoWork2(42));
Console.WriteLine("Time for 'DoWork2' is {0}s", time2.TotalSeconds);
}
}
Timedpublic class Timed<T>
{
public readonly TimeSpan Duration;
public readonly T Result;
// making constructor private to force static factories usage
private Timed(T result, TimeSpan duration)
{
Result = result;
Duration = duration;
}
// static factory method instead of constructor, for generic parameter
// type inference
public static Timed<T> Create(T result, TimeSpan duration)
{
return new Timed<T>(result, duration);
}
}
顺便说一下，
F#REPL#timeF..NETfsi.exeStopWatchInvoke.Measure（（）=>{/*dosomething*/}）StopWatchInvoke.Measure（（）=>{/*dosomething*/}）