C# 监测每个方法的执行次数和占用时间（测试4）

最新推荐文章于 2024-08-18 13:53:45 发布
最新推荐文章于 2024-08-18 13:53:45 发布
阅读量722 收藏
点赞数
文章标签： c# json
原文链接：http://www.cnblogs.com/guxingy/p/11063298.html
版权

　　今天也要做这个功能，就百度一下，结果搜索到了自己的文章。一开始还没注意，当看到里面的一个注释的方法时，一开始还以为自己复制错了代码，结果仔细一看网页的文章，我去，原来是自己写的，写的确实不咋地。

把自己的文章的代码复制了下来，稍微改了一下，运行看了一下效果，然后仔细一看，计算的总时间不对，如下图：

上一篇文章的地址：https://www.cnblogs.com/guxingy/p/10142242.html

改了几个地方：

    /// <summary>
    /// 拦截器
    /// </summary>
    public class CallingLogInterceptor : IInterceptor
    {
        private DateTime dt { get; set; }
        private TimeSpan ts { get; set; }

        /// <summary>
        /// 方法执行前
        /// </summary>
        /// <param name="invocation"></param>
        private void PreProceed(IInvocation invocation)
        {
            dt = DateTime.Now;
        }

        /// <summary>
        /// 方法执行后
        /// </summary>
        /// <param name="invocation"></param>
        private void PostProceed(IInvocation invocation)
        {
            ts = DateTime.Now - dt;


            Console.WriteLine($"方法名称：{invocation.Method.Name}" );
            Console.WriteLine($"开始时间：{dt.ToString("yyyy-MM-dd HH:mm:ss fff")}");
            Console.WriteLine($"结束时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff")}");
            Console.WriteLine($"所用时间：{ts.TotalSeconds}");


            MethodOperationInfo.Add(invocation, ts.TotalMilliseconds);
        }

        /// <summary>
        /// 拦截
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            this.PreProceed(invocation);
            invocation.Proceed();//调用
            this.PostProceed(invocation);
        }
    }
View Code 
    /// <summary>
    /// 测试类1
    /// </summary>
    public class Class5_test1
    {
        public virtual void test1()
        {
            test4();            
            test3();
            test2();
        }
        public virtual void test2()
        {
            System.Threading.Thread.Sleep(1000);
        }
        public virtual void test3()
        {
            System.Threading.Thread.Sleep(2000);
        }
        public virtual void test4()
        {
            System.Threading.Thread.Sleep(3000);
        }
    }
View Code 
    public class MyProxyGenerator
    {
        /// <summary>
        /// 创建一个代理对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T CreateProxy<T>() where T : class
        {
            ProxyGenerator generator = new ProxyGenerator();//代理
            CallingLogInterceptor interceptor = new CallingLogInterceptor();//定义 拦截器
            T entity = generator.CreateClassProxy<T>(interceptor);
            return entity;
        }
    }
View Code 
    public class Class2
    {
        public static void test1()
        {
            Class5_test1 entity = MyProxyGenerator.CreateProxy<Class5_test1>();
            entity.test1();
            MethodOperationInfo.ShowContainsDetail();

            Console.Read();
        }
    }
View Code

 

说明：所有的测试，只是修改了一下Class5_test1 这个类给

测试1

    /// <summary>
    /// 测试类1
    /// </summary>
    public class Class5_test1
    {
        public virtual void test1()
        {            
            test2();
            test3();
            test4();
        }
        public virtual void test2()
        {
            System.Threading.Thread.Sleep(1000);
        }
        public virtual void test3()
        {
            System.Threading.Thread.Sleep(2000);
        }
        public virtual void test4()
        {
            System.Threading.Thread.Sleep(3000);
        }
    }
View Code

问题：这里test1调用了test2、test3、test4，那么执行test1所用时间，应该是test2、test3、test4所用时间的总和，正确所用时间至少应该是6秒（1+2+3），结果这里输出的是3秒多，肯定不对。

 

测试2

    /// <summary>
    /// 测试类1
    /// </summary>
    public class Class5_test1
    {
        public virtual void test1()
        {
            test4();
            test3();            
            test2();
        }
        public virtual void test2()
        {
            System.Threading.Thread.Sleep(1000);
        }
        public virtual void test3()
        {
            System.Threading.Thread.Sleep(2000);
        }
        public virtual void test4()
        {
            System.Threading.Thread.Sleep(3000);
        }
    }
