C# List.Where方法代码示例

        private IEnumerable<Tuple<string, string>> GetAllNodeNameDescriptionPairs()
        {
            var pmExtension = dynamoViewModel.Model.GetPackageManagerExtension();
            var pkgLoader = pmExtension.PackageLoader;

            var workspaces = new List<CustomNodeWorkspaceModel>();
            foreach (var def in AllFuncDefs())
            {
                CustomNodeWorkspaceModel ws;
                if (dynamoViewModel.Model.CustomNodeManager.TryGetFunctionWorkspace(
                    def.FunctionId,
                    DynamoModel.IsTestMode,
                    out ws))
                {
                    workspaces.Add(ws);
                }
            }

            // collect the name-description pairs for every custom node
            return
                workspaces
                    .Where(
                        p =>
                            (pkgLoader.IsUnderPackageControl(p.FileName) && pkgLoader.GetOwnerPackage(p.FileName).Name == Name)
                                || !pmExtension.PackageLoader.IsUnderPackageControl(p.FileName))
                    .Select(
                        x =>
                            new Tuple<string, string>(
                            x.Name,
                            !String.IsNullOrEmpty(x.Description)
                                ? x.Description
                                : Wpf.Properties.Resources.MessageNoNodeDescription));
        }

        private IEnumerable<string> GetAllFiles()
        {
            // get all function defs
            var allFuncs = AllFuncDefs().ToList();

            // all workspaces
            var workspaces = new List<CustomNodeWorkspaceModel>();
            foreach (var def in allFuncs)
            {
                CustomNodeWorkspaceModel ws;
                if (dynamoViewModel.Model.CustomNodeManager.TryGetFunctionWorkspace(
                    def.FunctionId,
                    DynamoModel.IsTestMode,
                    out ws))
                {
                    workspaces.Add(ws);
                }
            }
            
            // make sure workspaces are saved
            var unsavedWorkspaceNames =
                workspaces.Where(ws => ws.HasUnsavedChanges || ws.FileName == null).Select(ws => ws.Name).ToList();
            if (unsavedWorkspaceNames.Any())
            {
                throw new Exception(Wpf.Properties.Resources.MessageUnsavedChanges0 +
                                    String.Join(", ", unsavedWorkspaceNames) +
                                    Wpf.Properties.Resources.MessageUnsavedChanges1);
            }

            var pmExtension = dynamoViewModel.Model.GetPackageManagerExtension();
            // omit files currently already under package control
            var files =
                workspaces.Select(f => f.FileName)
                    .Where(
                        p =>
                            (pmExtension.PackageLoader.IsUnderPackageControl(p)
                                && (pmExtension.PackageLoader.GetOwnerPackage(p).Name == Name)
                                || !pmExtension.PackageLoader.IsUnderPackageControl(p)));

            // union with additional files
            files = files.Union(AdditionalFiles);
            files = files.Union(Assemblies.Select(x => x.Assembly.Location));

            return files;
        }

        /// <summary>
        /// This method adds relevant models to the undo recorder.
        /// </summary>
        /// <param name="isGroupLayout">True if all the selected models are groups.</param>
        private void RecordUndoGraphLayout(bool isGroupLayout)
        {
            List<ModelBase> undoItems = new List<ModelBase>();

            if (!isGroupLayout)
            {
                // Add all selected items to the undo recorder
                undoItems.AddRange(Nodes);
                undoItems.AddRange(Notes);
                if (DynamoSelection.Instance.Selection.Count > 0)
                {
                    undoItems = undoItems.Where(x => x.IsSelected).ToList();
                }
            }
            else
            {
                // Add all models inside selected groups
                foreach (var group in Annotations)
                {
                    if (group.IsSelected)
                    {
                        group.Deselect();
                        undoItems.AddRange(group.SelectedModels);
                    }
                }
            }

            WorkspaceModel.RecordModelsForModification(undoItems, UndoRecorder);
        }

        protected override void LoadNode(XmlNode nodeElement)
        {
            selectionOwner = DocumentManager.Instance.CurrentDBDocument;

            selectedUniqueIds =
                nodeElement.ChildNodes.Cast<XmlNode>()
                    .Where(subNode => subNode.Name.Equals("instance") && subNode.Attributes != null)
                    .Select(subNode => subNode.Attributes[0].Value)
                    .ToList();

            selectedElements =
                selectedUniqueIds
                    .Where(id => DocumentManager.Instance.ElementExistsInDocument(new ElementUUID(id)))
                    .Select(selectionOwner.GetElement)
                    .Select(x => x.Id)
                    .ToList();

            RequiresRecalc = true;
            RaisePropertyChanged("SelectedElement");
        }

        /// <summary>
        /// Aggregates all upstream geometry for the given node then sends
        /// a message that a visualization is ready
        /// </summary>
        /// <param name="node">The node whose upstream geometry you need.</param>
        /// <returns>A render description containing all upstream geometry.</returns>
        public void AggregateUpstreamRenderPackages(RenderTag tag)
        {
            var packages = new List<IRenderPackage>();

            //send back just what the node needs
            var watch = new Stopwatch();
            watch.Start();

            if (tag.Node == null)
            {
                //send back everything
                List<NodeModel> copyOfNodesList = controller.DynamoModel.Nodes;
                foreach (var modelNode in copyOfNodesList)
                {
                    lock (modelNode.RenderPackagesMutex)
                    {
                        packages.AddRange(modelNode.RenderPackages);
                    }
                }

                watch.Stop();
                Debug.WriteLine(String.Format("RENDER: {0} ellapsed for aggregating geometry for background preview.", watch.Elapsed));

                if (packages.Any())
                {
                    // if there are packages, send any that aren't empty
                    OnResultsReadyToVisualize(this,
                        new VisualizationEventArgs(
                            packages.Where(x => ((RenderPackage)x).IsNotEmpty()).Cast<RenderPackage>(), string.Empty, tag.TaskId));
                }
                else
                {
                    // if there are no packages, still trigger an update
                    // so the view gets redrawn
                    OnResultsReadyToVisualize(this,
                        new VisualizationEventArgs(packages.Cast<RenderPackage>(), string.Empty, tag.TaskId));
                }

            }
            else
            {
                watch.Stop();
                Debug.WriteLine(String.Format("RENDER: {0} ellapsed for aggregating geometry for branch {1}.", watch.Elapsed, tag.Node.GUID));

                //send back renderables for the branch
                packages = GetUpstreamPackages(tag.Node.Inputs, 0).ToList();
                if (packages.Any())
                    OnResultsReadyToVisualize(this, new VisualizationEventArgs(packages.Where(x => ((RenderPackage)x).IsNotEmpty()).Cast<RenderPackage>(), tag.Node.GUID.ToString(),tag.TaskId));
            }

            

            //LogVisualizationUpdateData(rd, watch.Elapsed.ToString());
        }

        void SelectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == NotifyCollectionChangedAction.Reset)
                return;

            if (updatingPaused || dynSettings.Controller == null)
                return;

            var changes = new List<ISelectable>();

            // Any node that has a visualizations but is
            // no longer in the selection 
            changes.AddRange(dynSettings.Controller.DynamoModel.Nodes
                .Where(x => x.HasRenderPackages)
                .Where(x => !DynamoSelection.Instance.Selection.Contains(x)));

            if (e.NewItems != null && e.NewItems.Cast<ISelectable>().Any())
            {
                changes.AddRange(e.NewItems.Cast<ISelectable>());
            }

            UpdateRenderPackages(
            changes.Any() ?
            changes.Where(sel => sel is NodeModel).Cast<NodeModel>() :
            null);
        }