增强方法的性能

Question

以下方法如何表现更好？

首先是一些背景资料：

表单和使用的逻辑之间的映射（在更深的一层上）放在字典CtrlLogicMapping中。

一个控件可以具有多个逻辑（例如，用于表单上的不同控件）。

在某些情况下，有必要知道某个对象是否已经在一个（独立于哪个）控制逻辑中使用。

每个逻辑可以具有一个或多个映射的对象范围，这些对象范围来自第三方供应商，并且包含有关映射到db的对象的信息。

如果使用对象，则aLogic.ObjectScope.IsUsed（ObjectID）可以返回true或false。

我想要一个方法，一旦对象中存在对象，它就会询问所有现有的ObjectScope，并且一旦对象范围中的对象为true，就应立即返回（不再需要处理其他对象范围。ObjectScope可以处于多个逻辑中）。

并非每种形式都需要逻辑（因此列表可以为null或为空），也不是每种逻辑都需要对象范围（也可以是null或为空）。

InUse方法有些耗时（测试中的InUse花费了60到140毫秒）。

因此，我想避免尽可能多地调用InUse，并尽可能地对其进行并行化。

迭代解决方案：

internal bool InUse (string ID_in){

        List<string> checked = new List<string>();

        if (null != frmLogicMapping && 0 < frmLogicMapping.Count)
        {
            foreach (List<Logic> logics in frmLogicMapping.Values)
            {
                if (null != logics && 0 < logics.Count)
                {
                    foreach (Logic aLogic in logics)
                    {
                        if (null != aLogic.ObjectScope)
                        {
                            if (!checked.Contains(aLogic.ObjectScope.ID)) 
                            {
                                // can take up to 140 ms
                                if (aLogic.ObjectScope.InUse(ID_in)) 
                                    return true;
                                checkeded.Add(aLogic.ObjectScope.ID);
                            }
                        }
                    }
                }
            }
        }
        return false;
   }

有没有一种方法可以使用InUse == true应该立即返回true且其他处理不应报告任何内容的停止条件进行校验呢？

还是coudl，它也可以用PLINQ编写？ 如何在PLINQ中处理空值？ 还是普通的LINQ是更好的选择？ （甚至如何处理空值？）

我想做的是

        if (null != frmLogicMapping&& 0 < frmLogicMapping.Count)
        {
            var objectscopes = frmLogicMapping.Values
                .Where(logics != null && logics.Count > 0)
                .SelectMany(logic => logic.ObjectScope)
                .Where(logic.ObjectScope!= null).ToList();

            bool returnValue = false;
            Parallel.ForEach(objectscopes, objectScope=>
            {
                if (objectScope.IsDirtyObject(objectID))
                {
                    returnValue  = true;
                }
            });
            return returnValue  ;
        }

但是以某种方式我混合了linq语句...而且我也不知道如何从并行foreach立即返回，或者如何将returnvalue标记为volatile

Thanxs，Offler

---

到目前为止的解决方案：Stephenx Borg的thanx

 if (null != objectScopes && 0 < objectScopes .Count)
        {
            System.Threading.Tasks.Task<bool>[] tasks = new System.Threading.Tasks.Task<bool>[objectScopes.Count];

            for (int i = 0; i < objectScope.Count; i++)
            {
                int temp= i;
                tasks[temp] = System.Threading.Tasks.Task.Factory.StartNew(() => { return objectScopes[temp].InUse(ID_in); }
                    , System.Threading.Tasks.TaskCreationOptions.LongRunning);
            }

            System.Threading.Tasks.Task.WaitAll(tasks);

            if (tasks.Any(x => x.Result == true))
            {
                return true;
            }
        } 

        return false;

Answer 1

另一种选择是创建一种方法来验证“列表”列表，并使用System.Threading.Tasks.Task，请在此处查看： http : //msdn.microsoft.com/zh-cn/library/system.threading.tasks。 task.aspx 。

您可以在结构上执行类似的操作：

Func DummyMethod = () =>{
                return true;
            };

            // Create list of tasks
            System.Threading.Tasks.Task[] tasks = new System.Threading.Tasks.Task[2];

            // First task
            var firstTask = System.Threading.Tasks.Task.Factory.StartNew(() => DummyMethod(), TaskCreationOptions.LongRunning);
            tasks[0] = firstTask;

            // Second task
            var secondTask = System.Threading.Tasks.Task.Factory.StartNew(() => DummyMethod(), TaskCreationOptions.LongRunning);
            tasks[1] = secondTask;

            // Launch all
            System.Threading.Tasks.Task.WaitAll(tasks);

            if (tasks.Any(x => x.Result)) { 
                Console.Write("In use!");
            }

在这种情况下，您需要循环执行任务结果，并检查返回的值是否为true。 这样做的好处是，所有列表将在单独的线程上一次运行。