View Code

问题：这里的test1方法的所用时间是1秒多，更不对了。

 

结论：

　　测试1 和 测试2 的区别，只是在test1里面改变了test2、test3、test4的执行顺序，结果时间却迥然不同，更奇怪的是，test1的所用时间，更是莫名的接近调用的倒数第二个方法。

　　测试1里面，test1的所用时间，很接近test4。

　　测试2里面，test1的所用时间，很接近test2。

　　反正就是所用时间，很接近 方法体里面 最后一个 调用的方法，原因找到了再补充，了解一下动态代理的原理或许就知道了，也获取是自己写错了，估计是第一种可能

 

 

乘着自己好奇，又测试了一下，看下面哦

    /// <summary>
    /// 测试类1
    /// </summary>
    public class Class5_test1
    {
        public virtual void test1()
        {
            Console.WriteLine("开始执行test1");
            test4();
            test3();            
            test2();
            Console.WriteLine("执行完成test1");
        }
        public virtual void test2()
        {
            System.Threading.Thread.Sleep(1000);
        }
        public virtual void test3()
        {
            System.Threading.Thread.Sleep(2000);
        }
        public virtual void test4()
        {
            System.Threading.Thread.Sleep(3000);
        }
    }
View Code

主要是是在，test1方法里面添加了方法的执行情况， 输出 开始执行 和 执行完成。

 

 

找到原因了：拦截器对象只创建了一个，所以dt一直都是最后调用的那个方法的开始时间

　　　　　　还是自己写的代码有问题啊

 

赋上 改好的全部代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;



using Castle.Core.Interceptor;
using Castle.DynamicProxy;
using System.Reflection;
using Newtonsoft.Json;
using System.Security.Cryptography;

namespace ConsoleApplication3
{
    //原文：https://www.cnblogs.com/guxingy/p/10142242.html

    public class Class2
    {
        public static void test1()
        {
            Class5_test1 entity = MyProxyGenerator.CreateProxy<Class5_test1>();
            entity.test1();
            MethodOperationInfo.ShowContainsDetail();
        }
    }



    public class MyProxyGenerator
    {
        /// <summary>
        /// 创建一个代理对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T CreateProxy<T>() where T : class
        {
            ProxyGenerator generator = new ProxyGenerator();//代理
            CallingLogInterceptor interceptor = new CallingLogInterceptor();//定义 拦截器
            T entity = generator.CreateClassProxy<T>(interceptor);
            return entity;
        }
    }




    /// <summary>
    /// 拦截器
    /// </summary>
    public class CallingLogInterceptor : IInterceptor
    {
        private DateTime dt { get; set; }
        private TimeSpan ts { get; set; }


        /// <summary>
        /// 方法执行前
        /// </summary>
        /// <param name="invocation"></param>
        private void PreProceed(IInvocation invocation)
        {
            //创建一个唯一的标识
            //创建一个对象，并记录开始时间

            //dt = DateTime.Now;
            //Console.WriteLine($"开始执行，方法名称：{invocation.Method.Name}，开始时间：{dt.ToString("yyyy-MM-dd HH:mm:ss fff")}");
            //Console.WriteLine();

            MethodOperationInfo.SetStartTime(invocation);
        }

        /// <summary>
        /// 方法执行后
        /// </summary>
        /// <param name="invocation"></param>
        private void PostProceed(IInvocation invocation)
        {
            //通用标识找到之前创建的那个对象，并记录结束时间
            
            //ts = DateTime.Now - dt;
            //Console.WriteLine($"执行完成，方法名称：{invocation.Method.Name}");
            //Console.WriteLine($"    开始时间：{dt.ToString("yyyy-MM-dd HH:mm:ss fff")}");
            //Console.WriteLine($"    结束时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff")}");
            //Console.WriteLine($"    所用时间：{ts.TotalSeconds}");
            //Console.WriteLine();
            
            MethodOperationInfo.SetEndTime(invocation);
        }

