如何更有效地用C#创建300个秒表？

我正在创建一个UWP应用程序，它需要测量用户观看对象的时间。这个应用程序有大约300个对象来测量时间。为此，我们将使用大约300个计时器。为了实现这一目标，我们必须单独创建300个秒表，这是非常低效的

计时器在用户注视相应对象时启动，在用户不再注视相应对象时停止。如果用户的目光再次聚焦在相应的对象上，计时器当然会再次启动。最后，秒表的所有时间都将保存到一个文件中。创建300个秒表需要为每个秒表添加一行新的代码，这似乎不是很有效。我曾尝试使用Enumerable.range自动化秒表创建过程，但到目前为止，我还没有找到解决方案

    /// <summary>
    /// All stopwatches for every word. In our real code we will have around 300 stopwatches.
    /// </summary>
    Stopwatch Stopwatch1 = new Stopwatch();
    Stopwatch Stopwatch2 = new Stopwatch();
    Stopwatch Stopwatch3 = new Stopwatch();
    Stopwatch Stopwatch4 = new Stopwatch();
    Stopwatch Stopwatch5 = new Stopwatch();
    Stopwatch Stopwatch6 = new Stopwatch();
    Stopwatch Stopwatch7 = new Stopwatch();
    Stopwatch Stopwatch8 = new Stopwatch();
    Stopwatch Stopwatch9 = new Stopwatch();
    Stopwatch Stopwatch10 = new Stopwatch();

//
///每个字都有秒表。在我们的真实代码中，我们将有大约300个秒表。
/// 
秒表秒表1=新秒表（）；
秒表秒表2=新秒表（）；
秒表秒表3=新秒表（）；
秒表秒表4=新秒表（）；
秒表秒表5=新秒表（）；
秒表秒表6=新秒表（）；
秒表秒表7=新秒表（）；
秒表秒表8=新秒表（）；
秒表秒表9=新秒表（）；
秒表秒表10=新秒表（）；

只需定义

List（）

var l=新列表（）；
对于（变量i=0；i<300；i++）
{
var w=秒表.StartNew（）；
w、 停止（）；
l、 加（w）；
}

要向您展示如何处理它，请参见此示例

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        public static List<Stopwatch> sws = new List<Stopwatch>();
        public static List<Thread> threads = new List<Thread>();

        static void Main()
        {
            for (var i = 0; i < 300; i++)
            {               
                threads.Add(new Thread(Dummy));
                sws.Add(new Stopwatch());
            }

            for(int i = 0; i < 300; i++) sws[i].Start();

            new Thread( () => { for(int i = 0; i < 5; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 5; i < 10; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 10; i < 15; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 15; i < 20; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 20; i < 25; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 25; i < 30; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 30; i < 35; i++) threads[i].Start(i); }).Start();
            new Thread( () => { for(int i = 35; i < 40; i++) threads[i].Start(i); }).Start();

            Console.Read();
        }

        static void Dummy(object data)
        {
            int i = (int)data;
            Thread.Sleep(250); 
            sws[i].Stop();
            Console.WriteLine(sws[i].ElapsedMilliseconds.ToString());
        }
    }
}     

使用系统；
使用System.Collections.Generic；
使用系统诊断；
使用系统线程；
使用System.Threading.Tasks；
命名空间控制台应用程序1
{
班级计划
{
公共静态列表sws=新列表（）；
公共静态列表线程=新列表（）；
静态void Main（）
{
对于（变量i=0；i<300；i++）
{               
添加（新线程（虚拟））；
添加（新秒表（））；
}
对于（inti=0；i<300；i++）sws[i].Start（）；
新线程（（）=>{for（inti=0；i<5；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=5；i<10；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=10；i<15；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=15；i<20；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=20；i<25；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=25；i<30；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=30；i<35；i++）线程[i].Start（i）；}.Start（）；
新线程（（）=>{for（inti=35；i<40；i++）线程[i].Start（i）；}.Start（）；
Console.Read（）；
}
静态无效虚拟对象（对象数据）
{
int i=（int）数据；
睡眠（250）；
sws[i].Stop（）；
Console.WriteLine（sws[i].elapsedmillisons.ToString（））；
}
}
}     

所以，首先需要获得可用对象的列表。您可以使用以下代码创建一个通用字典，为您拥有的每个对象保留秒表。还有一个生成凝视调查的方法的示例实现

您仍然需要添加调用start和stop方法的代码

class Program
{
    static Dictionary<object, Stopwatch> stopwatchesByObject;

    static void Main(string[] args)
    {
        List<object> objects = new List<object>();

        // now you have to fill the objects list...

        stopwatchesByObject = new Dictionary<object, Stopwatch>();
        foreach (var o in objects)
        {
            stopwatchesByObject.Add(o, new Stopwatch());
        }
    }

    // Call this method when the user starts gazing at object o
    static void StartGazingAt(object o)
    {
        stopwatchesByObject[o].Start();
    }

    // Call this method when the user stops gazing at object o
    static void StopGazingAt(object o)
    {
        stopwatchesByObject[o].Stop();
    }

    static void CreateStatistics()
    {
        StringBuilder sb = new StringBuilder();
        foreach (var entry in stopwatchesByObject)
        {
            sb.AppendLine($"Gazed at {entry.Key.ToString()} for {entry.Value.Elapsed.TotalSeconds} seconds.");
        }
        File.WriteAllText("c:\\temp\\statictics.txt", sb.ToString());
    }
}

类程序
{
静态字典stopwatchesByObject；
静态void Main（字符串[]参数）
{
列表对象=新列表（）；
//现在您必须填写对象列表。。。
stopwatchesByObject=新字典（）；
foreach（对象中的var o）
{
添加（o，newstopwatch（））；
}
}
//当用户开始注视对象o时调用此方法
静态空位StartGazingAt（对象o）
{
stopwatchesByObject[o]。开始（）；
}
//当用户停止注视对象o时调用此方法
静态空隙停止观测（对象o）
{
stopwatchesByObject[o]。停止（）；
}
静态void CreateStatistics（）
{
StringBuilder sb=新的StringBuilder（）；
foreach（stopwatchesByObject中的var条目）
{
sb.AppendLine（$“凝视{entry.Key.ToString（）}以获得{entry.Value.appeased.TotalSeconds}秒。”）；
}
writealText（“c:\\temp\\statics.txt”，sb.ToString（））；
}
}

我喜欢Stefan Illners的方法，并想添加一些linq魔术，在我看来，它非常简洁易读

using System.Linq;

var myListOfItemsToWatch = new List<object> { "foo", "bar", "baz" };
var listOfStopwatches = myListOfItemsToWatch.ToDictionary(watchItem =>
        watchItem, i => new Stopwatch()
);

使用System.Linq；
var myListOfItemsToWatch=新列表{“foo”、“bar”、“baz”}；
var listOfStopwatches=MyListofItemStopWatch.ToDictionary（watchItem=>
watchItem，i=>newstopwatch（）
);

为什么不创建一个

列表

，然后使用一个循环来初始化所需的秒表数量？您只需要一个秒表和一个位置来存储以前查看对象的时间量。然后在再次查看时增加该值。@Esko-如果不能同时有多个锁的话

using System.Linq;

var myListOfItemsToWatch = new List<object> { "foo", "bar", "baz" };
var listOfStopwatches = myListOfItemsToWatch.ToDictionary(watchItem =>
        watchItem, i => new Stopwatch()
);