相关疑难解决方法(0)

我做了快速测试应用程序,将LINQ排序与我的自定义对象上的Array.Sort进行比较.Array.Sort似乎非常慢!

我创建了这样的自定义类:

class Person : IComparable<Person>
{
    public int Age { get; set; }
    public string Name { get; set; }

    public int CompareTo(Person obj)
    {
        return this.Age.CompareTo(obj.Age);
    }

    public Person()
    { }

}

然后我在main()中做了我的测试人员:

string name = "Mr. Tomek";

Random r = new Random();
int size = 10000000;

DateTime start, end;
Person[] people1 = new Person[size];
Person[] people2 = new Person[size];

for (int i = 0; i < size; i++)
{
     people1[i] = new Person();
     people1[i].Age = r.Next(0, 10000); …

在.NET 4中,System.IO.Path对该Combine方法具有以下重载:

public static string Combine(params string[] paths)
public static string Combine(string path1, string path2)
public static string Combine(string path1, string path2, string path3)
public static string Combine(string path1, string path2, string path3, string path4)

第一个是在.NET 4中添加的,以支持任意数量的路径参数.第二个在早期版本中已经存在,所以我认为它是为了向后兼容而保留的.

但我很好奇其他重载的用途是什么.第一种方法签名是否已涵盖这些用例params？

编辑:我现在相信答案是"因为并非所有语言都params支持(并且传递没有params支持的数组是不方便的)".然而,stackoverflow蜂巢的想法似乎强烈反对.因此,作为妥协,我不接受任何答案.

下面是一个简单的过程编码C#和Python(对于你们好奇的过程,它是项目欧拉问题5的解决方案).

我的问题是,C#下面的代码只需要9秒来迭代,而Python代码的完成需要283秒(确切地说,Python 3.4.3上的283秒 - 64位和Python 2.7.9上的329秒--32位).

到目前为止,我已经编写了类似的进程C#,Python并且执行时间差异可比.然而,这一次,经过的时间之间存在极大的差异.

我认为,这种差异的某些部分来自灵活变量类型的python语言(我怀疑,python将变量的某些部分转换为double)但是这仍然很难解释.

我究竟做错了什么？

我的系统:Windows-7 64位,

C# - VS Express 2012(9秒)

Python 3.4.3 64位(283秒)

Python 2.7.9 32位(329秒)

c-sharp代码:

using System;

namespace bug_vcs {
    class Program {
        public static void Main(string[] args) {
            DateTime t0 = DateTime.Now;
            int maxNumber = 20;
            bool found = false;
            long start = maxNumber;
            while (!found) {
                found = true;
                int i = 2;
                while ((i < …

在静态Stopwatch构造函数中,我们可以看到以下代码,它基本上检查是否存在高分辨率性能计数器.

static Stopwatch()
{
    if (!SafeNativeMethods.QueryPerformanceFrequency(out Frequency))
    {
        IsHighResolution = false;
        Frequency = 0x989680L;
        tickFrequency = 1.0;
    }
    else
    {
        IsHighResolution = true;
        tickFrequency = 10000000.0;
        tickFrequency /= (double) Frequency;
    }
}

在MSDN上,它说QueryPerformanceFrequency:

检索高分辨率性能计数器的频率(如果存在)

然而,目前还不清楚它究竟存在的时候？我怀疑它通常存在于当前的机器上,但究竟不是吗？

这很有意思,因为当它不存在时,Stopwatch变成仅仅DateTime.UtcNow属性的包装.

我正在为我的大学制作一个图像隐写术项目.我已完成项目并保留了几种不同的算法来隐藏图像中的数据.

我想问的是,在C#中有什么方法可以通过它找到程序中两点之间的执行/运行时间.例如

//Some Code
//Code to start recording the time.
hideDataUsingAlgorithm();
//Code to stop recording and get the time of execution of the above function. 

我想这样做是为了显示简单(耗时较少)和更高效但耗时的算法(使用相同的数据和相同的图像)之间的区别.我有大约10种不同的Color和GrayScale图像算法.

没有多线程因此不会成为问题.Theres只是一个主线程.

问:如何计算呈现MVC页面并在母版页上显示时间所需的总时间.

在Asp.net Web Form中,我创建了一个Base页面类,如下所示:

public class PageBase : System.Web.UI.Page
{      
    private DateTime startTime = DateTime.Now;
    private TimeSpan renderTime;   
    public DateTime StartTime
    {
        set { startTime = value; }
        get { return startTime; }
    }  
    public virtual string PageRenderTime
    {
        get
        {
            renderTime = DateTime.Now - startTime;
            return renderTime.Seconds + "." + renderTime.Milliseconds + " seconds";
        }
    }       
}

然后我会在我的母版页上调用方法,如下所示:

<div id="performance">
     <% =PageRenderTime %>
</div>

问:我如何使用MVC框架完成同样的事情？

问:使用MVC框架,我在哪里设置首次创建页面的开始时间？

我发现了一个测量功能性能的好问题,答案建议使用秒表,如下所示

Stopwatch sw = new Stopwatch();
sw.Start();
//DoWork
sw.Stop();
//take sw.Elapsed

但如果您在多处理器机器下运行,这是否有效？线程可以切换到另一个处理器,可以吗？同样的事情也应该在Enviroment.TickCount中.如果答案是肯定的,我应该将我的代码包装在BeginThreadAffinity中,如下所示

Thread.BeginThreadAffinity();
Stopwatch sw = new Stopwatch();
sw.Start();
//DoWork
sw.Stop();
//take sw.Elapsed
Thread.EndThreadAffinity();

PS

切换可以在线程级别上发生,而不仅仅是处理器级别,例如,如果函数在另一个线程中运行,那么系统可以将其切换到另一个处理器,如果发生这种情况,秒表在切换后是否有效？

我不是仅使用秒表进行性能测量,而是使用Thread.Sleep模拟定时器功能(以防止呼叫重叠)

如果我有一个共享System.Diagnostics.Stopwatch实例,多个线程可以shared.ElapsedTicks安全地调用并获得准确的结果吗？

以这种方式使用秒表的共享实例和使用静态GetTimeStamp()方法之间的线程安全性/准确性方面是否存在差异？

我测量的180ms时左右间隔,并且发现使用共享实例是给我结果的价差较大,包括更短,比我期望一个显著数量.

该机器有多个CPU(2*英特尔X5550,它的价值)

我喜欢设置计时器来计算执行中特定进程的c#中的执行时间.我怎样才能做到这一点

我在我的数据库中有一个大约200,000个条目的视图.我正在阅读以下代码:

using (SqlConnection conn = new SqlConnection....)
{
    conn.Open();

    string query = "SELECT * FROM SP3DPROJECT.dbo.XSystemHierarchy";

    using (SqlCommand comm = new SqlCommand())
    {
        comm.CommandText = query;
        comm.Connection = conn;

        using (SqlDataReader reader = comm.ExecuteReader())
        {
            DateTime start = DateTime.Now;

            while (reader.Read())
            {
                // Code goes here, but for performance 
                // test I'm letting this empty
            }

            DateTime end = DateTime.Now;
            TimeSpan elapsed = (end- start).TotalSeconds;
        }
    }
}

视图只有2列GUID类型.将ExecuteCommand()是非常快的,但while循环(甚至没有任何代码,只是循环)大约需要150秒.

有更好或更快的方法吗？