        /// <summary>
        /// 拦截
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            this.PreProceed(invocation);
            invocation.Proceed();//调用
            this.PostProceed(invocation);
        }
    }


    
    /// <summary>
    /// 扩展
    /// </summary>
    public static class IntExtension
    {
        public static string ToString(this object obj, int len, bool afterFill = true)
        {
            string name = obj.ToString();
            //int count = len - name.Length;//不能用这个 汉字和英文占用的长度不同
            int count = len - System.Text.Encoding.Default.GetBytes(name).Length;

            if (afterFill)
            {
                for (int i = 0; i < count; i++)
                {
                    name += " ";
                }
                return name;

            }
            else
            {
                string value = "";
                for (int i = 0; i < count; i++)
                {
                    value += " ";
                }
                value += name;
                return value;
            }
        }
    }



    /// <summary>
    /// 操作日志
    /// </summary>
    public class MethodOperationInfo
    {
        public string NameSpaceName { get; set; }
        public string ClassName { get; set; }
        public string MethodName { get; set; }
        public string Parameters { get; set; }
        public string ParameterTypes { get; set; }
        public double TotalMilliseconds { get; set; }


        public string Name { get; set; }
        public DateTime StartTime { get; set; }
        public DateTime EndTime { get; set; }
        public bool IsEnd { get; set; }//标识这个对象是否完成计算耗时
        
        




        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="invocation"></param>
        public MethodOperationInfo(IInvocation invocation)
        {
            StartTime = DateTime.Now;
            NameSpaceName = invocation.TargetType.Namespace;
            ClassName = invocation.TargetType.Name;
            MethodName = invocation.Method.Name;//方法名
            ParameterTypes = GetParameterTypes(invocation);//参数类型
            Parameters = GetParameter(invocation);//参数
            Name = GetName(invocation);
            IsEnd = false;
        }


        /// <summary>
        /// 操作完成
        /// </summary>
        /// <param name="invocation"></param>
        public void OperationFinish(IInvocation invocation)
        {
            EndTime = DateTime.Now;
            TotalMilliseconds = (EndTime - StartTime).TotalMilliseconds;
            IsEnd = true;
        }





        //存放 所有的 详细信息
        public static List<MethodOperationInfo> operationInfos = new List<MethodOperationInfo>();
        

        /// <summary>
        /// 设置开始时间
        /// </summary>
        /// <param name="invocation"></param>
        public static void SetStartTime(IInvocation invocation)
        {
            MethodOperationInfo model = new MethodOperationInfo(invocation);
            operationInfos.Add(model);
        }

        /// <summary>
        /// 设置结束时间
        /// </summary>
        /// <param name="invocation"></param>
        public static void SetEndTime(IInvocation invocation)
        {
            MethodOperationInfo model = GetModel(invocation);
            model.OperationFinish(invocation);
        }

        /// <summary>
        /// 获取一个对象
        /// </summary>
        /// <param name="invocation"></param>
        /// <returns></returns>
        public static MethodOperationInfo GetModel(IInvocation invocation)
        {
            string name = GetName(invocation);
            return operationInfos.Where(c => (c.Name == name) && !c.IsEnd).FirstOrDefault();
        }

        /// <summary>
        /// 获取 这个方法 唯一的编号，针对方法而已
        /// </summary>
        /// <param name="invocation"></param>
        /// <returns></returns>
        public static string GetName(IInvocation invocation)
        {
            string NameSpaceName = invocation.TargetType.Namespace;
            string ClassName = invocation.TargetType.Name;
            string MethodName = invocation.Method.Name;//方法名
            string ParameterTypes = GetParameterTypes(invocation);
            string Parameters = GetParameter(invocation);//参数

            string strId = $"{NameSpaceName},{ClassName},{MethodName},{ParameterTypes}";

            //MD5加密
            byte[] result = Encoding.Default.GetBytes(strId);
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] output = md5.ComputeHash(result);
            return BitConverter.ToString(output).Replace("-", "");
        }


        /// <summary>
        /// 获取方法的参数类型
        /// 如：(System.String, System.Object, System.Int32)
        /// </summary>
        /// <param name="invocation"></param>
        /// <returns></returns>
        public static string GetParameterTypes(IInvocation invocation)
        {
            MethodInfo mInfo = invocation.Method;
            ParameterInfo[] pInfos = mInfo.GetParameters();

            string str = "";
            str += "(";
            for (int j = 0; j < pInfos.Length; j++)
            {
                var p = pInfos[j];
                string pTypeName = $"{p.ParameterType.ToString()}, ";
                if (p.ParameterType.IsGenericType && (p.ParameterType.GetGenericTypeDefinition() == typeof(Nullable<>)))
                {
                    pTypeName = $"{Nullable.GetUnderlyingType(p.ParameterType).Name}?, ";
                }
                str += pTypeName;
            }
            str = str.TrimEnd(' ').TrimEnd(',');
            str += ")";

            return str;
        }

        /// <summary>
        /// 获取方法的参数
        /// </summary>
        /// <param name="invocation"></param>
        /// <returns></returns>
        public static string GetParameter(IInvocation invocation)
        {
            string Parameters = "";//参数
            if ((invocation.Arguments != null) && (invocation.Arguments.Length > 0))
            {
                Parameters = JsonConvert.SerializeObject(invocation.Arguments);
            }
            return Parameters;
        }


        /// <summary>
        /// 显示日志
        /// </summary>
        /// <param name="ShowDetailRecord">是否显示详情记录-比较占用时间</param>
        /// <param name="IsFilter">是否开启过滤</param>
        public static void Show(bool ShowDetailRecord = true, bool IsFilter = false)
        {
            StringBuilder sb = new StringBuilder();
            DateTime beforDT = DateTime.Now;
            List<string> list_Show_Method = new List<string>() { "GetSingle_Value1" };//可改为配置参数



            //每个方法-耗时            
            string str = "";
            double totalMilliseconds_AllMethod = 0;


            //去重
            var operationInfos_NotRepeat = operationInfos.GroupBy(c => c.Name).Select(c => c.First()).ToList();

            //分组统计
            operationInfos.GroupBy(c => c.Name).Select(c => new
            {
                Name = c.Key,
                ExecuteNumber = c.Count(),
                TotalMilliseconds = c.Sum(a => a.TotalMilliseconds)
            }).ToList().ForEach(c =>
            {
                var item = operationInfos_NotRepeat.Where(x => x.Name == c.Name).First();
                totalMilliseconds_AllMethod += item.TotalMilliseconds;

                str += $"命名空间：{item.NameSpaceName.ToString(40)}     ";
                str += $"类名：{item.ClassName.ToString(30)}     ";
                str += $"方法：{item.MethodName.ToString(80)}     ";
                str += $"次数：{c.ExecuteNumber.ToString(10)}     ";
                str += $"耗时：{c.TotalMilliseconds.ToString(10, false) }毫秒     ";
                str += $"\r\n";
            });
            sb.Append(str + "\r\n\r\n");

            //方法-总耗时
            str = "";
            str += $"所有方法-耗时：{totalMilliseconds_AllMethod}毫秒    ";
            str += $"{totalMilliseconds_AllMethod / 1000}秒    ";
            str += $"{(totalMilliseconds_AllMethod / 1000 / 60).ToString("f2")}分钟    ";
            str += $"当前时间：{DateTime.Now}    ";
            sb.Insert(0, str + "\r\n\r\n");



            #region 方法 每次耗时的 详情信息

            if (ShowDetailRecord)
            {
                for (int i = 0; i < operationInfos.Count; i++)
                {
                    Console.WriteLine($"处理数据-当前行：{operationInfos.Count - i}");
                    var item = operationInfos[i];

                    //数据过滤                   
                    if (IsFilter && !list_Show_Method.Contains(item.MethodName))
                    {
                        continue;
                    }

                    sb.Append($"命名空间：{item.NameSpaceName.ToString(40)}     ");
                    sb.Append($"类名：{item.ClassName.ToString(30)}     ");
                    sb.Append($"方法：{item.MethodName + item.ParameterTypes.ToString(80)}     ");
                    sb.Append($"耗时：{item.TotalMilliseconds.ToString(10, false) }毫秒     ");
                    sb.Append($"参数：{item.Parameters.ToString(50)}     ");
                    sb.Append($"\r\n");
                }
            }
            #endregion

            //计算日志-耗时
            sb.Insert(0, $"计算日志-耗时：{DateTime.Now.Subtract(beforDT).TotalSeconds.ToString("#0.00000")}秒 \r\n\r\n");


            System.IO.File.WriteAllText($"LOG_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}.txt", sb.ToString());
            Console.WriteLine("完成！");
        }

        /// <summary>
        /// 显示日志 包含详情数据
        /// </summary>
        public static void ShowContainsDetail()
        {
            Show(true);
        }

        /// <summary>
        /// 显示日志 不包含详情数据
        /// </summary>
        public static void ShowNotContainsDetail()
        {
            Show(false);
        }
    }




    

    /// <summary>
    /// 测试类1
    /// </summary>
    public class Class5_test1
    {
        public virtual void test1()
        {
            Console.WriteLine("主方法-test1-开始执行");
            Console.WriteLine();

            for (int i = 0; i < 4; i++)
            {
                test4();
            }
            for (int i = 0; i < 3; i++)
            {
                test3();
            }
            for (int i = 0; i < 2; i++)
            {
                test2();
            }

            Console.WriteLine("主方法-test1-执行完成");
            Console.WriteLine();
        }
        public virtual void test2()
        {
            System.Threading.Thread.Sleep(200);
        }
        public virtual void test3()
        {
            System.Threading.Thread.Sleep(300);
        }
        public virtual void test4()
        {
            System.Threading.Thread.Sleep(400);
        }
    }








}
View Code

 

但是当要代理的那个的类，如果没有无参构造函数，这种方法就还是用不了，准备解决这个问题，解决了到时候再贴上解决方案。

 

本来是准备用到生产环境测试一下自己的代码的，结果，我去，有参构造函数，接口，多态，麻蛋都有啊，改好了，再继续贴代码

 

转载于:https://www.cnblogs.com/guxingy/p/11063298.html

weixin_33729196
关注
C#函数执行时间
qq_42001894的博客
12-16 896
递归和循环执行时间比较 C#计算函数执行时间System.Diagnostics.Stopwatch或者System.DateTime.Now using System; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Text; using System.Thr...
C# 监测每个方法的执行次数和占用时间（测试3）
weixin_34138255的博客
12-19 853
原文：http://www.cnblogs.com/RicCC/archive/2010/03/15/castle-dynamic-proxy.html 在Nuget引用 Castle.DynamicProxy 和Newtonsoft.Json 这个 操作日志的作用： 　　　　可用来分析方法的执行效率 　　　　分析方法执行效率慢的原因 　　　　根据传入的参数测试，找到运行...
C# AOP动态代理的使用【站在巨人的肩膀上编程：调包】
最新发布
冰凌的博客
08-18 364
之前本人发布过一篇简单实现AOP的博客，那个主要针对的是需要代理的类不变，而代理前置后置处理经常发生变化的情况。最近遇到前置后置处理不变，而需要代理的类经常变化的情况，所以我们必须学习新的代理设计满足当下的需求。5、编写代理类的实现代码，代理类实现IInterceptor接口，invocation.Proceed方法就是被代理的方法，使用语法这里不多赘述，有兴趣的朋友请仔细阅读源码。被代理类经常需要变化，而代理的前置后置处理基本不变的时候，推荐使用这种动态代理实现方式。6、把代理类和被代理类关联起来使用。
C# 监测每个方法的执行次数和占用时间（测试1）
weixin_33924220的博客
12-17 194
在Nuget引用 Castle.DynamicProxy 和Newtonsoft.Json 这个 原文：http://www.cnblogs.com/RicCC/archive/2010/03/15/castle-dynamic-proxy.html 代码： using Castle.Core.Interceptor; using Castle.DynamicProxy...
C# 监测每个方法的执行次数和占用时间（测试2）
weixin_34290390的博客
12-17 153
在Nuget引用 Castle.DynamicProxy 和Newtonsoft.Json 这个 原文：http://www.cnblogs.com/RicCC/archive/2010/03/15/castle-dynamic-proxy.html 代码： using Castle.Core.Interceptor; using Castle.DynamicProxy; ...
c# 测试方法执行时间
weixin_33915554的博客
11-28 157
class Program { static void Main(string[] args) { Console.WriteLine(ActionExtension.Profiler(a, 10)); } static void a() { } ...
C#析构函数与内存压力测试：析构对性能影响的全面评估
析构函数是C#语言中管理资源和内存清理的重要特性。了解析构函数的工作机制，可以帮助我们更有效地管理内存，避免资源泄露，从而提高应用程序的性能和稳定性。本章将从析构函数的基本概念入手，探讨其在现代C#编程中...
c#行计数器，性能监视器
11-06
然而，手动添加这种特性到每个方法并不实际。你可能需要一个更通用的解决方案，比如通过IL注入或动态代理，但这涉及到更复杂的编程技巧。 另一方面，Windows自带的性能监视器（Performance Monitor，PerfMon）是一...
监测IIS应用程序池小工具
05-06
在IIS中，每个应用程序池都是一个独立的进程空间，用来运行一个或多个网站或应用程序。这样设计的原因主要是为了隔离应用程序，确保一个应用的问题不会影响到其他应用，同时也可以设置不同的资源限制和配置参数以...
C#特性性能影响分析：5个优化策略，提升系统效率
C#特性的基本概念和作用 C#是微软开发的一种面向对象的高级编程语言，广泛应用于.NET框架中。C#中的特性（Attributes）是一种声明性的标记，允许开发者在代码中添加元数据，这些元数据可以被编译器和其他工具读取...
模糊测试--强制性安全漏洞发掘
热门推荐
软件性能测试专栏
01-20 2万+
文档分享地址链接：http://pan.baidu.com/share/link?shareid=2723797392&uk=2485812037 密码：r43x 前 言 我知道"人类和鱼类能够和平共处" 。 --George W. Bush, 2000年9月29日 简介 模糊测试的概念至少已经流传了20年，但是直到最近才引起广泛的关注。安全漏洞困扰了许多流行的客户端应用程序
C#测量程序运行时间及cpu使用时间实例方法
12-31
这里要指出的是， 运行一段程序，使用的cpu时间，跟实际运行的时间是不一样的。附例如下： 代码如下:private void ShowRunTime()  {   TimeSpan ts1 = Process.GetCurrentProcess().TotalProcessorTime;   Stopwatch stw = new Stopwatch();  stw.Start();  int Circles = 1000;   for (int i = 0; i < Circles; ++i)  {  }  double Msecs = Process.GetCurrentProcess(
c# 统计方法执行时间
weixin_30432179的博客
10-13 237
在System.Diagnostics命名空间中dot net framework为我们提供了精确计算代码执行时间的类Stopwatch； Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); //要测试的方法 stopWatch.Stop(); Trace.WriteLine(stopWatch.ElapsedTi...
7期同学12月5日的上机问题总结【C#类中成员实例化的执行顺序】
weixin_30325071的博客
12-05 137
有同学写了以下代码，大家想想结果是怎样的？ 1usingSystem; 2usingSystem.Collections.Generic; 3usingSystem.Linq; 4usingSystem.Text; 5 6namespaceMyTest 7{ 8classProgram 9{ 10staticv...
C#计算代码执行时间
weixin_30332241的博客
03-21 132
在一些测试工作时我们需要获得高精度的代码执行时间以比较其效率。最近遇到一个模块其执行时间非常短，但是调用频率非常高。精确计算其运算时间对于提高程序整体效率来说非常重要。 在我刚刚接触.Net时，也曾经想要测试一下自己写的程序的运行时间，当时我使用的是将两个DateTime.Now相减的笨方法，呵呵。后来知道使用Environment.TickCount，对于一般的测试来说就足够了。但是它...
C# 监测每个方法的执行次数和占用时间（测试5）
weixin_30258901的博客
07-03 255
又找到了一个bug 测试的类： public class Class11_1 { public virtual List<int> test2_1(List<tb_SensorRecordModel> SensorRecords) { List<...
C# 代码执行时间
linchaoa1989的博客
09-27 340
【代码】 C# 代码执行时间。
利用静态变量记录并控制递归函数的执行次数
u012393450的博客
09-26 3466
static关键字         在PHP的函数内部中，当我们定义一个变量为static时，需要对该变量进行初始化对该变量赋值且仅初始化一次，由于static修饰的变量是局部的，该变量仅在函数内部有效，当每次调用该函数时，该变量的值都会保留。         利用这一特性，可以统计出递归函数的调用次数，并可以做限制，防止未收敛的函数无线执行下去，造成死循环。
C#中获取代码执行时间的方法
weixin_44171249的博客
10-24 1192
C#获取代码块执行时间的方法
C#方法执行时间测量与代码注入实践
本文主要介绍了在C#中如何获取方法执行时间的方法，包括使用DateTime对象和Stopwatch类，并探讨了如何通过代码注入实现对整个项目中所有方法执行时间的监控。此外，还提及了利用面向切面编程（AOP）技术，特别是通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值